@typeberry/lib 0.2.0-c3df163 → 0.2.0-f506473

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. */
@@ -3346,6 +3348,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 +3474,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 +3504,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 };
 }
 
@@ -10659,7 +10666,6 @@ declare enum UpdatePreimageKind {
  */
 declare class UpdatePreimage {
   private constructor(
-    public readonly serviceId: ServiceId,
     public readonly action:
       | {
           kind: UpdatePreimageKind.Provide;
@@ -10679,16 +10685,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 +10694,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 +10703,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 +10742,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 +10760,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 +10796,6 @@ declare enum UpdateStorageKind {
  */
 declare class UpdateStorage {
   private constructor(
-    public readonly serviceId: ServiceId,
     public readonly action:
       | {
           kind: UpdateStorageKind.Set;
@@ -10812,12 +10807,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 +10830,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 +11036,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 +11054,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 +11066,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 +11183,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 +11986,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)];
@@ -12663,7 +12689,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 +12697,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());
     }
@@ -15483,7 +15509,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 +15542,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 +15580,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 +17565,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 +17923,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 +17938,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 +18413,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 +18451,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 +18474,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 +18538,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 +18553,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 +18571,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 +18592,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 +18609,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 +18657,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 +18678,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 +18698,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 +18725,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 +18889,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 +18899,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 +19300,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 +19319,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 +20149,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 +20166,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 +20174,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({