@typeberry/lib 0.2.0-c3df163 → 0.2.0-c96e8ef

package/index.d.ts

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