@typeberry/lib 0.2.0-e767e74 → 0.2.0-ef1ea0e

package/index.d.ts

@@ -322,7 +322,7 @@ type ErrorResult<Error> = {
   isOk: false;
   isError: true;
   error: Error;
-  details: string;
+  details: () => string;
 };
 
 /**
@@ -383,7 +383,7 @@ declare function resultToString<Ok, Error>(res: Result$2<Ok, Error>) {
   if (res.isOk) {
     return `OK: ${typeof res.ok === "symbol" ? res.ok.toString() : res.ok}`;
   }
-  return `${res.details}\nError: ${maybeTaggedErrorToString(res.error)}`;
+  return `${res.details()}\nError: ${maybeTaggedErrorToString(res.error)}`;
 }
 
 /** An indication of two possible outcomes returned from a function. */
@@ -402,7 +402,7 @@ declare const Result$2 = {
   },
 
   /** Create new [`Result`] with `Error` status. */
-  error: <Error>(error: Error, details = ""): ErrorResult<Error> => {
+  error: <Error>(error: Error, details: () => string): ErrorResult<Error> => {
     check`${error !== undefined} 'Error' type cannot be undefined.`;
     return {
       isOk: false,
@@ -556,7 +556,7 @@ declare function deepEqual<T>(
 
     if (actual.isError && expected.isError) {
       deepEqual(actual.error, expected.error, { context: ctx.concat(["error"]), errorsCollector: errors, ignore });
-      deepEqual(actual.details, expected.details, {
+      deepEqual(actual.details(), expected.details(), {
         context: ctx.concat(["details"]),
         errorsCollector: errors,
         // display details when error does not match
@@ -1467,8 +1467,8 @@ declare class Decoder {
   /**
    * Create a new [`Decoder`] instance given a raw array of bytes as a source.
    */
-  static fromBlob(source: Uint8Array) {
-    return new Decoder(source);
+  static fromBlob(source: Uint8Array, context?: unknown) {
+    return new Decoder(source, undefined, context);
   }
 
   /**
@@ -1818,7 +1818,7 @@ declare class Decoder {
   private ensureHasBytes(bytes: number) {
     check`${bytes >= 0} Negative number of bytes given.`;
     if (this.offset + bytes > this.source.length) {
-      throw new Error(
+      throw new EndOfDataError(
         `Attempting to decode more data than there is left. Need ${bytes}, left: ${this.source.length - this.offset}.`,
       );
     }
@@ -1837,6 +1837,8 @@ declare function decodeVariableLengthExtraBytes(firstByte: number) {
   return 0;
 }
 
+declare class EndOfDataError extends Error {}
+
 /** Hint for how big the encoded object will be. */
 type SizeHint = {
   /** Number of bytes in the encoding. */
@@ -2879,6 +2881,15 @@ declare namespace codec$1 {
     };
   })();
 
+  /** Zero-size `void` value. */
+  export const nothing = Descriptor.new<void>(
+    "void",
+    { bytes: 0, isExact: true },
+    (_e, _v) => {},
+    (_d) => {},
+    (_s) => {},
+  );
+
   /** Variable-length U32. */
   export const varU32 = Descriptor.new<U32>(
     "var_u32",
@@ -3346,6 +3357,9 @@ declare function forEachDescriptor<T>(
       try {
         f(k, descriptors[k]);
       } catch (e) {
+        if (e instanceof EndOfDataError) {
+          throw new EndOfDataError(`${key}: ${e}`);
+        }
         throw new Error(`${key}: ${e}`);
       }
     }
@@ -3469,6 +3483,8 @@ type index$q_DescriptorRecord<T> = DescriptorRecord<T>;
 type index$q_Encode<T> = Encode<T>;
 type index$q_Encoder = Encoder;
 declare const index$q_Encoder: typeof Encoder;
+type index$q_EndOfDataError = EndOfDataError;
+declare const index$q_EndOfDataError: typeof EndOfDataError;
 type index$q_LengthRange = LengthRange;
 declare const index$q_MASKS: typeof MASKS;
 declare const index$q_MAX_LENGTH: typeof MAX_LENGTH;
@@ -3497,7 +3513,7 @@ declare const index$q_sequenceViewVarLen: typeof sequenceViewVarLen;
 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 { 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_EndOfDataError as EndOfDataError, index$q_MASKS as MASKS, index$q_MAX_LENGTH as MAX_LENGTH, index$q_ObjectView as ObjectView, index$q_SequenceView as SequenceView, index$q_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, index$q_TYPICAL_SEQUENCE_LENGTH as TYPICAL_SEQUENCE_LENGTH, index$q_ViewField as ViewField, index$q_addSizeHints as addSizeHints, codec$1 as codec, index$q_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$q_exactHint as exactHint, index$q_forEachDescriptor as forEachDescriptor, index$q_hasUniqueView as hasUniqueView, index$q_objectView as objectView, index$q_readonlyArray as readonlyArray, index$q_sequenceViewFixLen as sequenceViewFixLen, index$q_sequenceViewVarLen as sequenceViewVarLen, index$q_tryAsExactBytes as tryAsExactBytes, index$q_validateLength as validateLength };
   export type { index$q_ClassConstructor as ClassConstructor, index$q_Codec as Codec, index$q_CodecRecord as CodecRecord, index$q_CodecWithView as CodecWithView, index$q_Decode as Decode, index$q_DescribedBy as DescribedBy, index$q_DescriptorRecord as DescriptorRecord, index$q_Encode as Encode, index$q_LengthRange as LengthRange, index$q_OptionalRecord as OptionalRecord, Options$1 as Options, index$q_PropertyKeys as PropertyKeys, index$q_SimpleDescriptorRecord as SimpleDescriptorRecord, index$q_SizeHint as SizeHint, index$q_ViewOf as ViewOf };
 }
 
@@ -4263,7 +4279,7 @@ declare class SortedArray<V> implements ImmutableSortedArray<V> {
     };
   }
 
-  /** Create a new SortedSet from two sorted collections. */
+  /** Create a new SortedArray from two sorted collections. */
   static fromTwoSortedCollections<V>(first: ImmutableSortedArray<V>, second: ImmutableSortedArray<V>) {
     check`${first.comparator === second.comparator} Cannot merge arrays if they do not use the same comparator`;
     const comparator = first.comparator;
@@ -5070,29 +5086,6 @@ declare const fullChainSpec = new ChainSpec({
   maxLookupAnchorAge: tryAsU32(14_400),
 });
 
-/**
- * Configuration object for typeberry workers.
- */
-declare class WorkerConfig {
-  /**
-   * Since we loose prototypes when transferring the context,
-   * this function is re-initializing proper types.
-   *
-   * TODO [ToDr] instead of doing this hack, we might prefer to pass data
-   * between workers using JAM codec maybe?
-   */
-  static reInit(config: unknown) {
-    const { chainSpec, dbPath, omitSealVerification } = config as WorkerConfig;
-    return new WorkerConfig(new ChainSpec(chainSpec), dbPath, omitSealVerification);
-  }
-
-  constructor(
-    public readonly chainSpec: ChainSpec,
-    public readonly dbPath: string,
-    public readonly omitSealVerification: boolean = false,
-  ) {}
-}
-
 /** Peer id. */
 type PeerId = Opaque<string, "peerId">;
 
@@ -5135,12 +5128,10 @@ declare const index$m_EST_VALIDATORS: typeof EST_VALIDATORS;
 declare const index$m_EST_VALIDATORS_SUPER_MAJORITY: typeof EST_VALIDATORS_SUPER_MAJORITY;
 type index$m_PeerAddress = PeerAddress;
 type index$m_PeerId = PeerId;
-type index$m_WorkerConfig = WorkerConfig;
-declare const index$m_WorkerConfig: typeof WorkerConfig;
 declare const index$m_fullChainSpec: typeof fullChainSpec;
 declare const index$m_tinyChainSpec: typeof tinyChainSpec;
 declare namespace index$m {
-  export { index$m_Bootnode as Bootnode, index$m_ChainSpec as ChainSpec, index$m_EC_SEGMENT_SIZE as EC_SEGMENT_SIZE, index$m_EST_CORES as EST_CORES, index$m_EST_EPOCH_LENGTH as EST_EPOCH_LENGTH, index$m_EST_VALIDATORS as EST_VALIDATORS, index$m_EST_VALIDATORS_SUPER_MAJORITY as EST_VALIDATORS_SUPER_MAJORITY, index$m_WorkerConfig as WorkerConfig, index$m_fullChainSpec as fullChainSpec, index$m_tinyChainSpec as tinyChainSpec };
+  export { index$m_Bootnode as Bootnode, index$m_ChainSpec as ChainSpec, index$m_EC_SEGMENT_SIZE as EC_SEGMENT_SIZE, index$m_EST_CORES as EST_CORES, index$m_EST_EPOCH_LENGTH as EST_EPOCH_LENGTH, index$m_EST_VALIDATORS as EST_VALIDATORS, index$m_EST_VALIDATORS_SUPER_MAJORITY as EST_VALIDATORS_SUPER_MAJORITY, index$m_fullChainSpec as fullChainSpec, index$m_tinyChainSpec as tinyChainSpec };
   export type { index$m_PeerAddress as PeerAddress, index$m_PeerId as PeerId };
 }
 
@@ -8192,7 +8183,7 @@ declare class NodeConfiguration {
       version: "number",
       flavor: knownChainSpecFromJson,
       chain_spec: JipChainSpec.fromJson,
-      database_base_path: "string",
+      database_base_path: json.optional("string"),
       authorship: AuthorshipOptions.fromJson,
     },
     NodeConfiguration.new,
@@ -8202,7 +8193,7 @@ declare class NodeConfiguration {
     if (version !== 1) {
       throw new Error("Only version=1 config is supported.");
     }
-    return new NodeConfiguration($schema, version, flavor, chain_spec, database_base_path, authorship);
+    return new NodeConfiguration($schema, version, flavor, chain_spec, database_base_path ?? undefined, authorship);
   }
 
   private constructor(
@@ -8210,7 +8201,8 @@ declare class NodeConfiguration {
     public readonly version: number,
     public readonly flavor: KnownChainSpec,
     public readonly chainSpec: JipChainSpec,
-    public readonly databaseBasePath: string,
+    /** If database path is not provided, we load an in-memory db. */
+    public readonly databaseBasePath: string | undefined,
     public readonly authorship: AuthorshipOptions,
   ) {}
 }
@@ -8285,6 +8277,8 @@ interface BlocksDb {
    * NOTE: this is not extrinsic hash!
    */
   getExtrinsic(hash: HeaderHash): ExtrinsicView | null;
+  /** Close the database and free resources. */
+  close(): Promise<void>;
 }
 
 /** In-memory (non-persistent) blocks database. */
@@ -8343,6 +8337,8 @@ declare class InMemoryBlocks implements BlocksDb {
   getExtrinsic(hash: HeaderHash): ExtrinsicView | null {
     return this.extrinsicsByHeaderHash.get(hash) ?? null;
   }
+
+  async close() {}
 }
 
 type StateKey$1 = Opaque<OpaqueHash, "trieStateKey">;
@@ -10659,7 +10655,6 @@ declare enum UpdatePreimageKind {
  */
 declare class UpdatePreimage {
   private constructor(
-    public readonly serviceId: ServiceId,
     public readonly action:
       | {
           kind: UpdatePreimageKind.Provide;
@@ -10679,16 +10674,8 @@ declare class UpdatePreimage {
   ) {}
 
   /** 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, {
+  static provide({ preimage, slot }: { preimage: PreimageItem; slot: TimeSlot | null }) {
+    return new UpdatePreimage({
       kind: UpdatePreimageKind.Provide,
       preimage,
       slot,
@@ -10696,8 +10683,8 @@ declare class UpdatePreimage {
   }
 
   /** The preimage should be removed completely from the database. */
-  static remove({ serviceId, hash, length }: { serviceId: ServiceId; hash: PreimageHash; length: U32 }) {
-    return new UpdatePreimage(serviceId, {
+  static remove({ hash, length }: { hash: PreimageHash; length: U32 }) {
+    return new UpdatePreimage({
       kind: UpdatePreimageKind.Remove,
       hash,
       length,
@@ -10705,8 +10692,8 @@ declare class UpdatePreimage {
   }
 
   /** Update the lookup history of some preimage or add a new one (request). */
-  static updateOrAdd({ serviceId, lookupHistory }: { serviceId: ServiceId; lookupHistory: LookupHistoryItem }) {
-    return new UpdatePreimage(serviceId, {
+  static updateOrAdd({ lookupHistory }: { lookupHistory: LookupHistoryItem }) {
+    return new UpdatePreimage({
       kind: UpdatePreimageKind.UpdateOrAdd,
       item: lookupHistory,
     });
@@ -10744,12 +10731,12 @@ declare enum UpdateServiceKind {
   /** Create a new `Service` instance. */
   Create = 1,
 }
+
 /**
- * Update service info of a particular `ServiceId` or create a new one.
+ * Update service info or create a new one.
  */
 declare class UpdateService {
   private constructor(
-    public readonly serviceId: ServiceId,
     public readonly action:
       | {
           kind: UpdateServiceKind.Update;
@@ -10762,23 +10749,21 @@ declare class UpdateService {
         },
   ) {}
 
-  static update({ serviceId, serviceInfo }: { serviceId: ServiceId; serviceInfo: ServiceAccountInfo }) {
-    return new UpdateService(serviceId, {
+  static update({ serviceInfo }: { serviceInfo: ServiceAccountInfo }) {
+    return new UpdateService({
       kind: UpdateServiceKind.Update,
       account: serviceInfo,
     });
   }
 
   static create({
-    serviceId,
     serviceInfo,
     lookupHistory,
   }: {
-    serviceId: ServiceId;
     serviceInfo: ServiceAccountInfo;
     lookupHistory: LookupHistoryItem | null;
   }) {
-    return new UpdateService(serviceId, {
+    return new UpdateService({
       kind: UpdateServiceKind.Create,
       account: serviceInfo,
       lookupHistory,
@@ -10800,7 +10785,6 @@ declare enum UpdateStorageKind {
  */
 declare class UpdateStorage {
   private constructor(
-    public readonly serviceId: ServiceId,
     public readonly action:
       | {
           kind: UpdateStorageKind.Set;
@@ -10812,12 +10796,12 @@ declare class UpdateStorage {
         },
   ) {}
 
-  static set({ serviceId, storage }: { serviceId: ServiceId; storage: StorageItem }) {
-    return new UpdateStorage(serviceId, { kind: UpdateStorageKind.Set, storage });
+  static set({ storage }: { storage: StorageItem }) {
+    return new UpdateStorage({ kind: UpdateStorageKind.Set, storage });
   }
 
-  static remove({ serviceId, key }: { serviceId: ServiceId; key: StorageKey }) {
-    return new UpdateStorage(serviceId, { kind: UpdateStorageKind.Remove, key });
+  static remove({ key }: { key: StorageKey }) {
+    return new UpdateStorage({ kind: UpdateStorageKind.Remove, key });
   }
 
   get key() {
@@ -10835,16 +10819,17 @@ declare class UpdateStorage {
   }
 }
 
-// TODO [ToDr] This would be more convenient to use if the data was grouped by `ServiceId`.
 type ServicesUpdate = {
   /** Service ids to remove from state alongside all their data. */
-  servicesRemoved: ServiceId[];
-  /** Services to update or create anew. */
-  servicesUpdates: UpdateService[];
+  removed: ServiceId[];
+  /** Services newly created. */
+  created: ServiceId[];
+  /** Services to update. */
+  updated: Map<ServiceId, UpdateService>;
   /** Service preimages to update and potentially lookup history */
-  preimages: UpdatePreimage[];
+  preimages: Map<ServiceId, UpdatePreimage[]>;
   /** Service storage to update. */
-  storage: UpdateStorage[];
+  storage: Map<ServiceId, UpdateStorage[]>;
 };
 
 declare enum UpdateError {
@@ -11040,13 +11025,13 @@ declare class InMemoryState extends WithDebug implements State, WithStateView, E
    * Modify the state and apply a single state update.
    */
   applyUpdate(update: Partial<State & ServicesUpdate>): Result$2<OK, UpdateError> {
-    const { servicesRemoved, servicesUpdates, preimages, storage, ...rest } = update;
+    const { removed, created: _, updated, preimages, storage, ...rest } = update;
     // just assign all other variables
     Object.assign(this, rest);
 
     // and update the services state
     let result: Result<OK, UpdateError>;
-    result = this.updateServices(servicesUpdates);
+    result = this.updateServices(updated);
     if (result.isError) {
       return result;
     }
@@ -11058,7 +11043,7 @@ declare class InMemoryState extends WithDebug implements State, WithStateView, E
     if (result.isError) {
       return result;
     }
-    this.removeServices(servicesRemoved);
+    this.removeServices(removed);
 
     return Result.ok(OK);
   }
@@ -11070,93 +11055,108 @@ declare class InMemoryState extends WithDebug implements State, WithStateView, E
     }
   }
 
-  private updateStorage(storage: UpdateStorage[] | undefined): Result$2<OK, UpdateError> {
-    for (const { serviceId, action } of storage ?? []) {
-      const { kind } = action;
-      const service = this.services.get(serviceId);
-      if (service === undefined) {
-        return Result.error(
-          UpdateError.NoService,
-          `Attempting to update storage of non-existing service: ${serviceId}`,
-        );
-      }
+  private updateStorage(storageUpdates: Map<ServiceId, UpdateStorage[]> | undefined): Result$2<OK, UpdateError> {
+    if (storageUpdates === undefined) {
+      return Result.ok(OK);
+    }
+    for (const [serviceId, updates] of storageUpdates.entries()) {
+      for (const update of updates) {
+        const { kind } = update.action;
+        const service = this.services.get(serviceId);
+        if (service === undefined) {
+          return Result.error(
+            UpdateError.NoService,
+            () => `Attempting to update storage of non-existing service: ${serviceId}`,
+          );
+        }
 
-      if (kind === UpdateStorageKind.Set) {
-        const { key, value } = action.storage;
-        service.data.storage.set(key.toString(), StorageItem.create({ key, value }));
-      } else if (kind === UpdateStorageKind.Remove) {
-        const { key } = action;
-        check`
+        if (kind === UpdateStorageKind.Set) {
+          const { key, value } = update.action.storage;
+          service.data.storage.set(key.toString(), StorageItem.create({ key, value }));
+        } else if (kind === UpdateStorageKind.Remove) {
+          const { key } = update.action;
+          check`
           ${service.data.storage.has(key.toString())}
-          Attempting to remove non-existing storage item at ${serviceId}: ${action.key}
+          Attempting to remove non-existing storage item at ${serviceId}: ${update.action.key}
         `;
-        service.data.storage.delete(key.toString());
-      } else {
-        assertNever(kind);
+          service.data.storage.delete(key.toString());
+        } else {
+          assertNever(kind);
+        }
       }
     }
-
     return Result.ok(OK);
   }
 
-  private updatePreimages(preimages: UpdatePreimage[] | undefined): Result$2<OK, UpdateError> {
-    for (const { serviceId, action } of preimages ?? []) {
+  private updatePreimages(preimagesUpdates: Map<ServiceId, UpdatePreimage[]> | undefined): Result$2<OK, UpdateError> {
+    if (preimagesUpdates === undefined) {
+      return Result.ok(OK);
+    }
+    for (const [serviceId, updates] of preimagesUpdates.entries()) {
       const service = this.services.get(serviceId);
       if (service === undefined) {
         return Result.error(
           UpdateError.NoService,
-          `Attempting to update preimage of non-existing service: ${serviceId}`,
+          () => `Attempting to update preimage of non-existing service: ${serviceId}`,
         );
       }
-      const { kind } = action;
-      if (kind === UpdatePreimageKind.Provide) {
-        const { preimage, slot } = action;
-        if (service.data.preimages.has(preimage.hash)) {
-          return Result.error(UpdateError.PreimageExists, `Overwriting existing preimage at ${serviceId}: ${preimage}`);
-        }
-        service.data.preimages.set(preimage.hash, preimage);
-        if (slot !== null) {
-          const lookupHistory = service.data.lookupHistory.get(preimage.hash);
-          const length = tryAsU32(preimage.blob.length);
-          const lookup = new LookupHistoryItem(preimage.hash, length, tryAsLookupHistorySlots([slot]));
-          if (lookupHistory === undefined) {
-            // no lookup history for that preimage at all (edge case, should be requested)
-            service.data.lookupHistory.set(preimage.hash, [lookup]);
-          } else {
-            // insert or replace exiting entry
-            const index = lookupHistory.map((x) => x.length).indexOf(length);
-            lookupHistory.splice(index, index === -1 ? 0 : 1, lookup);
+      for (const update of updates) {
+        const { kind } = update.action;
+        if (kind === UpdatePreimageKind.Provide) {
+          const { preimage, slot } = update.action;
+          if (service.data.preimages.has(preimage.hash)) {
+            return Result.error(
+              UpdateError.PreimageExists,
+              () => `Overwriting existing preimage at ${serviceId}: ${preimage}`,
+            );
           }
+          service.data.preimages.set(preimage.hash, preimage);
+          if (slot !== null) {
+            const lookupHistory = service.data.lookupHistory.get(preimage.hash);
+            const length = tryAsU32(preimage.blob.length);
+            const lookup = new LookupHistoryItem(preimage.hash, length, tryAsLookupHistorySlots([slot]));
+            if (lookupHistory === undefined) {
+              // no lookup history for that preimage at all (edge case, should be requested)
+              service.data.lookupHistory.set(preimage.hash, [lookup]);
+            } else {
+              // insert or replace exiting entry
+              const index = lookupHistory.map((x) => x.length).indexOf(length);
+              lookupHistory.splice(index, index === -1 ? 0 : 1, lookup);
+            }
+          }
+        } else if (kind === UpdatePreimageKind.Remove) {
+          const { hash, length } = update.action;
+          service.data.preimages.delete(hash);
+          const history = service.data.lookupHistory.get(hash) ?? [];
+          const idx = history.map((x) => x.length).indexOf(length);
+          if (idx !== -1) {
+            history.splice(idx, 1);
+          }
+        } else if (kind === UpdatePreimageKind.UpdateOrAdd) {
+          const { item } = update.action;
+          const history = service.data.lookupHistory.get(item.hash) ?? [];
+          const existingIdx = history.map((x) => x.length).indexOf(item.length);
+          const removeCount = existingIdx === -1 ? 0 : 1;
+          history.splice(existingIdx, removeCount, item);
+          service.data.lookupHistory.set(item.hash, history);
+        } else {
+          assertNever(kind);
         }
-      } else if (kind === UpdatePreimageKind.Remove) {
-        const { hash, length } = action;
-        service.data.preimages.delete(hash);
-        const history = service.data.lookupHistory.get(hash) ?? [];
-        const idx = history.map((x) => x.length).indexOf(length);
-        if (idx !== -1) {
-          history.splice(idx, 1);
-        }
-      } else if (kind === UpdatePreimageKind.UpdateOrAdd) {
-        const { item } = action;
-        const history = service.data.lookupHistory.get(item.hash) ?? [];
-        const existingIdx = history.map((x) => x.length).indexOf(item.length);
-        const removeCount = existingIdx === -1 ? 0 : 1;
-        history.splice(existingIdx, removeCount, item);
-        service.data.lookupHistory.set(item.hash, history);
-      } else {
-        assertNever(kind);
       }
     }
     return Result.ok(OK);
   }
 
-  private updateServices(servicesUpdates?: UpdateService[]): Result$2<OK, UpdateError> {
-    for (const { serviceId, action } of servicesUpdates ?? []) {
-      const { kind, account } = action;
+  private updateServices(servicesUpdates: Map<ServiceId, UpdateService> | undefined): Result$2<OK, UpdateError> {
+    if (servicesUpdates === undefined) {
+      return Result.ok(OK);
+    }
+    for (const [serviceId, update] of servicesUpdates.entries()) {
+      const { kind, account } = update.action;
       if (kind === UpdateServiceKind.Create) {
-        const { lookupHistory } = action;
+        const { lookupHistory } = update.action;
         if (this.services.has(serviceId)) {
-          return Result.error(UpdateError.DuplicateService, `${serviceId} already exists!`);
+          return Result.error(UpdateError.DuplicateService, () => `${serviceId} already exists!`);
         }
         this.services.set(
           serviceId,
@@ -11172,7 +11172,7 @@ declare class InMemoryState extends WithDebug implements State, WithStateView, E
       } else if (kind === UpdateServiceKind.Update) {
         const existingService = this.services.get(serviceId);
         if (existingService === undefined) {
-          return Result.error(UpdateError.NoService, `Cannot update ${serviceId} because it does not exist.`);
+          return Result.error(UpdateError.NoService, () => `Cannot update ${serviceId} because it does not exist.`);
         }
         existingService.data.info = account;
       } else {
@@ -11975,89 +11975,104 @@ declare function* serializeStateUpdate(
   const encode = <T>(codec: Encode<T>, val: T) => Encoder.encodeObject(codec, val, spec);
 
   // then let's proceed with service updates
-  yield* serializeServiceUpdates(update.servicesUpdates, encode, blake2b);
+  yield* serializeServiceUpdates(update.updated, encode, blake2b);
   yield* serializePreimages(update.preimages, encode, blake2b);
   yield* serializeStorage(update.storage, blake2b);
-  yield* serializeRemovedServices(update.servicesRemoved);
+  yield* serializeRemovedServices(update.removed);
 }
 
 declare function* serializeRemovedServices(servicesRemoved: ServiceId[] | undefined): Generator<StateEntryUpdate> {
-  for (const serviceId of servicesRemoved ?? []) {
+  if (servicesRemoved === undefined) {
+    return;
+  }
+  for (const serviceId of servicesRemoved) {
     // TODO [ToDr] what about all data associated with a service?
     const codec = serialize.serviceData(serviceId);
     yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
   }
 }
 
-declare function* serializeStorage(storage: UpdateStorage[] | undefined, blake2b: Blake2b): Generator<StateEntryUpdate> {
-  for (const { action, serviceId } of storage ?? []) {
-    switch (action.kind) {
-      case UpdateStorageKind.Set: {
-        const key = action.storage.key;
-        const codec = serialize.serviceStorage(blake2b, serviceId, key);
-        yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
-        break;
-      }
-      case UpdateStorageKind.Remove: {
-        const key = action.key;
-        const codec = serialize.serviceStorage(blake2b, serviceId, key);
-        yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
-        break;
+declare function* serializeStorage(
+  storageUpdates: Map<ServiceId, UpdateStorage[]> | undefined,
+  blake2b: Blake2b,
+): Generator<StateEntryUpdate> {
+  if (storageUpdates === undefined) {
+    return;
+  }
+  for (const [serviceId, updates] of storageUpdates.entries()) {
+    for (const { action } of updates) {
+      switch (action.kind) {
+        case UpdateStorageKind.Set: {
+          const key = action.storage.key;
+          const codec = serialize.serviceStorage(blake2b, serviceId, key);
+          yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
+          break;
+        }
+        case UpdateStorageKind.Remove: {
+          const key = action.key;
+          const codec = serialize.serviceStorage(blake2b, serviceId, key);
+          yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
+          break;
+        }
       }
-      default:
-        assertNever(action);
     }
   }
 }
 
 declare function* serializePreimages(
-  preimages: UpdatePreimage[] | undefined,
+  preimagesUpdates: Map<ServiceId, UpdatePreimage[]> | undefined,
   encode: EncodeFun,
   blake2b: Blake2b,
 ): Generator<StateEntryUpdate> {
-  for (const { action, serviceId } of preimages ?? []) {
-    switch (action.kind) {
-      case UpdatePreimageKind.Provide: {
-        const { hash, blob } = action.preimage;
-        const codec = serialize.servicePreimages(blake2b, serviceId, hash);
-        yield [StateEntryUpdateAction.Insert, codec.key, blob];
-
-        if (action.slot !== null) {
-          const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, tryAsU32(blob.length));
-          yield [
-            StateEntryUpdateAction.Insert,
-            codec2.key,
-            encode(codec2.Codec, tryAsLookupHistorySlots([action.slot])),
-          ];
+  if (preimagesUpdates === undefined) {
+    return;
+  }
+  for (const [serviceId, updates] of preimagesUpdates.entries()) {
+    for (const { action } of updates) {
+      switch (action.kind) {
+        case UpdatePreimageKind.Provide: {
+          const { hash, blob } = action.preimage;
+          const codec = serialize.servicePreimages(blake2b, serviceId, hash);
+          yield [StateEntryUpdateAction.Insert, codec.key, blob];
+
+          if (action.slot !== null) {
+            const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, tryAsU32(blob.length));
+            yield [
+              StateEntryUpdateAction.Insert,
+              codec2.key,
+              encode(codec2.Codec, tryAsLookupHistorySlots([action.slot])),
+            ];
+          }
+          break;
         }
-        break;
-      }
-      case UpdatePreimageKind.UpdateOrAdd: {
-        const { hash, length, slots } = action.item;
-        const codec = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
-        yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, slots)];
-        break;
-      }
-      case UpdatePreimageKind.Remove: {
-        const { hash, length } = action;
-        const codec = serialize.servicePreimages(blake2b, serviceId, hash);
-        yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
+        case UpdatePreimageKind.UpdateOrAdd: {
+          const { hash, length, slots } = action.item;
+          const codec = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
+          yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, slots)];
+          break;
+        }
+        case UpdatePreimageKind.Remove: {
+          const { hash, length } = action;
+          const codec = serialize.servicePreimages(blake2b, serviceId, hash);
+          yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
 
-        const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
-        yield [StateEntryUpdateAction.Remove, codec2.key, EMPTY_BLOB];
-        break;
+          const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
+          yield [StateEntryUpdateAction.Remove, codec2.key, EMPTY_BLOB];
+          break;
+        }
       }
-      default:
-        assertNever(action);
     }
   }
 }
 declare function* serializeServiceUpdates(
-  servicesUpdates: UpdateService[] | undefined,
+  servicesUpdates: Map<ServiceId, UpdateService> | undefined,
   encode: EncodeFun,
   blake2b: Blake2b,
 ): Generator<StateEntryUpdate> {
-  for (const { action, serviceId } of servicesUpdates ?? []) {
+  if (servicesUpdates === undefined) {
+    return;
+  }
+  for (const [serviceId, { action }] of servicesUpdates.entries()) {
     // new service being created or updated
     const codec = serialize.serviceData(serviceId);
     yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, action.account)];
@@ -12646,7 +12661,7 @@ interface ValuesDb {
    * Missing value is considered an irrecoverable error, so the implementations
    * are free to throw if that happens.
    */
-  get(key: Uint8Array): Uint8Array;
+  get(key: ValueHash): Uint8Array;
 }
 
 /**
@@ -12663,7 +12678,7 @@ declare class LeafDb implements SerializedStateBackend {
     if (blob.length % TRIE_NODE_BYTES !== 0) {
       return Result.error(
         LeafDbError.InvalidLeafData,
-        `${blob.length} is not a multiply of ${TRIE_NODE_BYTES}: ${blob}`,
+        () => `${blob.length} is not a multiply of ${TRIE_NODE_BYTES}: ${blob}`,
       );
     }
 
@@ -12671,7 +12686,7 @@ declare class LeafDb implements SerializedStateBackend {
     for (const nodeData of blob.chunks(TRIE_NODE_BYTES)) {
       const node = new TrieNode(nodeData.raw);
       if (node.getNodeType() === NodeType.Branch) {
-        return Result.error(LeafDbError.InvalidLeafData, `Branch node detected: ${nodeData}`);
+        return Result.error(LeafDbError.InvalidLeafData, () => `Branch node detected: ${nodeData}`);
       }
       leaves.insert(node.asLeafNode());
     }
@@ -12679,15 +12694,20 @@ declare class LeafDb implements SerializedStateBackend {
     return Result.ok(new LeafDb(leaves, db));
   }
 
+  /** Create leaf db from sorted set of leaves. */
+  static fromLeaves(leaves: SortedSet<LeafNode>, db: ValuesDb): LeafDb {
+    return new LeafDb(leaves, db);
+  }
+
   /** A mapping between an embedded value or db lookup key. */
   private readonly lookup: TruncatedHashDictionary<StateKey, Lookup>;
 
   private constructor(
-    public readonly leaves: SortedSet<LeafNode>,
+    public readonly leafs: SortedSet<LeafNode>,
     public readonly db: ValuesDb,
   ) {
     this.lookup = TruncatedHashDictionary.fromEntries(
-      leaves.array.map((leaf) => {
+      leafs.array.map((leaf) => {
         const key: StateKey = leaf.getKey().asOpaque();
         const value: Lookup = leaf.hasEmbeddedValue()
           ? {
@@ -12696,7 +12716,7 @@ declare class LeafDb implements SerializedStateBackend {
             }
           : {
               kind: LookupKind.DbKey,
-              key: leaf.getValueHash().raw,
+              key: leaf.getValueHash(),
             };
         return [key, value];
       }),
@@ -12722,7 +12742,7 @@ declare class LeafDb implements SerializedStateBackend {
 
   getStateRoot(blake2b: Blake2b): StateRootHash {
     const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
-    return InMemoryTrie.computeStateRoot(blake2bTrieHasher, this.leaves).asOpaque();
+    return InMemoryTrie.computeStateRoot(blake2bTrieHasher, this.leafs).asOpaque();
   }
 
   intoStateEntries(): StateEntries {
@@ -12756,9 +12776,42 @@ type Lookup =
     }
   | {
       kind: LookupKind.DbKey;
-      key: Uint8Array;
+      key: ValueHash;
     };
 
+declare function updateLeafs(
+  leafs: SortedSet<LeafNode>,
+  blake2b: Blake2b,
+  data: Iterable<[StateEntryUpdateAction, StateKey | TruncatedHash, BytesBlob]>,
+): {
+  values: [ValueHash, BytesBlob][];
+  leafs: SortedSet<LeafNode>;
+} {
+  const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
+  // We will collect all values that don't fit directly into leaf nodes.
+  const values: [ValueHash, BytesBlob][] = [];
+  for (const [action, key, value] of data) {
+    if (action === StateEntryUpdateAction.Insert) {
+      const leafNode = InMemoryTrie.constructLeaf(blake2bTrieHasher, key.asOpaque(), value);
+      leafs.replace(leafNode);
+      if (!leafNode.hasEmbeddedValue()) {
+        values.push([leafNode.getValueHash(), value]);
+      }
+    } else if (action === StateEntryUpdateAction.Remove) {
+      const leafNode = InMemoryTrie.constructLeaf(blake2bTrieHasher, key.asOpaque(), BytesBlob.empty());
+      leafs.removeOne(leafNode);
+      // TODO [ToDr] Handle ref-counting values or updating some header-hash-based references.
+    } else {
+      assertNever(action);
+    }
+  }
+
+  return {
+    values,
+    leafs,
+  };
+}
+
 /** A potential error that occured during state update. */
 declare enum StateUpdateError {
   /** A conflicting state update has been provided. */
@@ -12766,6 +12819,13 @@ declare enum StateUpdateError {
   /** There was an error committing the changes. */
   Commit = 1,
 }
+
+/** Interface to initialize states db. Typically used in conjunction with `StatesDb`. */
+interface InitStatesDb<T = State> {
+  /** Insert a pre-defined initial state directly into the database. */
+  insertInitialState(headerHash: HeaderHash, initialState: T): Promise<Result$2<OK, StateUpdateError>>;
+}
+
 /**
  * Interface for accessing states stored in the database.
  *
@@ -12791,12 +12851,18 @@ interface StatesDb<T extends State = State> {
 
   /** Retrieve posterior state of given header. */
   getState(header: HeaderHash): T | null;
+
+  /** Close the database and free resources. */
+  close(): Promise<void>;
 }
 
 declare class InMemoryStates implements StatesDb<InMemoryState> {
-  private readonly db: HashDictionary<HeaderHash, BytesBlob> = HashDictionary.new();
+  private readonly db: HashDictionary<HeaderHash, InMemoryState> = HashDictionary.new();
+  private readonly blake2b: Promise<Blake2b>;
 
-  constructor(private readonly spec: ChainSpec) {}
+  constructor(private readonly spec: ChainSpec) {
+    this.blake2b = Blake2b.createHasher();
+  }
 
   async updateAndSetState(
     headerHash: HeaderHash,
@@ -12805,7 +12871,7 @@ declare class InMemoryStates implements StatesDb<InMemoryState> {
   ): Promise<Result$2<OK, StateUpdateError>> {
     const res = state.applyUpdate(update);
     if (res.isOk) {
-      return await this.insertState(headerHash, state);
+      return await this.insertInitialState(headerHash, state);
     }
 
     switch (res.error) {
@@ -12819,32 +12885,126 @@ declare class InMemoryStates implements StatesDb<InMemoryState> {
   }
 
   async getStateRoot(state: InMemoryState): Promise<StateRootHash> {
-    const blake2b = await Blake2b.createHasher();
+    const blake2b = await this.blake2b;
     return StateEntries.serializeInMemory(this.spec, blake2b, state).getRootHash(blake2b);
   }
 
   /** Insert a full state into the database. */
-  async insertState(headerHash: HeaderHash, state: InMemoryState): Promise<Result$2<OK, StateUpdateError>> {
-    const encoded = Encoder.encodeObject(inMemoryStateCodec(this.spec), state, this.spec);
-    this.db.set(headerHash, encoded);
+  async insertInitialState(headerHash: HeaderHash, state: InMemoryState): Promise<Result$2<OK, StateUpdateError>> {
+    const copy = InMemoryState.copyFrom(this.spec, state, state.intoServicesData());
+    this.db.set(headerHash, copy);
     return Result.ok(OK);
   }
 
   getState(headerHash: HeaderHash): InMemoryState | null {
-    const encodedState = this.db.get(headerHash);
-    if (encodedState === undefined) {
+    const state = this.db.get(headerHash);
+    if (state === undefined) {
       return null;
     }
 
-    return Decoder.decodeObject(inMemoryStateCodec(this.spec), encodedState, this.spec);
+    return InMemoryState.copyFrom(this.spec, state, state.intoServicesData());
+  }
+
+  async close() {}
+}
+
+/** Root database. */
+interface RootDb<TBlocks = BlocksDb, TStates = StatesDb> {
+  /** Blocks DB. */
+  getBlocksDb(): TBlocks;
+
+  /** States DB. */
+  getStatesDb(): TStates;
+
+  /** Close access to the DB. */
+  close(): Promise<void>;
+}
+
+/** Abstract serialized-states db. */
+type SerializedStatesDb = StatesDb<SerializedState<LeafDb>> & InitStatesDb<StateEntries>;
+
+/** In-memory serialized-states db. */
+declare class InMemorySerializedStates implements StatesDb<SerializedState<LeafDb>>, InitStatesDb<StateEntries> {
+  private readonly db: HashDictionary<HeaderHash, SortedSet<LeafNode>> = HashDictionary.new();
+  private readonly valuesDb: HashDictionary<ValueHash, BytesBlob> = HashDictionary.new();
+
+  constructor(
+    private readonly spec: ChainSpec,
+    private readonly blake2b: Blake2b,
+  ) {}
+
+  async insertInitialState(headerHash: HeaderHash, entries: StateEntries): Promise<Result$2<OK, StateUpdateError>> {
+    // convert state entries into leafdb
+    const { values, leafs } = updateLeafs(
+      SortedSet.fromArray(leafComparator, []),
+      this.blake2b,
+      Array.from(entries, (x) => [StateEntryUpdateAction.Insert, x[0], x[1]]),
+    );
+
+    // insert values to the db.
+    for (const val of values) {
+      this.valuesDb.set(val[0], val[1]);
+    }
+
+    this.db.set(headerHash, leafs);
+    return Result.ok(OK);
+  }
+
+  async getStateRoot(state: SerializedState<LeafDb>): Promise<StateRootHash> {
+    return state.backend.getStateRoot(this.blake2b);
+  }
+
+  async updateAndSetState(
+    header: HeaderHash,
+    state: SerializedState<LeafDb>,
+    update: Partial<State & ServicesUpdate>,
+  ): Promise<Result$2<OK, StateUpdateError>> {
+    const blake2b = this.blake2b;
+    const updatedValues = serializeStateUpdate(this.spec, blake2b, update);
+    const { values, leafs } = updateLeafs(state.backend.leafs, blake2b, updatedValues);
+
+    // insert values to the db
+    // valuesdb can be shared between all states because it's just
+    // <valuehash> -> <value> mapping and existence is managed by trie leafs.
+    for (const val of values) {
+      this.valuesDb.set(val[0], val[1]);
+    }
+
+    // make sure to clone the leafs before writing, since the collection is re-used.
+    this.db.set(header, SortedSet.fromSortedArray(leafComparator, leafs.slice()));
+
+    return Result.ok(OK);
+  }
+
+  getState(header: HeaderHash): SerializedState<LeafDb> | null {
+    const leafs = this.db.get(header);
+    if (leafs === undefined) {
+      return null;
+    }
+    // now create a leafdb with shared values db.
+    const leafDb = LeafDb.fromLeaves(leafs, {
+      get: (key: ValueHash) => {
+        const val = this.valuesDb.get(key);
+        if (val === undefined) {
+          throw new Error(`Missing value at key: ${key}`);
+        }
+        return val.raw;
+      },
+    });
+    return SerializedState.new(this.spec, this.blake2b, leafDb);
   }
+
+  async close() {}
 }
 
 type index$c_BlocksDb = BlocksDb;
 type index$c_InMemoryBlocks = InMemoryBlocks;
 declare const index$c_InMemoryBlocks: typeof InMemoryBlocks;
+type index$c_InMemorySerializedStates = InMemorySerializedStates;
+declare const index$c_InMemorySerializedStates: typeof InMemorySerializedStates;
 type index$c_InMemoryStates = InMemoryStates;
 declare const index$c_InMemoryStates: typeof InMemoryStates;
+type index$c_InitStatesDb<T = State> = InitStatesDb<T>;
 type index$c_LeafDb = LeafDb;
 declare const index$c_LeafDb: typeof LeafDb;
 type index$c_LeafDbError = LeafDbError;
@@ -12852,13 +13012,16 @@ declare const index$c_LeafDbError: typeof LeafDbError;
 type index$c_Lookup = Lookup;
 type index$c_LookupKind = LookupKind;
 declare const index$c_LookupKind: typeof LookupKind;
+type index$c_RootDb<TBlocks = BlocksDb, TStates = StatesDb> = RootDb<TBlocks, TStates>;
+type index$c_SerializedStatesDb = SerializedStatesDb;
 type index$c_StateUpdateError = StateUpdateError;
 declare const index$c_StateUpdateError: typeof StateUpdateError;
 type index$c_StatesDb<T extends State = State> = StatesDb<T>;
 type index$c_ValuesDb = ValuesDb;
+declare const index$c_updateLeafs: typeof updateLeafs;
 declare namespace index$c {
-  export { index$c_InMemoryBlocks as InMemoryBlocks, index$c_InMemoryStates as InMemoryStates, index$c_LeafDb as LeafDb, index$c_LeafDbError as LeafDbError, index$c_LookupKind as LookupKind, index$c_StateUpdateError as StateUpdateError };
-  export type { index$c_BlocksDb as BlocksDb, index$c_Lookup as Lookup, index$c_StatesDb as StatesDb, index$c_ValuesDb as ValuesDb };
+  export { index$c_InMemoryBlocks as InMemoryBlocks, index$c_InMemorySerializedStates as InMemorySerializedStates, index$c_InMemoryStates as InMemoryStates, index$c_LeafDb as LeafDb, index$c_LeafDbError as LeafDbError, index$c_LookupKind as LookupKind, index$c_StateUpdateError as StateUpdateError, index$c_updateLeafs as updateLeafs };
+  export type { index$c_BlocksDb as BlocksDb, index$c_InitStatesDb as InitStatesDb, index$c_Lookup as Lookup, index$c_RootDb as RootDb, index$c_SerializedStatesDb as SerializedStatesDb, index$c_StatesDb as StatesDb, index$c_ValuesDb as ValuesDb };
 }
 
 /**
@@ -14196,6 +14359,82 @@ interface GasCounter {
   sub(g: Gas): boolean;
 }
 
+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;
+  }
+}
+
 /**
  * Mask class is an implementation of skip function defined in GP.
  *
@@ -14365,99 +14604,23 @@ 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;
+declare class NibblesDecoder {
+  private byte = new Int8Array(1);
 
-  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);
+  setByte(byte: number) {
+    this.byte[0] = byte;
   }
 
-  static fromBytes(bytes: Uint8Array) {
-    check`${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
-    return new Registers(bytes);
+  getHighNibble() {
+    return (this.byte[0] & 0xf0) >>> 4;
   }
 
-  getBytesAsLittleEndian(index: number, len: number) {
-    const offset = index << REGISTER_SIZE_SHIFT;
-    return this.bytes.subarray(offset, offset + len);
+  getLowNibble() {
+    return this.byte[0] & 0x0f;
   }
 
-  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);
-
-  setByte(byte: number) {
-    this.byte[0] = byte;
-  }
-
-  getHighNibble() {
-    return (this.byte[0] & 0xf0) >>> 4;
-  }
-
-  getLowNibble() {
-    return this.byte[0] & 0x0f;
-  }
-
-  getHighNibbleAsRegisterIndex() {
-    return Math.min(this.getHighNibble(), MAX_REGISTER_INDEX);
+  getHighNibbleAsRegisterIndex() {
+    return Math.min(this.getHighNibble(), MAX_REGISTER_INDEX);
   }
 
   getLowNibbleAsRegisterIndex() {
@@ -15483,7 +15646,7 @@ declare class Memory {
     const pagesResult = this.getPages(address, bytes.length, AccessType.WRITE);
 
     if (pagesResult.isError) {
-      return Result.error(pagesResult.error);
+      return Result.error(pagesResult.error, pagesResult.details);
     }
 
     const pages = pagesResult.ok;
@@ -15516,17 +15679,23 @@ declare class Memory {
 
     for (const pageNumber of pageRange) {
       if (pageNumber < RESERVED_NUMBER_OF_PAGES) {
-        return Result.error(PageFault.fromPageNumber(pageNumber, true));
+        return Result.error(
+          PageFault.fromPageNumber(pageNumber, true),
+          () => `Page fault: attempted to access reserved page ${pageNumber}`,
+        );
       }
 
       const page = this.memory.get(pageNumber);
 
       if (page === undefined) {
-        return Result.error(PageFault.fromPageNumber(pageNumber));
+        return Result.error(PageFault.fromPageNumber(pageNumber), () => `Page fault: page ${pageNumber} not allocated`);
       }
 
       if (accessType === AccessType.WRITE && !page.isWriteable()) {
-        return Result.error(PageFault.fromPageNumber(pageNumber, true));
+        return Result.error(
+          PageFault.fromPageNumber(pageNumber, true),
+          () => `Page fault: attempted to write to read-only page ${pageNumber}`,
+        );
       }
 
       pages.push(page);
@@ -15548,7 +15717,7 @@ declare class Memory {
     const pagesResult = this.getPages(startAddress, result.length, AccessType.READ);
 
     if (pagesResult.isError) {
-      return Result.error(pagesResult.error);
+      return Result.error(pagesResult.error, pagesResult.details);
     }
 
     const pages = pagesResult.ok;
@@ -17533,7 +17702,7 @@ declare class ProgramDecoder {
       return Result.ok(new ProgramDecoder(program));
     } catch (e) {
       logger.error`Invalid program: ${e}`;
-      return Result.error(ProgramDecoderError.InvalidProgramError);
+      return Result.error(ProgramDecoderError.InvalidProgramError, () => `Program decoder error: ${e}`);
     }
   }
 }
@@ -17877,870 +18046,896 @@ 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));
-
-/** 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,
-    };
-  }
+interface IHostCallMemory {
+  storeFrom(address: U64, bytes: Uint8Array): Result$2<OK, PageFault | OutOfBounds>;
+  loadInto(result: Uint8Array, startAddress: U64): Result$2<OK, PageFault | OutOfBounds>;
 }
 
-type MachineStatus =
-  | {
-      status: typeof Status.HOST;
-      hostCallIndex: U64;
+declare class HostCallMemory implements IHostCallMemory {
+  constructor(private readonly memory: Memory) {}
+
+  storeFrom(address: U64, bytes: Uint8Array): Result$2<OK, PageFault | OutOfBounds> {
+    if (bytes.length === 0) {
+      return Result.ok(OK);
     }
-  | {
-      status: typeof Status.FAULT;
-      address: U64;
+
+    if (address + tryAsU64(bytes.length) > MEMORY_SIZE) {
+      return Result.error(
+        new OutOfBounds(),
+        () => `Memory access out of bounds: address ${address} + length ${bytes.length} exceeds memory size`,
+      );
     }
-  | {
-      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;
-};
+    return this.memory.storeFrom(tryAsMemoryIndex(Number(address)), bytes);
+  }
 
-/** 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,
-}
+  loadInto(result: Uint8Array, startAddress: U64): Result$2<OK, PageFault | OutOfBounds> {
+    if (result.length === 0) {
+      return Result.ok(OK);
+    }
 
-/** 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;
+    if (startAddress + tryAsU64(result.length) > MEMORY_SIZE) {
+      return Result.error(
+        new OutOfBounds(),
+        () => `Memory access out of bounds: address ${startAddress} + length ${result.length} exceeds memory size`,
+      );
+    }
 
-/** 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.memory.loadInto(result, tryAsMemoryIndex(Number(startAddress)));
+  }
 }
 
-declare enum ZeroVoidError {
-  /** No machine under given machine index. */
-  NoMachine = 0,
-  /** Attempting to void or zero non-accessible page. */
-  InvalidPage = 1,
+interface IHostCallRegisters {
+  get(registerIndex: number): U64;
+  set(registerIndex: number, value: U64): void;
 }
 
-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 PartiallyUpdatedState<T extends StateSlice = StateSlice> {
-  /** A collection of state updates. */
-  public readonly stateUpdate;
-
-  constructor(
-    /** Original (unmodified state). */
-    public readonly state: T,
-    stateUpdate?: AccumulationStateUpdate,
+declare class ReturnValue {
+  private constructor(
+    public consumedGas: Gas,
+    public status: Status | null,
+    public memorySlice: Uint8Array | null,
   ) {
-    this.stateUpdate =
-      stateUpdate === undefined ? AccumulationStateUpdate.empty() : AccumulationStateUpdate.copyFrom(stateUpdate);
+    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
+    `;
   }
 
-  /**
-   * 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;
-    }
+  static fromStatus(consumedGas: Gas, status: Status) {
+    return new ReturnValue(consumedGas, status, 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);
-    };
+      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);
 
-    if (updatedPreimage === undefined) {
-      return stateFallback();
-    }
+      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(),
+      );
 
-    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]));
+      if (result === PvmExecution.Halt) {
+        status = Status.HALT;
+        return this.getReturnValue(status, pvmInstance);
       }
-      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]));
+      if (result === PvmExecution.Panic) {
+        status = Status.PANIC;
+        return this.getReturnValue(status, pvmInstance);
       }
-      case UpdatePreimageKind.UpdateOrAdd: {
-        return action.item;
+
+      if (result === PvmExecution.OOG) {
+        status = Status.OOG;
+        return this.getReturnValue(status, pvmInstance);
       }
+
+      if (result === undefined) {
+        pvmInstance.runProgram();
+        status = pvmInstance.getStatus();
+        continue;
+      }
+
+      assertNever(result);
     }
+  }
 
-    assertNever(action);
+  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);
+    }
   }
+}
 
-  /* State update functions. */
+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 };
+}
 
-  updateStorage(serviceId: ServiceId, key: StorageKey, value: BytesBlob | null) {
-    const update =
-      value === null
-        ? UpdateStorage.remove({ serviceId, key })
-        : UpdateStorage.set({
-            serviceId,
-            storage: StorageItem.create({ key, value }),
-          });
+/**
+ * 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));
 
-    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);
-  }
+/** 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));
 
-  /**
-   * 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 MachineInstance {
+  async run(gas: BigGas, registers: Registers): Promise<MachineResult> {
+    return {
+      result: {
+        status: Status.OK,
+      },
+      gas,
+      registers,
+    };
   }
+}
 
-  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}`;
+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;
+    };
 
-    const overflowItems = !isU32(items);
-    const overflowBytes = !isU64(bytes);
+/** Data returned by a machine invocation. */
+type MachineResult = {
+  result: MachineStatus;
+  gas: BigGas;
+  registers: Registers;
+};
 
-    // TODO [ToDr] this is not specified in GP, but it seems sensible.
-    if (overflowItems || overflowBytes) {
-      return Result.error(InsufficientFundsError);
-    }
+/** 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,
+}
 
-    const thresholdBalance = ServiceAccountInfo.calculateThresholdBalance(items, bytes, serviceInfo.gratisStorage);
-    if (serviceInfo.balance < thresholdBalance) {
-      return Result.error(InsufficientFundsError);
-    }
+/** 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;
 
-    // Update service info with new details.
-    this.updateServiceInfo(
-      serviceId,
-      ServiceAccountInfo.create({
-        ...serviceInfo,
-        storageUtilisationBytes: bytes,
-        storageUtilisationCount: items,
-      }),
-    );
-    return Result.ok(OK);
-  }
+/** 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,
+}
 
-  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];
-
-    if (existingItem?.action.kind === UpdateServiceKind.Create) {
-      this.stateUpdate.services.servicesUpdates.splice(
-        idx,
-        toRemove,
-        UpdateService.create({
-          serviceId,
-          serviceInfo: newInfo,
-          lookupHistory: existingItem.action.lookupHistory,
-        }),
-      );
+declare enum ZeroVoidError {
+  /** No machine under given machine index. */
+  NoMachine = 0,
+  /** Attempting to void or zero non-accessible page. */
+  InvalidPage = 1,
+}
 
-      return;
-    }
+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,
+}
 
-    this.stateUpdate.services.servicesUpdates.splice(
-      idx,
-      toRemove,
-      UpdateService.update({
-        serviceId,
-        serviceInfo: newInfo,
-      }),
-    );
-  }
+/** Error machine is not found. */
+declare const NoMachineError = Symbol("Machine index not found.");
+type NoMachineError = typeof NoMachineError;
 
-  getPrivilegedServices() {
-    if (this.stateUpdate.privilegedServices !== null) {
-      return this.stateUpdate.privilegedServices;
-    }
+/** Too many segments already exported. */
+declare const SegmentExportError = Symbol("Too many segments already exported.");
+type SegmentExportError = typeof SegmentExportError;
 
-    return this.state.privilegedServices;
-  }
+/** 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 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 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;
+
+/** Deep clone of a map with array. */
+declare function deepCloneMapWithArray<K, V>(map: Map<K, V[]>): Map<K, V[]> {
+  const cloned: [K, V[]][] = [];
+
+  for (const [k, v] of map.entries()) {
+    cloned.push([k, v.slice()]);
+  }
+
+  return new Map(cloned);
 }
 
 /**
- * Host call result constants.
+ * State updates that currently accumulating service produced.
  *
- * https://graypaper.fluffylabs.dev/#/85129da/2c7c022c7c02?v=0.6.3
+ * `x_u`: https://graypaper.fluffylabs.dev/#/9a08063/2f31012f3101?v=0.6.6
  */
-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;
-
-interface IHostCallMemory {
-  storeFrom(address: U64, bytes: Uint8Array): Result$2<OK, PageFault | OutOfBounds>;
-  loadInto(result: Uint8Array, startAddress: U64): Result$2<OK, PageFault | OutOfBounds>;
-  getMemory(): Memory;
-}
-
-declare class HostCallMemory implements IHostCallMemory {
-  constructor(private readonly memory: Memory) {}
+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;
 
-  storeFrom(address: U64, bytes: Uint8Array): Result$2<OK, PageFault | OutOfBounds> {
-    if (bytes.length === 0) {
-      return Result.ok(OK);
-    }
+  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(),
+  ) {}
 
-    if (address + tryAsU64(bytes.length) > MEMORY_SIZE) {
-      return Result.error(new OutOfBounds());
-    }
+  /** Create new empty state update. */
+  static empty(): AccumulationStateUpdate {
+    return new AccumulationStateUpdate(
+      {
+        created: [],
+        updated: new Map(),
+        removed: [],
+        preimages: new Map(),
+        storage: new Map(),
+      },
+      [],
+    );
+  }
 
-    return this.memory.storeFrom(tryAsMemoryIndex(Number(address)), bytes);
+  /** 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 = {
+      // shallow copy
+      created: [...from.services.created],
+      updated: new Map(from.services.updated),
+      removed: [...from.services.removed],
+      // deep copy
+      preimages: deepCloneMapWithArray(from.services.preimages),
+      storage: deepCloneMapWithArray(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 maybeUpdatedServiceInfo = this.stateUpdate.services.updated.get(destination);
 
-/** A utility function to easily trace a bunch of registers. */
-declare function traceRegisters(...regs: number[]) {
-  return regs.map(tryAsRegisterIndex);
-}
+    if (maybeUpdatedServiceInfo !== undefined) {
+      return maybeUpdatedServiceInfo.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 storages = this.stateUpdate.services.storage.get(serviceId) ?? [];
+    const item = storages.find((x) => 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>;
-}
+  hasPreimage(serviceId: ServiceId, hash: PreimageHash): boolean {
+    const preimages = this.stateUpdate.services.preimages.get(serviceId) ?? [];
+    const providedPreimage = 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.hash.isEqualTo(hash),
+    );
+    if (providedPreimage !== undefined) {
+      return true;
+    }
 
-/** Container for all available host calls. */
-declare class HostCallsManager {
-  private readonly hostCalls = new Map<HostCallIndex, HostCallHandler>();
-  private readonly missing;
+    // fallback to state preimages
+    const service = this.state.getService(serviceId);
+    if (service === undefined) {
+      return false;
+    }
 
-  constructor({
-    missing,
-    handlers = [],
-  }: {
-    missing: HostCallHandler;
-    handlers?: HostCallHandler[];
-  }) {
-    this.missing = missing;
+    return service?.hasPreimage(hash) ?? false;
+  }
 
-    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);
+  getPreimage(serviceId: ServiceId, hash: PreimageHash): BytesBlob | null {
+    // TODO [ToDr] Should we verify availability here?
+    const preimages = this.stateUpdate.services.preimages.get(serviceId) ?? [];
+    const freshlyProvided = preimages.find((x) => x.hash.isEqualTo(hash));
+    if (freshlyProvided !== undefined && freshlyProvided.action.kind === UpdatePreimageKind.Provide) {
+      return freshlyProvided.action.preimage.blob;
     }
-  }
 
-  /** Get a host call by index. */
-  get(hostCallIndex: HostCallIndex): HostCallHandler {
-    return this.hostCalls.get(hostCallIndex) ?? this.missing;
+    const service = this.state.getService(serviceId);
+    return service?.getPreimage(hash) ?? null;
   }
 
-  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}.`;
-  }
-}
+  /** Get status of a preimage of current service taking into account any updates. */
+  getLookupHistory(
+    currentTimeslot: TimeSlot,
+    serviceId: ServiceId,
+    hash: PreimageHash,
+    length: U64,
+  ): LookupHistoryItem | null {
+    const preimages = this.stateUpdate.services.preimages.get(serviceId) ?? [];
+    // 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 = preimages.findLast(
+      (update) => update.hash.isEqualTo(hash) && BigInt(update.length) === length,
+    );
 
-type ResolveFn = (pvm: Interpreter) => void;
+    const stateFallback = () => {
+      // fallback to state lookup
+      const service = this.state.getService(serviceId);
+      const lenU32 = preimageLenAsU32(length);
+      if (lenU32 === null || service === null) {
+        return null;
+      }
 
-declare class InterpreterInstanceManager {
-  private instances: Interpreter[] = [];
-  private waitingQueue: ResolveFn[] = [];
+      const slots = service.getLookupHistory(hash, lenU32);
+      return slots === null ? null : new LookupHistoryItem(hash, lenU32, slots);
+    };
 
-  constructor(noOfPvmInstances: number) {
-    for (let i = 0; i < noOfPvmInstances; i++) {
-      this.instances.push(
-        new Interpreter({
-          useSbrkGas: false,
-        }),
-      );
+    if (updatedPreimage === undefined) {
+      return stateFallback();
     }
-  }
 
-  async getInstance(): Promise<Interpreter> {
-    const instance = this.instances.pop();
-    if (instance !== undefined) {
-      return Promise.resolve(instance);
+    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;
+      }
     }
-    return new Promise((resolve) => {
-      this.waitingQueue.push(resolve);
-    });
-  }
 
-  releaseInstance(pvm: Interpreter) {
-    const waiting = this.waitingQueue.shift();
-    if (waiting !== undefined) {
-      return waiting(pvm);
-    }
-    this.instances.push(pvm);
+    assertNever(action);
   }
-}
 
-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
-    `;
-  }
+  /* State update functions. */
+  updateStorage(serviceId: ServiceId, key: StorageKey, value: BytesBlob | null) {
+    const update =
+      value === null
+        ? UpdateStorage.remove({ key })
+        : UpdateStorage.set({
+            storage: StorageItem.create({ key, value }),
+          });
 
-  static fromStatus(consumedGas: Gas, status: Status) {
-    return new ReturnValue(consumedGas, status, null);
+    const storages = this.stateUpdate.services.storage.get(serviceId) ?? [];
+    const index = storages.findIndex((x) => x.key.isEqualTo(key));
+    const count = index === -1 ? 0 : 1;
+    storages.splice(index, count, update);
+    this.stateUpdate.services.storage.set(serviceId, storages);
   }
 
-  static fromMemorySlice(consumedGas: Gas, memorySlice: Uint8Array) {
-    return new ReturnValue(consumedGas, null, memorySlice);
+  /**
+   * 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(serviceId: ServiceId, newUpdate: UpdatePreimage) {
+    const updatePreimages = this.stateUpdate.services.preimages.get(serviceId) ?? [];
+    updatePreimages.push(newUpdate);
+    this.stateUpdate.services.preimages.set(serviceId, updatePreimages);
   }
 
-  hasMemorySlice(): this is this & { status: null; memorySlice: Uint8Array } {
-    return this.memorySlice instanceof Uint8Array && this.status === null;
-  }
+  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}`;
 
-  hasStatus(): this is this & { status: Status; memorySlice: null } {
-    return !this.hasMemorySlice();
-  }
-}
-declare class HostCalls {
-  constructor(
-    private pvmInstanceManager: InterpreterInstanceManager,
-    private hostCalls: HostCallsManager,
-  ) {}
+    const overflowItems = !isU32(items);
+    const overflowBytes = !isU64(bytes);
 
-  private getReturnValue(status: Status, pvmInstance: Interpreter): ReturnValue {
-    const gasConsumed = pvmInstance.getGasConsumed();
-    if (status === Status.OOG) {
-      return ReturnValue.fromStatus(gasConsumed, status);
+    // TODO [ToDr] this is not specified in GP, but it seems sensible.
+    if (overflowItems || overflowBytes) {
+      return Result.error(
+        InsufficientFundsError,
+        () => `Storage utilisation overflow: items=${overflowItems}, bytes=${overflowBytes}`,
+      );
     }
 
-    if (status === Status.HALT) {
-      const memory = pvmInstance.getMemory();
-      const regs = pvmInstance.getRegisters();
-      const maybeAddress = regs.getLowerU32(7);
-      const maybeLength = regs.getLowerU32(8);
-
-      const result = safeAllocUint8Array(maybeLength);
-      const startAddress = tryAsMemoryIndex(maybeAddress);
-      const loadResult = memory.loadInto(result, startAddress);
-
-      if (loadResult.isError) {
-        return ReturnValue.fromMemorySlice(gasConsumed, new Uint8Array());
-      }
-
-      return ReturnValue.fromMemorySlice(gasConsumed, result);
+    const thresholdBalance = ServiceAccountInfo.calculateThresholdBalance(items, bytes, serviceInfo.gratisStorage);
+    if (serviceInfo.balance < thresholdBalance) {
+      return Result.error(
+        InsufficientFundsError,
+        () => `Service balance (${serviceInfo.balance}) below threshold (${thresholdBalance})`,
+      );
     }
 
-    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 existingUpdate = this.stateUpdate.services.updated.get(serviceId);
 
-      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 (existingUpdate?.action.kind === UpdateServiceKind.Create) {
+      this.stateUpdate.services.updated.set(
+        serviceId,
+        UpdateService.create({
+          serviceInfo: newInfo,
+          lookupHistory: existingUpdate.action.lookupHistory,
+        }),
       );
+      return;
+    }
 
-      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;
-      }
+    this.stateUpdate.services.updated.set(
+      serviceId,
+      UpdateService.update({
+        serviceInfo: newInfo,
+      }),
+    );
+  }
 
-      assertNever(result);
-    }
+  createService(serviceId: ServiceId, newInfo: ServiceAccountInfo, newLookupHistory: LookupHistoryItem) {
+    this.stateUpdate.services.created.push(serviceId);
+    this.stateUpdate.services.updated.set(
+      serviceId,
+      UpdateService.create({
+        serviceInfo: newInfo,
+        lookupHistory: newLookupHistory,
+      }),
+    );
   }
 
-  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;
@@ -18831,6 +19026,7 @@ declare const index$6_UpdatePrivilegesError: typeof UpdatePrivilegesError;
 type index$6_ZeroVoidError = ZeroVoidError;
 declare const index$6_ZeroVoidError: typeof ZeroVoidError;
 declare const index$6_clampU64ToU32: typeof clampU64ToU32;
+declare const index$6_deepCloneMapWithArray: typeof deepCloneMapWithArray;
 declare const index$6_getServiceId: typeof getServiceId;
 declare const index$6_getServiceIdOrCurrent: typeof getServiceIdOrCurrent;
 declare const index$6_preimageLenAsU32: typeof preimageLenAsU32;
@@ -18840,7 +19036,7 @@ declare const index$6_tryAsMachineId: typeof tryAsMachineId;
 declare const index$6_tryAsProgramCounter: typeof tryAsProgramCounter;
 declare const index$6_writeServiceIdAsLeBytes: typeof writeServiceIdAsLeBytes;
 declare namespace index$6 {
-  export { index$6_AccumulationStateUpdate as AccumulationStateUpdate, index$6_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$6_EjectError as EjectError, index$6_ForgetPreimageError as ForgetPreimageError, index$6_HostCallResult as HostCallResult, index$6_MAX_U32 as MAX_U32, index$6_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$6_MachineInstance as MachineInstance, index$6_MemoryOperation as MemoryOperation, index$6_NewServiceError as NewServiceError, index$6_PagesError as PagesError, index$6_PartiallyUpdatedState as PartiallyUpdatedState, index$6_PeekPokeError as PeekPokeError, index$6_PendingTransfer as PendingTransfer, index$6_PreimageStatusKind as PreimageStatusKind, index$6_ProvidePreimageError as ProvidePreimageError, index$6_RequestPreimageError as RequestPreimageError, index$6_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$6_TransferError as TransferError, index$6_UpdatePrivilegesError as UpdatePrivilegesError, index$6_ZeroVoidError as ZeroVoidError, index$6_clampU64ToU32 as clampU64ToU32, index$6_getServiceId as getServiceId, index$6_getServiceIdOrCurrent as getServiceIdOrCurrent, index$6_preimageLenAsU32 as preimageLenAsU32, index$6_slotsToPreimageStatus as slotsToPreimageStatus, index$6_toMemoryOperation as toMemoryOperation, index$6_tryAsMachineId as tryAsMachineId, index$6_tryAsProgramCounter as tryAsProgramCounter, index$6_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
+  export { index$6_AccumulationStateUpdate as AccumulationStateUpdate, index$6_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$6_EjectError as EjectError, index$6_ForgetPreimageError as ForgetPreimageError, index$6_HostCallResult as HostCallResult, index$6_MAX_U32 as MAX_U32, index$6_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$6_MachineInstance as MachineInstance, index$6_MemoryOperation as MemoryOperation, index$6_NewServiceError as NewServiceError, index$6_PagesError as PagesError, index$6_PartiallyUpdatedState as PartiallyUpdatedState, index$6_PeekPokeError as PeekPokeError, index$6_PendingTransfer as PendingTransfer, index$6_PreimageStatusKind as PreimageStatusKind, index$6_ProvidePreimageError as ProvidePreimageError, index$6_RequestPreimageError as RequestPreimageError, index$6_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$6_TransferError as TransferError, index$6_UpdatePrivilegesError as UpdatePrivilegesError, index$6_ZeroVoidError as ZeroVoidError, index$6_clampU64ToU32 as clampU64ToU32, index$6_deepCloneMapWithArray as deepCloneMapWithArray, index$6_getServiceId as getServiceId, index$6_getServiceIdOrCurrent as getServiceIdOrCurrent, index$6_preimageLenAsU32 as preimageLenAsU32, index$6_slotsToPreimageStatus as slotsToPreimageStatus, index$6_toMemoryOperation as toMemoryOperation, index$6_tryAsMachineId as tryAsMachineId, index$6_tryAsProgramCounter as tryAsProgramCounter, index$6_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
   export type { index$6_InsufficientFundsError as InsufficientFundsError, index$6_MachineId as MachineId, index$6_MachineResult as MachineResult, index$6_MachineStatus as MachineStatus, index$6_NoMachineError as NoMachineError, index$6_PartialState as PartialState, index$6_PreimageStatus as PreimageStatus, index$6_ProgramCounter as ProgramCounter, index$6_RefineExternalities as RefineExternalities, index$6_SegmentExportError as SegmentExportError, index$6_ServiceStateUpdate as ServiceStateUpdate, index$6_StateSlice as StateSlice, index$6_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$6_UnprivilegedError as UnprivilegedError };
 }
 
@@ -19241,6 +19437,7 @@ declare const index$3_check: typeof check;
 declare const index$3_clampU64ToU32: typeof clampU64ToU32;
 declare const index$3_createResults: typeof createResults;
 declare const index$3_decodeStandardProgram: typeof decodeStandardProgram;
+declare const index$3_deepCloneMapWithArray: typeof deepCloneMapWithArray;
 declare const index$3_extractCodeAndMetadata: typeof extractCodeAndMetadata;
 declare const index$3_getServiceId: typeof getServiceId;
 declare const index$3_getServiceIdOrCurrent: typeof getServiceIdOrCurrent;
@@ -19259,7 +19456,7 @@ declare const index$3_tryAsMachineId: typeof tryAsMachineId;
 declare const index$3_tryAsProgramCounter: typeof tryAsProgramCounter;
 declare const index$3_writeServiceIdAsLeBytes: typeof writeServiceIdAsLeBytes;
 declare namespace index$3 {
-  export { index$3_AccumulationStateUpdate as AccumulationStateUpdate, index$3_ArgsDecoder as ArgsDecoder, index$3_ArgumentType as ArgumentType, index$3_BasicBlocks as BasicBlocks, index$3_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$3_EjectError as EjectError, index$3_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$3_ForgetPreimageError as ForgetPreimageError, index$3_HostCallMemory as HostCallMemory, index$3_HostCallRegisters as HostCallRegisters, index$3_HostCallResult as HostCallResult, index$3_ImmediateDecoder as ImmediateDecoder, index$3_MAX_U32 as MAX_U32, index$3_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$3_MachineInstance as MachineInstance, index$3_Mask as Mask, index$3_MemoryOperation as MemoryOperation, index$3_MemorySegment as MemorySegment, NO_OF_REGISTERS$1 as NO_OF_REGISTERS, index$3_NewServiceError as NewServiceError, index$3_NibblesDecoder as NibblesDecoder, index$3_PagesError as PagesError, index$3_PartiallyUpdatedState as PartiallyUpdatedState, index$3_PeekPokeError as PeekPokeError, index$3_PendingTransfer as PendingTransfer, index$3_PreimageStatusKind as PreimageStatusKind, index$3_Program as Program, index$3_ProgramDecoder as ProgramDecoder, index$3_ProvidePreimageError as ProvidePreimageError, DebuggerAdapter as Pvm, index$3_Registers as Registers, index$3_RequestPreimageError as RequestPreimageError, Result$2 as Result, index$3_RichTaggedError as RichTaggedError, index$3_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$3_SpiMemory as SpiMemory, index$3_SpiProgram as SpiProgram, index$3_TransferError as TransferError, index$3_UpdatePrivilegesError as UpdatePrivilegesError, index$3_WithDebug as WithDebug, index$3_ZeroVoidError as ZeroVoidError, index$3___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$3_asOpaqueType as asOpaqueType, index$3_assertEmpty as assertEmpty, index$3_assertNever as assertNever, index$l as block, index$s as bytes, index$3_check as check, index$3_clampU64ToU32 as clampU64ToU32, index$3_createResults as createResults, index$3_decodeStandardProgram as decodeStandardProgram, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_getServiceId as getServiceId, index$3_getServiceIdOrCurrent as getServiceIdOrCurrent, index$p as hash, index$3_inspect as inspect, index$3_instructionArgumentTypeMap as instructionArgumentTypeMap, index$8 as interpreter, index$3_isBrowser as isBrowser, index$3_isTaggedError as isTaggedError, index$3_maybeTaggedErrorToString as maybeTaggedErrorToString, index$3_measure as measure, index$r as numbers, index$3_preimageLenAsU32 as preimageLenAsU32, index$3_resultToString as resultToString, index$3_seeThrough as seeThrough, index$3_slotsToPreimageStatus as slotsToPreimageStatus, index$3_toMemoryOperation as toMemoryOperation, index$3_tryAsMachineId as tryAsMachineId, index$3_tryAsProgramCounter as tryAsProgramCounter, index$3_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
+  export { index$3_AccumulationStateUpdate as AccumulationStateUpdate, index$3_ArgsDecoder as ArgsDecoder, index$3_ArgumentType as ArgumentType, index$3_BasicBlocks as BasicBlocks, index$3_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$3_EjectError as EjectError, index$3_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$3_ForgetPreimageError as ForgetPreimageError, index$3_HostCallMemory as HostCallMemory, index$3_HostCallRegisters as HostCallRegisters, index$3_HostCallResult as HostCallResult, index$3_ImmediateDecoder as ImmediateDecoder, index$3_MAX_U32 as MAX_U32, index$3_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$3_MachineInstance as MachineInstance, index$3_Mask as Mask, index$3_MemoryOperation as MemoryOperation, index$3_MemorySegment as MemorySegment, NO_OF_REGISTERS$1 as NO_OF_REGISTERS, index$3_NewServiceError as NewServiceError, index$3_NibblesDecoder as NibblesDecoder, index$3_PagesError as PagesError, index$3_PartiallyUpdatedState as PartiallyUpdatedState, index$3_PeekPokeError as PeekPokeError, index$3_PendingTransfer as PendingTransfer, index$3_PreimageStatusKind as PreimageStatusKind, index$3_Program as Program, index$3_ProgramDecoder as ProgramDecoder, index$3_ProvidePreimageError as ProvidePreimageError, DebuggerAdapter as Pvm, index$3_Registers as Registers, index$3_RequestPreimageError as RequestPreimageError, Result$2 as Result, index$3_RichTaggedError as RichTaggedError, index$3_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$3_SpiMemory as SpiMemory, index$3_SpiProgram as SpiProgram, index$3_TransferError as TransferError, index$3_UpdatePrivilegesError as UpdatePrivilegesError, index$3_WithDebug as WithDebug, index$3_ZeroVoidError as ZeroVoidError, index$3___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$3_asOpaqueType as asOpaqueType, index$3_assertEmpty as assertEmpty, index$3_assertNever as assertNever, index$l as block, index$s as bytes, index$3_check as check, index$3_clampU64ToU32 as clampU64ToU32, index$3_createResults as createResults, index$3_decodeStandardProgram as decodeStandardProgram, index$3_deepCloneMapWithArray as deepCloneMapWithArray, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_getServiceId as getServiceId, index$3_getServiceIdOrCurrent as getServiceIdOrCurrent, index$p as hash, index$3_inspect as inspect, index$3_instructionArgumentTypeMap as instructionArgumentTypeMap, index$8 as interpreter, index$3_isBrowser as isBrowser, index$3_isTaggedError as isTaggedError, index$3_maybeTaggedErrorToString as maybeTaggedErrorToString, index$3_measure as measure, index$r as numbers, index$3_preimageLenAsU32 as preimageLenAsU32, index$3_resultToString as resultToString, index$3_seeThrough as seeThrough, index$3_slotsToPreimageStatus as slotsToPreimageStatus, index$3_toMemoryOperation as toMemoryOperation, index$3_tryAsMachineId as tryAsMachineId, index$3_tryAsProgramCounter as tryAsProgramCounter, index$3_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
   export type { index$3_Args as Args, index$3_EnumMapping as EnumMapping, index$3_ErrorResult as ErrorResult, index$3_IHostCallMemory as IHostCallMemory, index$3_IHostCallRegisters as IHostCallRegisters, index$3_InsufficientFundsError as InsufficientFundsError, index$3_MachineId as MachineId, index$3_MachineResult as MachineResult, index$3_MachineStatus as MachineStatus, index$3_NoMachineError as NoMachineError, index$3_OK as OK, index$3_OkResult as OkResult, index$3_Opaque as Opaque, index$3_PartialState as PartialState, index$3_PreimageStatus as PreimageStatus, index$3_ProgramCounter as ProgramCounter, index$3_RefineExternalities as RefineExternalities, index$3_SegmentExportError as SegmentExportError, index$3_ServiceStateUpdate as ServiceStateUpdate, index$3_StateSlice as StateSlice, index$3_StringLiteral as StringLiteral, index$3_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$3_TaggedError as TaggedError, index$3_TokenOf as TokenOf, index$3_Uninstantiable as Uninstantiable, index$3_UnprivilegedError as UnprivilegedError, index$3_WithOpaque as WithOpaque };
 }
 
@@ -20089,12 +20286,15 @@ declare class Preimages {
         prevPreimage.requester > currPreimage.requester ||
         currPreimage.blob.compare(prevPreimage.blob).isLessOrEqual()
       ) {
-        return Result.error(PreimagesErrorCode.PreimagesNotSortedUnique);
+        return Result.error(
+          PreimagesErrorCode.PreimagesNotSortedUnique,
+          () => `Preimages not sorted/unique at index ${i}`,
+        );
       }
     }
 
     const { preimages, slot } = input;
-    const pendingChanges: UpdatePreimage[] = [];
+    const pendingChanges = new Map<ServiceId, UpdatePreimage[]>();
 
     // select preimages for integration
     for (const preimage of preimages) {
@@ -20103,7 +20303,7 @@ declare class Preimages {
 
       const service = this.state.getService(requester);
       if (service === null) {
-        return Result.error(PreimagesErrorCode.AccountNotFound);
+        return Result.error(PreimagesErrorCode.AccountNotFound, () => `Service not found: ${requester}`);
       }
 
       const hasPreimage = service.hasPreimage(hash);
@@ -20111,17 +20311,22 @@ declare class Preimages {
       // https://graypaper.fluffylabs.dev/#/5f542d7/181800181900
       // https://graypaper.fluffylabs.dev/#/5f542d7/116f0011a500
       if (hasPreimage || slots === null || !LookupHistoryItem.isRequested(slots)) {
-        return Result.error(PreimagesErrorCode.PreimageUnneeded);
+        return Result.error(
+          PreimagesErrorCode.PreimageUnneeded,
+          () =>
+            `Preimage unneeded: requester=${requester}, hash=${hash}, hasPreimage=${hasPreimage}, isRequested=${slots !== null && LookupHistoryItem.isRequested(slots)}`,
+        );
       }
 
       // https://graypaper.fluffylabs.dev/#/5f542d7/18c00018f300
-      pendingChanges.push(
+      const updates = pendingChanges.get(requester) ?? [];
+      updates.push(
         UpdatePreimage.provide({
-          serviceId: requester,
           preimage: PreimageItem.create({ hash, blob }),
           slot,
         }),
       );
+      pendingChanges.set(requester, updates);
     }
 
     return Result.ok({