@typeberry/lib 0.2.0-74f246e → 0.2.0-8017bfd

package/index.d.ts

@@ -10659,7 +10659,6 @@ declare enum UpdatePreimageKind {
  */
 declare class UpdatePreimage {
   private constructor(
-    public readonly serviceId: ServiceId,
     public readonly action:
       | {
           kind: UpdatePreimageKind.Provide;
@@ -10679,16 +10678,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 +10687,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 +10696,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 +10735,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 +10753,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 +10789,6 @@ declare enum UpdateStorageKind {
  */
 declare class UpdateStorage {
   private constructor(
-    public readonly serviceId: ServiceId,
     public readonly action:
       | {
           kind: UpdateStorageKind.Set;
@@ -10812,12 +10800,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 +10823,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 +11029,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 +11047,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,37 +11059,44 @@ 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(
@@ -11108,53 +11104,61 @@ declare class InMemoryState extends WithDebug implements State, WithStateView, E
           `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!`);
         }
@@ -11975,89 +11979,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)];
@@ -14196,6 +14215,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,82 +14460,6 @@ declare class ImmediateDecoder {
   }
 }
 
-declare const NO_OF_REGISTERS$1 = 13;
-
-type RegisterIndex = Opaque<number, "register index">;
-
-declare class Registers {
-  private asSigned: BigInt64Array;
-  private asUnsigned: BigUint64Array;
-
-  constructor(private readonly bytes = safeAllocUint8Array(NO_OF_REGISTERS << REGISTER_SIZE_SHIFT)) {
-    check`${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
-    this.asSigned = new BigInt64Array(bytes.buffer, bytes.byteOffset);
-    this.asUnsigned = new BigUint64Array(bytes.buffer, bytes.byteOffset);
-  }
-
-  static fromBytes(bytes: Uint8Array) {
-    check`${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
-    return new Registers(bytes);
-  }
-
-  getBytesAsLittleEndian(index: number, len: number) {
-    const offset = index << REGISTER_SIZE_SHIFT;
-    return this.bytes.subarray(offset, offset + len);
-  }
-
-  getAllBytesAsLittleEndian() {
-    return this.bytes;
-  }
-
-  copyFrom(regs: Registers | BigUint64Array) {
-    const array = regs instanceof BigUint64Array ? regs : regs.asUnsigned;
-    this.asUnsigned.set(array);
-  }
-
-  reset() {
-    for (let i = 0; i < NO_OF_REGISTERS; i++) {
-      this.asUnsigned[i] = 0n;
-    }
-  }
-
-  getLowerU32(registerIndex: number) {
-    return Number(this.asUnsigned[registerIndex] & 0xff_ff_ff_ffn);
-  }
-
-  getLowerI32(registerIndex: number) {
-    return Number(this.getLowerU32(registerIndex)) >> 0;
-  }
-
-  setU32(registerIndex: number, value: number) {
-    this.asUnsigned[registerIndex] = signExtend32To64(value);
-  }
-
-  setI32(registerIndex: number, value: number) {
-    this.asSigned[registerIndex] = signExtend32To64(value);
-  }
-
-  getU64(registerIndex: number) {
-    return this.asUnsigned[registerIndex];
-  }
-
-  getI64(registerIndex: number) {
-    return this.asSigned[registerIndex];
-  }
-
-  setU64(registerIndex: number, value: bigint) {
-    this.asUnsigned[registerIndex] = value;
-  }
-
-  setI64(registerIndex: number, value: bigint) {
-    this.asSigned[registerIndex] = value;
-  }
-
-  getAllU64() {
-    return this.asUnsigned;
-  }
-}
-
 declare class NibblesDecoder {
   private byte = new Int8Array(1);
 
@@ -17877,870 +17896,884 @@ 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;
-    }
-  | {
-      status: typeof Status.FAULT;
-      address: 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.OK | typeof Status.HALT | typeof Status.PANIC | typeof Status.OOG;
-    };
 
-/** Data returned by a machine invocation. */
-type MachineResult = {
-  result: MachineStatus;
-  gas: BigGas;
-  registers: Registers;
-};
+    if (address + tryAsU64(bytes.length) > MEMORY_SIZE) {
+      return Result.error(new OutOfBounds());
+    }
 
-/** Types of possbile operations to request by Pages host call. */
-declare enum MemoryOperation {
-  /** Zeroes memory and set access to unreadable. */
-  Void = 0,
-  /** Zeroes memory and set access to read-only. */
-  ZeroRead = 1,
-  /** Zeroes memory and set access to read-write. */
-  ZeroWrite = 2,
-  /** Preserve memory and set access to read-only. */
-  Read = 3,
-  /** Preserve memory and set access to read-write. */
-  Write = 4,
-}
+    return this.memory.storeFrom(tryAsMemoryIndex(Number(address)), bytes);
+  }
 
-/** 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;
+  loadInto(result: Uint8Array, startAddress: U64): Result$2<OK, PageFault | OutOfBounds> {
+    if (result.length === 0) {
+      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,
-}
+    if (startAddress + tryAsU64(result.length) > MEMORY_SIZE) {
+      return Result.error(new OutOfBounds());
+    }
 
-declare enum ZeroVoidError {
-  /** No machine under given machine index. */
-  NoMachine = 0,
-  /** Attempting to void or zero non-accessible page. */
-  InvalidPage = 1,
+    return this.memory.loadInto(result, tryAsMemoryIndex(Number(startAddress)));
+  }
 }
 
-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,
+interface IHostCallRegisters {
+  get(registerIndex: number): U64;
+  set(registerIndex: number, value: U64): void;
 }
 
-/** Error machine is not found. */
-declare const NoMachineError = Symbol("Machine index not found.");
-type NoMachineError = typeof NoMachineError;
-
-/** Too many segments already exported. */
-declare const SegmentExportError = Symbol("Too many segments already exported.");
-type SegmentExportError = typeof SegmentExportError;
-
-/** Host functions external invocations available during refine phase. */
-interface RefineExternalities {
-  /** Forget a previously started nested VM. */
-  machineExpunge(machineIndex: MachineId): Promise<Result$2<ProgramCounter, NoMachineError>>;
+declare class HostCallRegisters implements IHostCallRegisters {
+  constructor(private readonly registers: Registers) {}
 
-  /** 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>>;
+  get(registerIndex: number): U64 {
+    return tryAsU64(this.registers.getU64(registerIndex));
+  }
 
-  /** Set given range of pages as writeable and initialize them with zeros. */
-  machineZeroPages(machineIndex: MachineId, pageStart: U64, pageCount: U64): Promise<Result$2<OK, ZeroVoidError>>;
+  set(registerIndex: number, value: U64) {
+    this.registers.setU64(registerIndex, value);
+  }
+}
 
-  /** 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>>;
+/** 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));
 
-  /** 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>>;
+/**
+ * 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
+}
 
-  /** Start an inner PVM instance with given entry point and starting code. */
-  machineInit(code: BytesBlob, programCounter: ProgramCounter): Promise<Result$2<MachineId, ProgramDecoderError>>;
+/** A utility function to easily trace a bunch of registers. */
+declare function traceRegisters(...regs: number[]) {
+  return regs.map(tryAsRegisterIndex);
+}
 
-  /** Run a previously initialized PVM instance with given gas and registers. */
-  machineInvoke(
-    machineIndex: MachineId,
-    gas: BigGas,
-    registers: Registers,
-  ): Promise<Result$2<MachineResult, NoMachineError>>;
+/** An interface for a host call implementation */
+interface HostCallHandler {
+  /** Index of that host call (i.e. what PVM invokes via `ecalli`) */
+  readonly index: HostCallIndex;
 
   /**
-   * Export segment for future retrieval.
+   * The gas cost of invocation of that host call.
    *
-   * Returns the index assigned to that segment or an error if there is too many already exported.
+   * NOTE: `((reg: IHostCallRegisters) => Gas)` function is for compatibility reasons: pre GP 0.7.2
    */
-  exportSegment(segment: Segment): Result$2<SegmentIndex, SegmentExportError>;
+  readonly basicGasCost: SmallGas | ((reg: IHostCallRegisters) => Gas);
 
-  /** Lookup a historical preimage. */
-  historicalLookup(serviceId: ServiceId | null, hash: Blake2bHash): Promise<BytesBlob | null>;
+  /** Currently executing service id. */
+  readonly currentServiceId: U32;
 
-  /** 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>>;
-}
+  /** Input&Output registers that we should add to tracing log. */
+  readonly tracedRegisters: RegisterIndex[];
 
-declare const InsufficientFundsError = "insufficient funds";
-type InsufficientFundsError = typeof InsufficientFundsError;
+  /**
+   * Actually execute the host call.
+   *
+   * NOTE the call is ALLOWED and expected to modify registers and memory.
+   */
+  execute(gas: GasCounter, regs: IHostCallRegisters, memory: IHostCallMemory): Promise<undefined | PvmExecution>;
+}
 
-/** 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);
-    };
-
-    if (updatedPreimage === undefined) {
-      return stateFallback();
-    }
+      const hostCall = this.hostCalls.get(index);
+      const gasBefore = gas.get();
+      // NOTE: `basicGasCost(regs)` function is for compatibility reasons: pre GP 0.7.2
+      const basicGasCost =
+        typeof hostCall.basicGasCost === "number" ? hostCall.basicGasCost : hostCall.basicGasCost(regs);
+      const underflow = gas.sub(basicGasCost);
 
-    const { action } = updatedPreimage;
-    switch (action.kind) {
-      case UpdatePreimageKind.Provide: {
-        // casting to U32 is safe, since we compare with object we have in memory.
-        return new LookupHistoryItem(hash, updatedPreimage.length, tryAsLookupHistorySlots([currentTimeslot]));
+      const pcLog = `[PC: ${pvmInstance.getPC()}]`;
+      if (underflow) {
+        this.hostCalls.traceHostCall(`${pcLog} OOG`, index, hostCall, regs, gas.get());
+        return ReturnValue.fromStatus(pvmInstance.getGasConsumed(), Status.OOG);
       }
-      case UpdatePreimageKind.Remove: {
-        const state = stateFallback();
-        // kinda impossible, since we know it's there because it's removed.
-        if (state === null) {
-          return null;
-        }
+      this.hostCalls.traceHostCall(`${pcLog} Invoking`, index, hostCall, regs, gasBefore);
+      const result = await hostCall.execute(gas, regs, memory);
+      this.hostCalls.traceHostCall(
+        result === undefined ? `${pcLog} Result` : `${pcLog} Status(${PvmExecution[result]})`,
+        index,
+        hostCall,
+        regs,
+        gas.get(),
+      );
 
-        return new LookupHistoryItem(hash, state.length, tryAsLookupHistorySlots([...state.slots, currentTimeslot]));
-      }
-      case UpdatePreimageKind.UpdateOrAdd: {
-        return action.item;
+      if (result === PvmExecution.Halt) {
+        status = Status.HALT;
+        return this.getReturnValue(status, pvmInstance);
       }
-    }
 
-    assertNever(action);
-  }
+      if (result === PvmExecution.Panic) {
+        status = Status.PANIC;
+        return this.getReturnValue(status, pvmInstance);
+      }
 
-  /* State update functions. */
+      if (result === PvmExecution.OOG) {
+        status = Status.OOG;
+        return this.getReturnValue(status, pvmInstance);
+      }
 
-  updateStorage(serviceId: ServiceId, key: StorageKey, value: BytesBlob | null) {
-    const update =
-      value === null
-        ? UpdateStorage.remove({ serviceId, key })
-        : UpdateStorage.set({
-            serviceId,
-            storage: StorageItem.create({ key, value }),
-          });
+      if (result === undefined) {
+        pvmInstance.runProgram();
+        status = pvmInstance.getStatus();
+        continue;
+      }
 
-    const index = this.stateUpdate.services.storage.findIndex(
-      (x) => x.serviceId === update.serviceId && x.key.isEqualTo(key),
-    );
-    const count = index === -1 ? 0 : 1;
-    this.stateUpdate.services.storage.splice(index, count, update);
+      assertNever(result);
+    }
   }
 
-  /**
-   * Update a preimage.
-   *
-   * Note we store all previous entries as well, since there might be a sequence of:
-   * `provide` -> `remove` and both should update the end state somehow.
-   */
-  updatePreimage(newUpdate: UpdatePreimage) {
-    this.stateUpdate.services.preimages.push(newUpdate);
+  async runProgram(
+    rawProgram: Uint8Array,
+    initialPc: number,
+    initialGas: Gas,
+    maybeRegisters?: Registers,
+    maybeMemory?: Memory,
+  ): Promise<ReturnValue> {
+    const pvmInstance = await this.pvmInstanceManager.getInstance();
+    pvmInstance.reset(rawProgram, initialPc, initialGas, maybeRegisters, maybeMemory);
+    try {
+      return await this.execute(pvmInstance);
+    } finally {
+      this.pvmInstanceManager.releaseInstance(pvmInstance);
+    }
   }
+}
 
-  updateServiceStorageUtilisation(
-    serviceId: ServiceId,
-    items: number,
-    bytes: bigint,
-    serviceInfo: ServiceAccountInfo,
-  ): Result$2<OK, InsufficientFundsError> {
-    check`${items >= 0} storageUtilisationCount has to be a positive number, got: ${items}`;
-    check`${bytes >= 0} storageUtilisationBytes has to be a positive number, got: ${bytes}`;
-
-    const overflowItems = !isU32(items);
-    const overflowBytes = !isU64(bytes);
+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 };
+}
 
-    // TODO [ToDr] this is not specified in GP, but it seems sensible.
-    if (overflowItems || overflowBytes) {
-      return Result.error(InsufficientFundsError);
-    }
+/**
+ * Program counter is a 64-bit unsigned integer that points to the next instruction
+ *
+ * https://graypaper.fluffylabs.dev/#/1c979cb/2e3f012e3f01?v=0.7.1
+ */
+type ProgramCounter = Opaque<U64, "ProgramCounter[u64]">;
+/** Convert a number into ProgramCounter. */
+declare const tryAsProgramCounter = (v: number | bigint): ProgramCounter => asOpaqueType(tryAsU64(v));
 
-    const thresholdBalance = ServiceAccountInfo.calculateThresholdBalance(items, bytes, serviceInfo.gratisStorage);
-    if (serviceInfo.balance < thresholdBalance) {
-      return Result.error(InsufficientFundsError);
-    }
+/** 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 service info with new details.
-    this.updateServiceInfo(
-      serviceId,
-      ServiceAccountInfo.create({
-        ...serviceInfo,
-        storageUtilisationBytes: bytes,
-        storageUtilisationCount: items,
-      }),
-    );
-    return Result.ok(OK);
+declare class MachineInstance {
+  async run(gas: BigGas, registers: Registers): Promise<MachineResult> {
+    return {
+      result: {
+        status: Status.OK,
+      },
+      gas,
+      registers,
+    };
   }
+}
 
-  updateServiceInfo(serviceId: ServiceId, newInfo: ServiceAccountInfo) {
-    const idx = this.stateUpdate.services.servicesUpdates.findIndex((x) => x.serviceId === serviceId);
-    const toRemove = idx === -1 ? 0 : 1;
-    const existingItem = this.stateUpdate.services.servicesUpdates[idx];
-
-    if (existingItem?.action.kind === UpdateServiceKind.Create) {
-      this.stateUpdate.services.servicesUpdates.splice(
-        idx,
-        toRemove,
-        UpdateService.create({
-          serviceId,
-          serviceInfo: newInfo,
-          lookupHistory: existingItem.action.lookupHistory,
-        }),
-      );
-
-      return;
+type MachineStatus =
+  | {
+      status: typeof Status.HOST;
+      hostCallIndex: U64;
     }
-
-    this.stateUpdate.services.servicesUpdates.splice(
-      idx,
-      toRemove,
-      UpdateService.update({
-        serviceId,
-        serviceInfo: newInfo,
-      }),
-    );
-  }
-
-  getPrivilegedServices() {
-    if (this.stateUpdate.privilegedServices !== null) {
-      return this.stateUpdate.privilegedServices;
+  | {
+      status: typeof Status.FAULT;
+      address: U64;
     }
+  | {
+      status: typeof Status.OK | typeof Status.HALT | typeof Status.PANIC | typeof Status.OOG;
+    };
 
-    return this.state.privilegedServices;
-  }
+/** Data returned by a machine invocation. */
+type MachineResult = {
+  result: MachineStatus;
+  gas: BigGas;
+  registers: Registers;
+};
+
+/** 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,
 }
 
-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));
+/** Convert a number into MemoryOperation or null (if invalid). */
+declare const toMemoryOperation = (v: number | bigint): MemoryOperation | null =>
+  v <= MemoryOperation.Write && v >= MemoryOperation.Void ? Number(v) : null;
+
+/** An error that may occur during `peek` or `poke` host call. */
+declare enum PeekPokeError {
+  /** Source page fault. */
+  SourcePageFault = 0,
+  /** Destination page fault. */
+  DestinationPageFault = 1,
+  /** No machine under given machine index. */
+  NoMachine = 2,
 }
 
-/**
- * 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 enum ZeroVoidError {
+  /** No machine under given machine index. */
+  NoMachine = 0,
+  /** Attempting to void or zero non-accessible page. */
+  InvalidPage = 1,
+}
 
-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 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 HostCallMemory implements IHostCallMemory {
-  constructor(private readonly memory: Memory) {}
+/** Error machine is not found. */
+declare const NoMachineError = Symbol("Machine index not found.");
+type NoMachineError = typeof NoMachineError;
 
-  storeFrom(address: U64, bytes: Uint8Array): Result$2<OK, PageFault | OutOfBounds> {
-    if (bytes.length === 0) {
-      return Result.ok(OK);
-    }
+/** Too many segments already exported. */
+declare const SegmentExportError = Symbol("Too many segments already exported.");
+type SegmentExportError = typeof SegmentExportError;
 
-    if (address + tryAsU64(bytes.length) > MEMORY_SIZE) {
-      return Result.error(new OutOfBounds());
-    }
+/** Host functions external invocations available during refine phase. */
+interface RefineExternalities {
+  /** Forget a previously started nested VM. */
+  machineExpunge(machineIndex: MachineId): Promise<Result$2<ProgramCounter, NoMachineError>>;
 
-    return this.memory.storeFrom(tryAsMemoryIndex(Number(address)), bytes);
-  }
+  /** 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>>;
 
-  loadInto(result: Uint8Array, startAddress: U64): Result$2<OK, PageFault | OutOfBounds> {
-    if (result.length === 0) {
-      return Result.ok(OK);
-    }
+  /** 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 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;
 
-    if (startAddress + tryAsU64(result.length) > MEMORY_SIZE) {
-      return Result.error(new OutOfBounds());
-    }
+/** Deep clone of a map with array. */
+declare function deepCloneMapWithArray<K, V>(map: Map<K, V[]>): Map<K, V[]> {
+  const cloned: [K, V[]][] = [];
 
-    return this.memory.loadInto(result, tryAsMemoryIndex(Number(startAddress)));
+  for (const [k, v] of map.entries()) {
+    cloned.push([k, v.slice()]);
   }
 
-  getMemory(): Memory {
-    return this.memory;
-  }
+  return new Map(cloned);
 }
 
-interface IHostCallRegisters {
-  get(registerIndex: number): U64;
-  set(registerIndex: number, value: U64): void;
-}
+/**
+ * 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;
 
-declare class HostCallRegisters implements IHostCallRegisters {
-  constructor(private readonly registers: Registers) {}
+  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(),
+  ) {}
 
-  get(registerIndex: number): U64 {
-    return tryAsU64(this.registers.getU64(registerIndex));
+  /** Create new empty state update. */
+  static empty(): AccumulationStateUpdate {
+    return new AccumulationStateUpdate(
+      {
+        created: [],
+        updated: new Map(),
+        removed: [],
+        preimages: new Map(),
+        storage: new Map(),
+      },
+      [],
+    );
   }
 
-  set(registerIndex: number, value: U64) {
-    this.registers.setU64(registerIndex, value);
+  /** Create a state update with some existing, yet uncommited services updates. */
+  static new(update: ServicesUpdate): AccumulationStateUpdate {
+    return new AccumulationStateUpdate(
+      {
+        ...update,
+      },
+      [],
+    );
   }
-}
 
-/** 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));
+  /** 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));
 
-/**
- * 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
-}
+    // update entries
+    for (const [k, v] of from.authorizationQueues) {
+      update.authorizationQueues.set(k, v);
+    }
 
-/** A utility function to easily trace a bunch of registers. */
-declare function traceRegisters(...regs: number[]) {
-  return regs.map(tryAsRegisterIndex);
-}
+    if (from.validatorsData !== null) {
+      update.validatorsData = asKnownSize([...from.validatorsData]);
+    }
 
-/** An interface for a host call implementation */
-interface HostCallHandler {
-  /** Index of that host call (i.e. what PVM invokes via `ecalli`) */
-  readonly index: HostCallIndex;
+    if (from.privilegedServices !== null) {
+      update.privilegedServices = PrivilegedServices.create({
+        ...from.privilegedServices,
+        assigners: asKnownSize([...from.privilegedServices.assigners]),
+      });
+    }
+    return update;
+  }
 
-  /**
-   * 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);
+  /** Retrieve and clear pending transfers. */
+  takeTransfers() {
+    const transfers = this.transfers;
+    this.transfers = [];
+    return transfers;
+  }
+}
 
-  /** Currently executing service id. */
-  readonly currentServiceId: U32;
+type StateSlice = Pick<State, "getService" | "privilegedServices">;
 
-  /** Input&Output registers that we should add to tracing log. */
-  readonly tracedRegisters: RegisterIndex[];
+declare class PartiallyUpdatedState<T extends StateSlice = StateSlice> {
+  /** A collection of state updates. */
+  public readonly stateUpdate;
+
+  constructor(
+    /** Original (unmodified state). */
+    public readonly state: T,
+    stateUpdate?: AccumulationStateUpdate,
+  ) {
+    this.stateUpdate =
+      stateUpdate === undefined ? AccumulationStateUpdate.empty() : AccumulationStateUpdate.copyFrom(stateUpdate);
+  }
 
   /**
-   * Actually execute the host call.
+   * Retrieve info of service with given id.
    *
-   * NOTE the call is ALLOWED and expected to modify registers and memory.
+   * NOTE the info may be updated compared to what is in the state.
+   *
+   * Takes into account ejected and newly created services as well.
    */
-  execute(gas: GasCounter, regs: IHostCallRegisters, memory: IHostCallMemory): Promise<undefined | PvmExecution>;
-}
+  getServiceInfo(destination: ServiceId | null): ServiceAccountInfo | null {
+    if (destination === null) {
+      return null;
+    }
 
-/** Container for all available host calls. */
-declare class HostCallsManager {
-  private readonly hostCalls = new Map<HostCallIndex, HostCallHandler>();
-  private readonly missing;
+    const maybeUpdatedServiceInfo = this.stateUpdate.services.updated.get(destination);
 
-  constructor({
-    missing,
-    handlers = [],
-  }: {
-    missing: HostCallHandler;
-    handlers?: HostCallHandler[];
-  }) {
-    this.missing = missing;
+    if (maybeUpdatedServiceInfo !== undefined) {
+      return maybeUpdatedServiceInfo.action.account;
+    }
 
-    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);
+    const maybeService = this.state.getService(destination);
+    if (maybeService === null) {
+      return null;
     }
-  }
 
-  /** Get a host call by index. */
-  get(hostCallIndex: HostCallIndex): HostCallHandler {
-    return this.hostCalls.get(hostCallIndex) ?? this.missing;
+    return maybeService.getInfo();
   }
 
-  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}.`;
-  }
-}
+  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;
+    }
 
-type ResolveFn = (pvm: Interpreter) => void;
+    const service = this.state.getService(serviceId);
+    return service?.getStorage(rawKey) ?? null;
+  }
 
-declare class InterpreterInstanceManager {
-  private instances: Interpreter[] = [];
-  private waitingQueue: ResolveFn[] = [];
+  /**
+   * 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 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;
+    }
 
-  constructor(noOfPvmInstances: number) {
-    for (let i = 0; i < noOfPvmInstances; i++) {
-      this.instances.push(
-        new Interpreter({
-          useSbrkGas: false,
-        }),
-      );
+    // fallback to state preimages
+    const service = this.state.getService(serviceId);
+    if (service === undefined) {
+      return false;
     }
+
+    return service?.hasPreimage(hash) ?? false;
   }
 
-  async getInstance(): Promise<Interpreter> {
-    const instance = this.instances.pop();
-    if (instance !== undefined) {
-      return Promise.resolve(instance);
+  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;
     }
-    return new Promise((resolve) => {
-      this.waitingQueue.push(resolve);
-    });
+
+    const service = this.state.getService(serviceId);
+    return service?.getPreimage(hash) ?? null;
   }
 
-  releaseInstance(pvm: Interpreter) {
-    const waiting = this.waitingQueue.shift();
-    if (waiting !== undefined) {
-      return waiting(pvm);
+  /** 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,
+    );
+
+    const stateFallback = () => {
+      // fallback to state lookup
+      const service = this.state.getService(serviceId);
+      const lenU32 = preimageLenAsU32(length);
+      if (lenU32 === null || service === null) {
+        return null;
+      }
+
+      const slots = service.getLookupHistory(hash, lenU32);
+      return slots === null ? null : new LookupHistoryItem(hash, lenU32, slots);
+    };
+
+    if (updatedPreimage === undefined) {
+      return stateFallback();
     }
-    this.instances.push(pvm);
-  }
-}
 
-declare class ReturnValue {
-  private constructor(
-    public consumedGas: Gas,
-    public status: Status | null,
-    public memorySlice: Uint8Array | null,
-  ) {
-    check`
-      ${(status === null && memorySlice !== null) || (status !== null && memorySlice === null)}
-      'status' and 'memorySlice' must not both be null or both be non-null — exactly one must be provided
-    `;
-  }
+    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;
+        }
 
-  static fromStatus(consumedGas: Gas, status: Status) {
-    return new ReturnValue(consumedGas, status, null);
-  }
+        return new LookupHistoryItem(hash, state.length, tryAsLookupHistorySlots([...state.slots, currentTimeslot]));
+      }
+      case UpdatePreimageKind.UpdateOrAdd: {
+        return action.item;
+      }
+    }
 
-  static fromMemorySlice(consumedGas: Gas, memorySlice: Uint8Array) {
-    return new ReturnValue(consumedGas, null, memorySlice);
+    assertNever(action);
   }
 
-  hasMemorySlice(): this is this & { status: null; memorySlice: Uint8Array } {
-    return this.memorySlice instanceof Uint8Array && this.status === null;
-  }
+  /* 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 }),
+          });
 
-  hasStatus(): this is this & { status: Status; memorySlice: null } {
-    return !this.hasMemorySlice();
+    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);
   }
-}
-declare class HostCalls {
-  constructor(
-    private pvmInstanceManager: InterpreterInstanceManager,
-    private hostCalls: HostCallsManager,
-  ) {}
 
-  private getReturnValue(status: Status, pvmInstance: Interpreter): ReturnValue {
-    const gasConsumed = pvmInstance.getGasConsumed();
-    if (status === Status.OOG) {
-      return ReturnValue.fromStatus(gasConsumed, status);
-    }
+  /**
+   * 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);
+  }
 
-    if (status === Status.HALT) {
-      const memory = pvmInstance.getMemory();
-      const regs = pvmInstance.getRegisters();
-      const maybeAddress = regs.getLowerU32(7);
-      const maybeLength = regs.getLowerU32(8);
+  updateServiceStorageUtilisation(
+    serviceId: ServiceId,
+    items: number,
+    bytes: bigint,
+    serviceInfo: ServiceAccountInfo,
+  ): Result$2<OK, InsufficientFundsError> {
+    check`${items >= 0} storageUtilisationCount has to be a positive number, got: ${items}`;
+    check`${bytes >= 0} storageUtilisationBytes has to be a positive number, got: ${bytes}`;
 
-      const result = safeAllocUint8Array(maybeLength);
-      const startAddress = tryAsMemoryIndex(maybeAddress);
-      const loadResult = memory.loadInto(result, startAddress);
+    const overflowItems = !isU32(items);
+    const overflowBytes = !isU64(bytes);
 
-      if (loadResult.isError) {
-        return ReturnValue.fromMemorySlice(gasConsumed, new Uint8Array());
-      }
+    // TODO [ToDr] this is not specified in GP, but it seems sensible.
+    if (overflowItems || overflowBytes) {
+      return Result.error(InsufficientFundsError);
+    }
 
-      return ReturnValue.fromMemorySlice(gasConsumed, result);
+    const thresholdBalance = ServiceAccountInfo.calculateThresholdBalance(items, bytes, serviceInfo.gratisStorage);
+    if (serviceInfo.balance < thresholdBalance) {
+      return Result.error(InsufficientFundsError);
     }
 
-    return ReturnValue.fromStatus(gasConsumed, Status.PANIC);
+    // Update service info with new details.
+    this.updateServiceInfo(
+      serviceId,
+      ServiceAccountInfo.create({
+        ...serviceInfo,
+        storageUtilisationBytes: bytes,
+        storageUtilisationCount: items,
+      }),
+    );
+    return Result.ok(OK);
   }
 
-  private async execute(pvmInstance: Interpreter) {
-    pvmInstance.runProgram();
-    for (;;) {
-      let status = pvmInstance.getStatus();
-      if (status !== Status.HOST) {
-        return this.getReturnValue(status, pvmInstance);
-      }
-      check`
-        ${pvmInstance.getExitParam() !== null}
-        "We know that the exit param is not null, because the status is 'Status.HOST'
-      `;
-      const hostCallIndex = pvmInstance.getExitParam() ?? -1;
-      const gas = pvmInstance.getGasCounter();
-      const regs = new HostCallRegisters(pvmInstance.getRegisters());
-      const memory = new HostCallMemory(pvmInstance.getMemory());
-      const index = tryAsHostCallIndex(hostCallIndex);
-
-      const hostCall = this.hostCalls.get(index);
-      const gasBefore = gas.get();
-      // NOTE: `basicGasCost(regs)` function is for compatibility reasons: pre GP 0.7.2
-      const basicGasCost =
-        typeof hostCall.basicGasCost === "number" ? hostCall.basicGasCost : hostCall.basicGasCost(regs);
-      const underflow = gas.sub(basicGasCost);
+  updateServiceInfo(serviceId: ServiceId, newInfo: ServiceAccountInfo) {
+    const 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 +18864,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 +18874,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 +19275,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 +19294,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 };
 }
 
@@ -20094,7 +20129,7 @@ declare class Preimages {
     }
 
     const { preimages, slot } = input;
-    const pendingChanges: UpdatePreimage[] = [];
+    const pendingChanges = new Map<ServiceId, UpdatePreimage[]>();
 
     // select preimages for integration
     for (const preimage of preimages) {
@@ -20115,13 +20150,14 @@ declare class Preimages {
       }
 
       // 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({