@typeberry/jam 0.2.0-c3df163 → 0.2.0-f506473

package/bootstrap-importer.mjs

@@ -3840,7 +3840,7 @@ function resultToString(res) {
     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. */
 const result_Result = {
@@ -3854,7 +3854,7 @@ const result_Result = {
         };
     },
     /** Create new [`Result`] with `Error` status. */
-    error: (error, details = "") => {
+    error: (error, details) => {
         debug_check `${error !== undefined} 'Error' type cannot be undefined.`;
         return {
             isOk: false,
@@ -3973,7 +3973,7 @@ function deepEqual(actual, expected, { context = [], errorsCollector, ignore = [
         }
         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
@@ -5214,8 +5214,8 @@ class decoder_Decoder {
     /**
      * Create a new [`Decoder`] instance given a raw array of bytes as a source.
      */
-    static fromBlob(source) {
-        return new decoder_Decoder(source);
+    static fromBlob(source, context) {
+        return new decoder_Decoder(source, undefined, context);
     }
     /**
      * Decode a single object from all of the source bytes.
@@ -5510,7 +5510,7 @@ class decoder_Decoder {
     ensureHasBytes(bytes) {
         debug_check `${bytes >= 0} Negative number of bytes given.`;
         if (this.offset + bytes > this.source.length) {
-            throw new Error(`Attempting to decode more data than there is left. Need ${bytes}, left: ${this.source.length - this.offset}.`);
+            throw new EndOfDataError(`Attempting to decode more data than there is left. Need ${bytes}, left: ${this.source.length - this.offset}.`);
         }
     }
 }
@@ -5524,6 +5524,8 @@ function decodeVariableLengthExtraBytes(firstByte) {
     }
     return 0;
 }
+class EndOfDataError extends Error {
+}
 
 ;// CONCATENATED MODULE: ./packages/core/codec/skip.ts
 
@@ -6315,6 +6317,7 @@ class SequenceView {
 
 
 
+
 /**
  * For sequences with unknown length we need to give some size hint.
  * TODO [ToDr] [opti] This value should be updated when we run some real-data bechmarks.
@@ -6564,6 +6567,9 @@ function forEachDescriptor(descriptors, f) {
                 f(k, descriptors[k]);
             }
             catch (e) {
+                if (e instanceof EndOfDataError) {
+                    throw new EndOfDataError(`${key}: ${e}`);
+                }
                 throw new Error(`${key}: ${e}`);
             }
         }
@@ -10597,31 +10603,29 @@ var UpdatePreimageKind;
  * 3. Update `LookupHistory` with given value.
  */
 class UpdatePreimage {
-    serviceId;
     action;
-    constructor(serviceId, action) {
-        this.serviceId = serviceId;
+    constructor(action) {
         this.action = action;
     }
     /** A preimage is provided. We should update the lookuphistory and add the preimage to db. */
-    static provide({ serviceId, preimage, slot, }) {
-        return new UpdatePreimage(serviceId, {
+    static provide({ preimage, slot }) {
+        return new UpdatePreimage({
             kind: UpdatePreimageKind.Provide,
             preimage,
             slot,
         });
     }
     /** The preimage should be removed completely from the database. */
-    static remove({ serviceId, hash, length }) {
-        return new UpdatePreimage(serviceId, {
+    static remove({ hash, length }) {
+        return new UpdatePreimage({
             kind: UpdatePreimageKind.Remove,
             hash,
             length,
         });
     }
     /** Update the lookup history of some preimage or add a new one (request). */
-    static updateOrAdd({ serviceId, lookupHistory }) {
-        return new UpdatePreimage(serviceId, {
+    static updateOrAdd({ lookupHistory }) {
+        return new UpdatePreimage({
             kind: UpdatePreimageKind.UpdateOrAdd,
             item: lookupHistory,
         });
@@ -10658,23 +10662,21 @@ var UpdateServiceKind;
     UpdateServiceKind[UpdateServiceKind["Create"] = 1] = "Create";
 })(UpdateServiceKind || (UpdateServiceKind = {}));
 /**
- * Update service info of a particular `ServiceId` or create a new one.
+ * Update service info or create a new one.
  */
 class UpdateService {
-    serviceId;
     action;
-    constructor(serviceId, action) {
-        this.serviceId = serviceId;
+    constructor(action) {
         this.action = action;
     }
-    static update({ serviceId, serviceInfo }) {
-        return new UpdateService(serviceId, {
+    static update({ serviceInfo }) {
+        return new UpdateService({
             kind: UpdateServiceKind.Update,
             account: serviceInfo,
         });
     }
-    static create({ serviceId, serviceInfo, lookupHistory, }) {
-        return new UpdateService(serviceId, {
+    static create({ serviceInfo, lookupHistory, }) {
+        return new UpdateService({
             kind: UpdateServiceKind.Create,
             account: serviceInfo,
             lookupHistory,
@@ -10695,17 +10697,15 @@ var UpdateStorageKind;
  * Can either create/modify an entry or remove it.
  */
 class UpdateStorage {
-    serviceId;
     action;
-    constructor(serviceId, action) {
-        this.serviceId = serviceId;
+    constructor(action) {
         this.action = action;
     }
-    static set({ serviceId, storage }) {
-        return new UpdateStorage(serviceId, { kind: UpdateStorageKind.Set, storage });
+    static set({ storage }) {
+        return new UpdateStorage({ kind: UpdateStorageKind.Set, storage });
     }
-    static remove({ serviceId, key }) {
-        return new UpdateStorage(serviceId, { kind: UpdateStorageKind.Remove, key });
+    static remove({ key }) {
+        return new UpdateStorage({ kind: UpdateStorageKind.Remove, key });
     }
     get key() {
         if (this.action.kind === UpdateStorageKind.Remove) {
@@ -10914,12 +10914,12 @@ class in_memory_state_InMemoryState extends WithDebug {
      * Modify the state and apply a single state update.
      */
     applyUpdate(update) {
-        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 = this.updateServices(servicesUpdates);
+        result = this.updateServices(updated);
         if (result.isError) {
             return result;
         }
@@ -10931,7 +10931,7 @@ class in_memory_state_InMemoryState extends WithDebug {
         if (result.isError) {
             return result;
         }
-        this.removeServices(servicesRemoved);
+        this.removeServices(removed);
         return result_Result.ok(result_OK);
     }
     removeServices(servicesRemoved) {
@@ -10940,89 +10940,102 @@ class in_memory_state_InMemoryState extends WithDebug {
             this.services.delete(serviceId);
         }
     }
-    updateStorage(storage) {
-        for (const { serviceId, action } of storage ?? []) {
-            const { kind } = action;
-            const service = this.services.get(serviceId);
-            if (service === undefined) {
-                return result_Result.error(in_memory_state_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;
-                debug_check `
+    updateStorage(storageUpdates) {
+        if (storageUpdates === undefined) {
+            return result_Result.ok(result_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_Result.error(in_memory_state_UpdateError.NoService, () => `Attempting to update storage of non-existing service: ${serviceId}`);
+                }
+                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;
+                    debug_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 {
-                debug_assertNever(kind);
+                    service.data.storage.delete(key.toString());
+                }
+                else {
+                    debug_assertNever(kind);
+                }
             }
         }
         return result_Result.ok(result_OK);
     }
-    updatePreimages(preimages) {
-        for (const { serviceId, action } of preimages ?? []) {
+    updatePreimages(preimagesUpdates) {
+        if (preimagesUpdates === undefined) {
+            return result_Result.ok(result_OK);
+        }
+        for (const [serviceId, updates] of preimagesUpdates.entries()) {
             const service = this.services.get(serviceId);
             if (service === undefined) {
-                return result_Result.error(in_memory_state_UpdateError.NoService, `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_Result.error(in_memory_state_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 = numbers_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]);
+                return result_Result.error(in_memory_state_UpdateError.NoService, () => `Attempting to update preimage of non-existing service: ${serviceId}`);
+            }
+            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_Result.error(in_memory_state_UpdateError.PreimageExists, () => `Overwriting existing preimage at ${serviceId}: ${preimage}`);
                     }
-                    else {
-                        // insert or replace exiting entry
-                        const index = lookupHistory.map((x) => x.length).indexOf(length);
-                        lookupHistory.splice(index, index === -1 ? 0 : 1, lookup);
+                    service.data.preimages.set(preimage.hash, preimage);
+                    if (slot !== null) {
+                        const lookupHistory = service.data.lookupHistory.get(preimage.hash);
+                        const length = numbers_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 } = 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.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 {
+                    debug_assertNever(kind);
                 }
-            }
-            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 {
-                debug_assertNever(kind);
             }
         }
         return result_Result.ok(result_OK);
     }
     updateServices(servicesUpdates) {
-        for (const { serviceId, action } of servicesUpdates ?? []) {
-            const { kind, account } = action;
+        if (servicesUpdates === undefined) {
+            return result_Result.ok(result_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_Result.error(in_memory_state_UpdateError.DuplicateService, `${serviceId} already exists!`);
+                    return result_Result.error(in_memory_state_UpdateError.DuplicateService, () => `${serviceId} already exists!`);
                 }
                 this.services.set(serviceId, new InMemoryService(serviceId, {
                     info: account,
@@ -11034,7 +11047,7 @@ class in_memory_state_InMemoryState extends WithDebug {
             else if (kind === UpdateServiceKind.Update) {
                 const existingService = this.services.get(serviceId);
                 if (existingService === undefined) {
-                    return result_Result.error(in_memory_state_UpdateError.NoService, `Cannot update ${serviceId} because it does not exist.`);
+                    return result_Result.error(in_memory_state_UpdateError.NoService, () => `Cannot update ${serviceId} because it does not exist.`);
                 }
                 existingService.data.info = account;
             }
@@ -12281,7 +12294,6 @@ function getKeccakTrieHasher(hasher) {
 
 
 
-
 /** What should be done with that key? */
 var StateEntryUpdateAction;
 (function (StateEntryUpdateAction) {
@@ -12297,76 +12309,88 @@ function* serializeStateUpdate(spec, blake2b, update) {
     yield* serializeBasicKeys(spec, update);
     const encode = (codec, val) => encoder_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);
 }
 function* serializeRemovedServices(servicesRemoved) {
-    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_serialize.serviceData(serviceId);
         yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
     }
 }
-function* serializeStorage(storage, blake2b) {
-    for (const { action, serviceId } of storage ?? []) {
-        switch (action.kind) {
-            case UpdateStorageKind.Set: {
-                const key = action.storage.key;
-                const codec = serialize_serialize.serviceStorage(blake2b, serviceId, key);
-                yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
-                break;
-            }
-            case UpdateStorageKind.Remove: {
-                const key = action.key;
-                const codec = serialize_serialize.serviceStorage(blake2b, serviceId, key);
-                yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
-                break;
+function* serializeStorage(storageUpdates, blake2b) {
+    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_serialize.serviceStorage(blake2b, serviceId, key);
+                    yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
+                    break;
+                }
+                case UpdateStorageKind.Remove: {
+                    const key = action.key;
+                    const codec = serialize_serialize.serviceStorage(blake2b, serviceId, key);
+                    yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
+                    break;
+                }
             }
-            default:
-                debug_assertNever(action);
         }
     }
 }
-function* serializePreimages(preimages, encode, blake2b) {
-    for (const { action, serviceId } of preimages ?? []) {
-        switch (action.kind) {
-            case UpdatePreimageKind.Provide: {
-                const { hash, blob } = action.preimage;
-                const codec = serialize_serialize.servicePreimages(blake2b, serviceId, hash);
-                yield [StateEntryUpdateAction.Insert, codec.key, blob];
-                if (action.slot !== null) {
-                    const codec2 = serialize_serialize.serviceLookupHistory(blake2b, serviceId, hash, numbers_tryAsU32(blob.length));
-                    yield [
-                        StateEntryUpdateAction.Insert,
-                        codec2.key,
-                        encode(codec2.Codec, tryAsLookupHistorySlots([action.slot])),
-                    ];
+function* serializePreimages(preimagesUpdates, encode, blake2b) {
+    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_serialize.servicePreimages(blake2b, serviceId, hash);
+                    yield [StateEntryUpdateAction.Insert, codec.key, blob];
+                    if (action.slot !== null) {
+                        const codec2 = serialize_serialize.serviceLookupHistory(blake2b, serviceId, hash, numbers_tryAsU32(blob.length));
+                        yield [
+                            StateEntryUpdateAction.Insert,
+                            codec2.key,
+                            encode(codec2.Codec, tryAsLookupHistorySlots([action.slot])),
+                        ];
+                    }
+                    break;
+                }
+                case UpdatePreimageKind.UpdateOrAdd: {
+                    const { hash, length, slots } = action.item;
+                    const codec = serialize_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_serialize.servicePreimages(blake2b, serviceId, hash);
+                    yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
+                    const codec2 = serialize_serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
+                    yield [StateEntryUpdateAction.Remove, codec2.key, EMPTY_BLOB];
+                    break;
                 }
-                break;
-            }
-            case UpdatePreimageKind.UpdateOrAdd: {
-                const { hash, length, slots } = action.item;
-                const codec = serialize_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_serialize.servicePreimages(blake2b, serviceId, hash);
-                yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
-                const codec2 = serialize_serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
-                yield [StateEntryUpdateAction.Remove, codec2.key, EMPTY_BLOB];
-                break;
             }
-            default:
-                debug_assertNever(action);
         }
     }
 }
 function* serializeServiceUpdates(servicesUpdates, encode, blake2b) {
-    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_serialize.serviceData(serviceId);
         yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, action.account)];
@@ -12653,13 +12677,13 @@ class LeafDb {
      */
     static fromLeavesBlob(blob, db) {
         if (blob.length % TRIE_NODE_BYTES !== 0) {
-            return result_Result.error(LeafDbError.InvalidLeafData, `${blob.length} is not a multiply of ${TRIE_NODE_BYTES}: ${blob}`);
+            return result_Result.error(LeafDbError.InvalidLeafData, () => `${blob.length} is not a multiply of ${TRIE_NODE_BYTES}: ${blob}`);
         }
         const leaves = SortedSet.fromArray(leafComparator, []);
         for (const nodeData of blob.chunks(TRIE_NODE_BYTES)) {
             const node = new TrieNode(nodeData.raw);
             if (node.getNodeType() === NodeType.Branch) {
-                return result_Result.error(LeafDbError.InvalidLeafData, `Branch node detected: ${nodeData}`);
+                return result_Result.error(LeafDbError.InvalidLeafData, () => `Branch node detected: ${nodeData}`);
             }
             leaves.insert(node.asLeafNode());
         }
@@ -13378,7 +13402,7 @@ class LmdbStates {
         }
         catch (e) {
             logger.error `${e}`;
-            return result_Result.error(StateUpdateError.Commit);
+            return result_Result.error(StateUpdateError.Commit, () => `Failed to commit state update: ${e}`);
         }
         return result_Result.ok(result_OK);
     }
@@ -14098,32 +14122,33 @@ class Preimages {
             }
             if (prevPreimage.requester > currPreimage.requester ||
                 currPreimage.blob.compare(prevPreimage.blob).isLessOrEqual()) {
-                return result_Result.error(PreimagesErrorCode.PreimagesNotSortedUnique);
+                return result_Result.error(PreimagesErrorCode.PreimagesNotSortedUnique, () => `Preimages not sorted/unique at index ${i}`);
             }
         }
         const { preimages, slot } = input;
-        const pendingChanges = [];
+        const pendingChanges = new Map();
         // select preimages for integration
         for (const preimage of preimages) {
             const { requester, blob } = preimage;
             const hash = this.blake2b.hashBytes(blob).asOpaque();
             const service = this.state.getService(requester);
             if (service === null) {
-                return result_Result.error(PreimagesErrorCode.AccountNotFound);
+                return result_Result.error(PreimagesErrorCode.AccountNotFound, () => `Service not found: ${requester}`);
             }
             const hasPreimage = service.hasPreimage(hash);
             const slots = service.getLookupHistory(hash, numbers_tryAsU32(blob.length));
             // https://graypaper.fluffylabs.dev/#/5f542d7/181800181900
             // https://graypaper.fluffylabs.dev/#/5f542d7/116f0011a500
             if (hasPreimage || slots === null || !LookupHistoryItem.isRequested(slots)) {
-                return result_Result.error(PreimagesErrorCode.PreimageUnneeded);
+                return result_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(UpdatePreimage.provide({
-                serviceId: requester,
+            const updates = pendingChanges.get(requester) ?? [];
+            updates.push(UpdatePreimage.provide({
                 preimage: PreimageItem.create({ hash, blob }),
                 slot,
             }));
+            pendingChanges.set(requester, updates);
         }
         return result_Result.ok({
             preimages: pendingChanges,
@@ -14161,7 +14186,7 @@ class BlockVerifier {
         const headerHash = this.hasher.header(headerView);
         // check if current block is already imported
         if (this.blocks.getHeader(headerHash.hash) !== null) {
-            return result_Result.error(BlockVerifierError.AlreadyImported, `Block ${headerHash.hash} is already imported.`);
+            return result_Result.error(BlockVerifierError.AlreadyImported, () => `Block ${headerHash.hash} is already imported.`);
         }
         // Check if parent block exists.
         // https://graypaper.fluffylabs.dev/#/cc517d7/0c82000c8200?v=0.6.5
@@ -14171,14 +14196,14 @@ class BlockVerifier {
         if (!parentHash.isEqualTo(block_verifier_ZERO_HASH)) {
             const parentBlock = this.blocks.getHeader(parentHash);
             if (parentBlock === null) {
-                return result_Result.error(BlockVerifierError.ParentNotFound, `Parent ${parentHash.toString()} not found`);
+                return result_Result.error(BlockVerifierError.ParentNotFound, () => `Parent ${parentHash.toString()} not found`);
             }
             // Check if the time slot index is consecutive and not from future.
             // https://graypaper.fluffylabs.dev/#/cc517d7/0c02010c0201?v=0.6.5
             const timeslot = headerView.timeSlotIndex.materialize();
             const parentTimeslot = parentBlock.timeSlotIndex.materialize();
             if (timeslot <= parentTimeslot) {
-                return result_Result.error(BlockVerifierError.InvalidTimeSlot, `Invalid time slot index: ${timeslot}, expected > ${parentTimeslot}`);
+                return result_Result.error(BlockVerifierError.InvalidTimeSlot, () => `Invalid time slot index: ${timeslot}, expected > ${parentTimeslot}`);
             }
         }
         // Check if extrinsic is valid.
@@ -14186,17 +14211,17 @@ class BlockVerifier {
         const extrinsicHash = headerView.extrinsicHash.materialize();
         const extrinsicMerkleCommitment = this.hasher.extrinsic(block.extrinsic.view());
         if (!extrinsicHash.isEqualTo(extrinsicMerkleCommitment.hash)) {
-            return result_Result.error(BlockVerifierError.InvalidExtrinsic, `Invalid extrinsic hash: ${extrinsicHash.toString()}, expected ${extrinsicMerkleCommitment.hash.toString()}`);
+            return result_Result.error(BlockVerifierError.InvalidExtrinsic, () => `Invalid extrinsic hash: ${extrinsicHash.toString()}, expected ${extrinsicMerkleCommitment.hash.toString()}`);
         }
         // Check if the state root is valid.
         // https://graypaper.fluffylabs.dev/#/cc517d7/0c18010c1801?v=0.6.5
         const stateRoot = headerView.priorStateRoot.materialize();
         const posteriorStateRoot = this.blocks.getPostStateRoot(parentHash);
         if (posteriorStateRoot === null) {
-            return result_Result.error(BlockVerifierError.StateRootNotFound, `Posterior state root ${parentHash.toString()} not found`);
+            return result_Result.error(BlockVerifierError.StateRootNotFound, () => `Posterior state root ${parentHash.toString()} not found`);
         }
         if (!stateRoot.isEqualTo(posteriorStateRoot)) {
-            return result_Result.error(BlockVerifierError.InvalidStateRoot, `Invalid prior state root: ${stateRoot.toString()}, expected ${posteriorStateRoot.toString()} (ours)`);
+            return result_Result.error(BlockVerifierError.InvalidStateRoot, () => `Invalid prior state root: ${stateRoot.toString()}, expected ${posteriorStateRoot.toString()} (ours)`);
         }
         return result_Result.ok(headerHash.hash);
     }
@@ -14321,7 +14346,7 @@ class Disputes {
         // check if culprits are sorted by key
         // https://graypaper.fluffylabs.dev/#/579bd12/12c50112c601
         if (!isUniqueSortedBy(disputes.culprits, "key")) {
-            return result_Result.error(DisputesErrorCode.CulpritsNotSortedUnique);
+            return result_Result.error(DisputesErrorCode.CulpritsNotSortedUnique, () => "Culprits are not uniquely sorted by key");
         }
         const culpritsLength = disputes.culprits.length;
         for (let i = 0; i < culpritsLength; i++) {
@@ -14330,24 +14355,24 @@ class Disputes {
             // https://graypaper.fluffylabs.dev/#/579bd12/125501125501
             const isInPunishSet = this.state.disputesRecords.asDictionaries().punishSet.has(key);
             if (isInPunishSet) {
-                return result_Result.error(DisputesErrorCode.OffenderAlreadyReported);
+                return result_Result.error(DisputesErrorCode.OffenderAlreadyReported, () => `Offender already reported: culprit ${i}, key=${key}`);
             }
             // check if the guarantor key is correct
             // https://graypaper.fluffylabs.dev/#/85129da/125501125501?v=0.6.3
             if (!allValidatorKeys.has(key)) {
-                return result_Result.error(DisputesErrorCode.BadGuarantorKey);
+                return result_Result.error(DisputesErrorCode.BadGuarantorKey, () => `Bad guarantor key: culprit ${i}, key=${key}`);
             }
             // verify if the culprit will be in new bad set
             // https://graypaper.fluffylabs.dev/#/579bd12/124601124601
             const isInNewBadSet = newItems.asDictionaries().badSet.has(workReportHash);
             if (!isInNewBadSet) {
-                return result_Result.error(DisputesErrorCode.CulpritsVerdictNotBad);
+                return result_Result.error(DisputesErrorCode.CulpritsVerdictNotBad, () => `Culprit verdict not bad: culprit ${i}, work report=${workReportHash}`);
             }
             // verify culprit signature
             // https://graypaper.fluffylabs.dev/#/579bd12/125c01125c01
             const result = verificationResult.culprits[i];
             if (!result?.isValid) {
-                return result_Result.error(DisputesErrorCode.BadSignature, `Invalid signature for culprit: ${i}`);
+                return result_Result.error(DisputesErrorCode.BadSignature, () => `Invalid signature for culprit: ${i}`);
             }
         }
         return result_Result.ok(null);
@@ -14356,7 +14381,7 @@ class Disputes {
         // check if faults are sorted by key
         // https://graypaper.fluffylabs.dev/#/579bd12/12c50112c601
         if (!isUniqueSortedBy(disputes.faults, "key")) {
-            return result_Result.error(DisputesErrorCode.FaultsNotSortedUnique);
+            return result_Result.error(DisputesErrorCode.FaultsNotSortedUnique, () => "Faults are not uniquely sorted by key");
         }
         const faultsLength = disputes.faults.length;
         for (let i = 0; i < faultsLength; i++) {
@@ -14365,12 +14390,12 @@ class Disputes {
             // https://graypaper.fluffylabs.dev/#/579bd12/12a20112a201
             const isInPunishSet = this.state.disputesRecords.asDictionaries().punishSet.has(key);
             if (isInPunishSet) {
-                return result_Result.error(DisputesErrorCode.OffenderAlreadyReported);
+                return result_Result.error(DisputesErrorCode.OffenderAlreadyReported, () => `Offender already reported: fault ${i}, key=${key}`);
             }
             // check if the auditor key is correct
             // https://graypaper.fluffylabs.dev/#/85129da/12a20112a201?v=0.6.3
             if (!allValidatorKeys.has(key)) {
-                return result_Result.error(DisputesErrorCode.BadAuditorKey);
+                return result_Result.error(DisputesErrorCode.BadAuditorKey, () => `Bad auditor key: fault ${i}, key=${key}`);
             }
             // verify if the fault will be included in new good/bad set
             // it may be not correct as in GP there is "iff" what means it should be rather
@@ -14382,14 +14407,14 @@ class Disputes {
                 const isInNewGoodSet = goodSet.has(workReportHash);
                 const isInNewBadSet = badSet.has(workReportHash);
                 if (isInNewGoodSet || !isInNewBadSet) {
-                    return result_Result.error(DisputesErrorCode.FaultVerdictWrong);
+                    return result_Result.error(DisputesErrorCode.FaultVerdictWrong, () => `Fault verdict wrong: fault ${i}, work report=${workReportHash}, inGood=${isInNewGoodSet}, inBad=${isInNewBadSet}`);
                 }
             }
             // verify fault signature. Verification was done earlier, here we only check the result.
             // https://graypaper.fluffylabs.dev/#/579bd12/12a90112a901
             const result = verificationResult.faults[i];
             if (!result.isValid) {
-                return result_Result.error(DisputesErrorCode.BadSignature, `Invalid signature for fault: ${i}`);
+                return result_Result.error(DisputesErrorCode.BadSignature, () => `Invalid signature for fault: ${i}`);
             }
         }
         return result_Result.ok(null);
@@ -14398,32 +14423,32 @@ class Disputes {
         // check if verdicts are correctly sorted
         // https://graypaper.fluffylabs.dev/#/579bd12/12c40112c401
         if (!isUniqueSortedBy(disputes.verdicts, "workReportHash")) {
-            return result_Result.error(DisputesErrorCode.VerdictsNotSortedUnique);
+            return result_Result.error(DisputesErrorCode.VerdictsNotSortedUnique, () => "Verdicts are not uniquely sorted by work report hash");
         }
         // check if judgement are correctly sorted
         // https://graypaper.fluffylabs.dev/#/579bd12/123702123802
         if (disputes.verdicts.some((verdict) => !isUniqueSortedByIndex(verdict.votes))) {
-            return result_Result.error(DisputesErrorCode.JudgementsNotSortedUnique);
+            return result_Result.error(DisputesErrorCode.JudgementsNotSortedUnique, () => "Judgements are not uniquely sorted by index");
         }
         const currentEpoch = Math.floor(this.state.timeslot / this.chainSpec.epochLength);
         let voteSignatureIndex = 0;
         for (const { votesEpoch, votes } of disputes.verdicts) {
             // https://graypaper.fluffylabs.dev/#/579bd12/12bb0012bc00
             if (votesEpoch !== currentEpoch && votesEpoch + 1 !== currentEpoch) {
-                return result_Result.error(DisputesErrorCode.BadJudgementAge);
+                return result_Result.error(DisputesErrorCode.BadJudgementAge, () => `Bad judgement age: epoch=${votesEpoch}, current=${currentEpoch}`);
             }
             const k = votesEpoch === currentEpoch ? this.state.currentValidatorData : this.state.previousValidatorData;
             for (const { index } of votes) {
                 const key = k[index]?.ed25519;
                 // no particular GP fragment but I think we don't believe in ghosts
                 if (key === undefined) {
-                    return result_Result.error(DisputesErrorCode.BadValidatorIndex);
+                    return result_Result.error(DisputesErrorCode.BadValidatorIndex, () => `Bad validator index: ${index} in epoch ${votesEpoch}`);
                 }
                 // verify vote signature. Verification was done earlier, here we only check the result.
                 // https://graypaper.fluffylabs.dev/#/579bd12/12cd0012cd00
                 const result = verificationResult.judgements[voteSignatureIndex];
                 if (!result.isValid) {
-                    return result_Result.error(DisputesErrorCode.BadSignature, `Invalid signature for judgement: ${voteSignatureIndex}`);
+                    return result_Result.error(DisputesErrorCode.BadSignature, () => `Invalid signature for judgement: ${voteSignatureIndex}`);
                 }
                 voteSignatureIndex += 1;
             }
@@ -14439,7 +14464,7 @@ class Disputes {
             const isInBadSet = badSet.has(verdict.workReportHash);
             const isInWonkySet = wonkySet.has(verdict.workReportHash);
             if (isInGoodSet || isInBadSet || isInWonkySet) {
-                return result_Result.error(DisputesErrorCode.AlreadyJudged);
+                return result_Result.error(DisputesErrorCode.AlreadyJudged, () => `Work report already judged: ${verdict.workReportHash}`);
             }
         }
         return result_Result.ok(null);
@@ -14470,7 +14495,7 @@ class Disputes {
                 // https://graypaper.fluffylabs.dev/#/579bd12/12f10212fc02
                 const f = disputes.faults.find((x) => x.workReportHash.isEqualTo(r));
                 if (f === undefined) {
-                    return result_Result.error(DisputesErrorCode.NotEnoughFaults);
+                    return result_Result.error(DisputesErrorCode.NotEnoughFaults, () => `Not enough faults for work report: ${r}`);
                 }
             }
             else if (sum === 0) {
@@ -14479,13 +14504,13 @@ class Disputes {
                 const c1 = disputes.culprits.find((x) => x.workReportHash.isEqualTo(r));
                 const c2 = disputes.culprits.findLast((x) => x.workReportHash.isEqualTo(r));
                 if (c1 === c2) {
-                    return result_Result.error(DisputesErrorCode.NotEnoughCulprits);
+                    return result_Result.error(DisputesErrorCode.NotEnoughCulprits, () => `Not enough culprits for work report: ${r}`);
                 }
             }
             else if (sum !== this.chainSpec.thirdOfValidators) {
                 // positive votes count is not correct
                 // https://graypaper.fluffylabs.dev/#/579bd12/125002128102
-                return result_Result.error(DisputesErrorCode.BadVoteSplit);
+                return result_Result.error(DisputesErrorCode.BadVoteSplit, () => `Bad vote split: sum=${sum}, expected=${this.chainSpec.thirdOfValidators} for work report ${r}`);
             }
         }
         return result_Result.ok(null);
@@ -14573,7 +14598,7 @@ class Disputes {
                 const validator = k[j.index];
                 // no particular GP fragment but I think we don't believe in ghosts
                 if (validator === undefined) {
-                    return result_Result.error(DisputesErrorCode.BadValidatorIndex);
+                    return result_Result.error(DisputesErrorCode.BadValidatorIndex, () => `Bad validator index in signature verification: ${j.index}`);
                 }
                 const key = validator.ed25519;
                 // verify vote signature
@@ -14681,7 +14706,7 @@ const ringCommitmentCache = [];
 async function verifySeal(bandersnatch, authorKey, signature, payload, encodedUnsealedHeader) {
     const sealResult = await bandersnatch.verifySeal(authorKey.raw, signature.raw, payload.raw, encodedUnsealedHeader.raw);
     if (sealResult[RESULT_INDEX] === ResultValues.Error) {
-        return result_Result.error(null);
+        return result_Result.error(null, () => "Bandersnatch VRF seal verification failed");
     }
     return result_Result.ok(bytes_Bytes.fromBlob(sealResult.subarray(1), hash_HASH_SIZE).asOpaque());
 }
@@ -14707,7 +14732,7 @@ function getRingCommitment(bandersnatch, validators) {
 async function getRingCommitmentNoCache(bandersnatch, keys) {
     const commitmentResult = await bandersnatch.getRingCommitment(keys.raw);
     if (commitmentResult[RESULT_INDEX] === ResultValues.Error) {
-        return result_Result.error(null);
+        return result_Result.error(null, () => "Bandersnatch ring commitment calculation failed");
     }
     return result_Result.ok(bytes_Bytes.fromBlob(commitmentResult.subarray(1), bandersnatch_BANDERSNATCH_RING_ROOT_BYTES).asOpaque());
 }
@@ -14882,7 +14907,7 @@ class Safrole {
                 epochRoot: epochRootResult.ok,
             });
         }
-        return result_Result.error(SafroleErrorCode.IncorrectData);
+        return result_Result.error(SafroleErrorCode.IncorrectData, () => "Safrole: failed to get epoch root for validator keys");
     }
     /**
      * Ticket sequencer that is used in standard mode
@@ -14973,10 +14998,10 @@ class Safrole {
         for (let i = 1; i < ticketsLength; i++) {
             const order = tickets[i - 1].id.compare(tickets[i].id);
             if (order.isEqual()) {
-                return result_Result.error(SafroleErrorCode.DuplicateTicket);
+                return result_Result.error(SafroleErrorCode.DuplicateTicket, () => `Safrole: duplicate ticket found at index ${i}`);
             }
             if (order.isGreater()) {
-                return result_Result.error(SafroleErrorCode.BadTicketOrder);
+                return result_Result.error(SafroleErrorCode.BadTicketOrder, () => `Safrole: bad ticket order at index ${i}`);
             }
         }
         return result_Result.ok(null);
@@ -15003,7 +15028,7 @@ class Safrole {
             attempt: ticket.attempt,
         }));
         if (!verificationResult.every((x) => x.isValid)) {
-            return result_Result.error(SafroleErrorCode.BadTicketProof);
+            return result_Result.error(SafroleErrorCode.BadTicketProof, () => "Safrole: invalid ticket proof in extrinsic");
         }
         /**
          * Verify if tickets are sorted and unique
@@ -15012,7 +15037,7 @@ class Safrole {
          */
         const ticketsVerifcationResult = this.verifyTickets(tickets);
         if (ticketsVerifcationResult.isError) {
-            return result_Result.error(ticketsVerifcationResult.error);
+            return result_Result.error(ticketsVerifcationResult.error, ticketsVerifcationResult.details);
         }
         if (this.isEpochChanged(timeslot)) {
             return result_Result.ok(tickets);
@@ -15021,7 +15046,7 @@ class Safrole {
         const ticketsFromExtrinsic = SortedSet.fromSortedArray(ticketComparator, tickets);
         const mergedTickets = SortedSet.fromTwoSortedCollections(ticketsFromState, ticketsFromExtrinsic);
         if (ticketsFromState.length + ticketsFromExtrinsic.length !== mergedTickets.length) {
-            return result_Result.error(SafroleErrorCode.DuplicateTicket);
+            return result_Result.error(SafroleErrorCode.DuplicateTicket, () => "Safrole: duplicate ticket when merging state and extrinsic tickets");
         }
         /**
          * Remove tickets if size of accumulator exceeds E (epoch length).
@@ -15090,24 +15115,24 @@ class Safrole {
     }
     async transition(input) {
         if (this.state.timeslot >= input.slot) {
-            return result_Result.error(SafroleErrorCode.BadSlot);
+            return result_Result.error(SafroleErrorCode.BadSlot, () => `Safrole: bad slot, state timeslot ${this.state.timeslot} >= input slot ${input.slot}`);
         }
         if (!this.isExtrinsicLengthValid(input.slot, input.extrinsic)) {
-            return result_Result.error(SafroleErrorCode.UnexpectedTicket);
+            return result_Result.error(SafroleErrorCode.UnexpectedTicket, () => `Safrole: unexpected ticket, invalid extrinsic length ${input.extrinsic.length}`);
         }
         if (!this.areTicketAttemptsValid(input.extrinsic)) {
-            return result_Result.error(SafroleErrorCode.BadTicketAttempt);
+            return result_Result.error(SafroleErrorCode.BadTicketAttempt, () => "Safrole: bad ticket attempt value in extrinsic");
         }
         const validatorKeysResult = await this.getValidatorKeys(input.slot, input.punishSet);
         if (validatorKeysResult.isError) {
-            return result_Result.error(validatorKeysResult.error);
+            return result_Result.error(validatorKeysResult.error, validatorKeysResult.details);
         }
         const { nextValidatorData, currentValidatorData, previousValidatorData, epochRoot } = validatorKeysResult.ok;
         const entropy = this.getEntropy(input.slot, input.entropy);
         const sealingKeySeries = this.getSlotKeySequence(input.slot, currentValidatorData, entropy[2]);
         const newTicketsAccumulatorResult = await this.getNewTicketAccumulator(input.slot, input.extrinsic, this.state.nextValidatorData, epochRoot, entropy[2]);
         if (newTicketsAccumulatorResult.isError) {
-            return result_Result.error(newTicketsAccumulatorResult.error);
+            return result_Result.error(newTicketsAccumulatorResult.error, newTicketsAccumulatorResult.details);
         }
         const stateUpdate = {
             nextValidatorData,
@@ -15141,14 +15166,14 @@ function compareWithEncoding(chainSpec, error, actual, expected, codec) {
     if (actual === null || expected === null) {
         // if one of them is `null`, both need to be.
         if (actual !== expected) {
-            return result_Result.error(error, `${SafroleErrorCode[error]} Expected: ${expected}, got: ${actual}`);
+            return result_Result.error(error, () => `${SafroleErrorCode[error]} Expected: ${expected}, got: ${actual}`);
         }
         return result_Result.ok(result_OK);
     }
     // compare the literal encoding.
     const encoded = encoder_Encoder.encodeObject(codec, actual, chainSpec);
     if (!encoded.isEqualTo(expected.encoded())) {
-        return result_Result.error(error, `${SafroleErrorCode[error]} Expected: ${expected.encoded()}, got: ${encoded}`);
+        return result_Result.error(error, () => `${SafroleErrorCode[error]} Expected: ${expected.encoded()}, got: ${encoded}`);
     }
     return result_Result.ok(result_OK);
 }
@@ -15191,7 +15216,7 @@ class SafroleSeal {
         const blockAuthorKey = state.currentValidatorData.at(blockAuthorIndex)?.bandersnatch;
         const entropySourceResult = await bandersnatch_vrf.verifySeal(await this.bandersnatch, blockAuthorKey ?? BANDERSNATCH_ZERO_KEY, headerView.entropySource.materialize(), payload, bytes_BytesBlob.blobFromNumbers([]));
         if (entropySourceResult.isError) {
-            return result_Result.error(SafroleSealError.IncorrectEntropySource);
+            return result_Result.error(SafroleSealError.IncorrectEntropySource, () => "Safrole: incorrect entropy source in header seal");
         }
         return result_Result.ok(entropySourceResult.ok);
     }
@@ -15200,7 +15225,7 @@ class SafroleSeal {
         const validatorIndex = headerView.bandersnatchBlockAuthorIndex.materialize();
         const authorKeys = state.currentValidatorData.at(validatorIndex);
         if (authorKeys === undefined) {
-            return result_Result.error(SafroleSealError.InvalidValidatorIndex);
+            return result_Result.error(SafroleSealError.InvalidValidatorIndex, () => `Safrole: invalid validator index ${validatorIndex}`);
         }
         const timeSlot = headerView.timeSlotIndex.materialize();
         const sealingKeys = state.sealingKeySeries;
@@ -15219,10 +15244,10 @@ class SafroleSeal {
         const authorKey = validatorData.bandersnatch;
         const result = await bandersnatch_vrf.verifySeal(await this.bandersnatch, authorKey ?? BANDERSNATCH_ZERO_KEY, headerView.seal.materialize(), payload, encodeUnsealedHeader(headerView));
         if (result.isError) {
-            return result_Result.error(SafroleSealError.IncorrectSeal);
+            return result_Result.error(SafroleSealError.IncorrectSeal, () => "Safrole: incorrect seal with ticket");
         }
         if (ticket === undefined || !ticket.id.isEqualTo(result.ok)) {
-            return result_Result.error(SafroleSealError.InvalidTicket);
+            return result_Result.error(SafroleSealError.InvalidTicket, () => `Safrole: invalid ticket, expected ${ticket?.id} got ${result.ok}`);
         }
         return result_Result.ok(result.ok);
     }
@@ -15232,13 +15257,13 @@ class SafroleSeal {
         const sealingKey = keys.at(index);
         const authorBandersnatchKey = authorKey.bandersnatch;
         if (sealingKey === undefined || !sealingKey.isEqualTo(authorBandersnatchKey)) {
-            return result_Result.error(SafroleSealError.InvalidValidator, `Invalid Validator. Expected: ${sealingKey}, got: ${authorKey.bandersnatch}`);
+            return result_Result.error(SafroleSealError.InvalidValidator, () => `Invalid Validator. Expected: ${sealingKey}, got: ${authorKey.bandersnatch}`);
         }
         // verify seal correctness
         const payload = bytes_BytesBlob.blobFromParts(JAM_FALLBACK_SEAL, entropy.raw);
         const result = await bandersnatch_vrf.verifySeal(await this.bandersnatch, authorBandersnatchKey, headerView.seal.materialize(), payload, encodeUnsealedHeader(headerView));
         if (result.isError) {
-            return result_Result.error(SafroleSealError.IncorrectSeal);
+            return result_Result.error(SafroleSealError.IncorrectSeal, () => "Safrole: incorrect seal with keys");
         }
         return result_Result.ok(result.ok);
     }
@@ -15281,6 +15306,14 @@ async function getRootHash(yieldedRoots) {
 
 
 const InsufficientFundsError = "insufficient funds";
+/** Deep clone of a map with array. */
+function deepCloneMapWithArray(map) {
+    const cloned = [];
+    for (const [k, v] of map.entries()) {
+        cloned.push([k, v.slice()]);
+    }
+    return new Map(cloned);
+}
 /**
  * State updates that currently accumulating service produced.
  *
@@ -15310,10 +15343,11 @@ class AccumulationStateUpdate {
     /** Create new empty state update. */
     static empty() {
         return new AccumulationStateUpdate({
-            servicesUpdates: [],
-            servicesRemoved: [],
-            preimages: [],
-            storage: [],
+            created: [],
+            updated: new Map(),
+            removed: [],
+            preimages: new Map(),
+            storage: new Map(),
         }, []);
     }
     /** Create a state update with some existing, yet uncommited services updates. */
@@ -15325,10 +15359,13 @@ class AccumulationStateUpdate {
     /** Create a copy of another `StateUpdate`. Used by checkpoints. */
     static copyFrom(from) {
         const serviceUpdates = {
-            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));
@@ -15376,9 +15413,9 @@ class PartiallyUpdatedState {
         if (destination === null) {
             return null;
         }
-        const maybeNewService = this.stateUpdate.services.servicesUpdates.find((update) => update.serviceId === destination);
-        if (maybeNewService !== undefined) {
-            return maybeNewService.action.account;
+        const maybeUpdatedServiceInfo = this.stateUpdate.services.updated.get(destination);
+        if (maybeUpdatedServiceInfo !== undefined) {
+            return maybeUpdatedServiceInfo.action.account;
         }
         const maybeService = this.state.getService(destination);
         if (maybeService === null) {
@@ -15387,7 +15424,8 @@ class PartiallyUpdatedState {
         return maybeService.getInfo();
     }
     getStorage(serviceId, rawKey) {
-        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;
         }
@@ -15402,10 +15440,11 @@ class PartiallyUpdatedState {
      * the existence in `preimages` map.
      */
     hasPreimage(serviceId, hash) {
-        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;
         }
@@ -15418,7 +15457,8 @@ class PartiallyUpdatedState {
     }
     getPreimage(serviceId, hash) {
         // 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;
         }
@@ -15427,10 +15467,11 @@ class PartiallyUpdatedState {
     }
     /** Get status of a preimage of current service taking into account any updates. */
     getLookupHistory(currentTimeslot, serviceId, hash, length) {
+        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 = () => {
             // fallback to state lookup
             const service = this.state.getService(serviceId);
@@ -15467,14 +15508,15 @@ class PartiallyUpdatedState {
     /* State update functions. */
     updateStorage(serviceId, key, value) {
         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);
     }
     /**
      * Update a preimage.
@@ -15482,8 +15524,10 @@ class PartiallyUpdatedState {
      * 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) {
-        this.stateUpdate.services.preimages.push(newUpdate);
+    updatePreimage(serviceId, newUpdate) {
+        const updatePreimages = this.stateUpdate.services.preimages.get(serviceId) ?? [];
+        updatePreimages.push(newUpdate);
+        this.stateUpdate.services.preimages.set(serviceId, updatePreimages);
     }
     updateServiceStorageUtilisation(serviceId, items, bytes, serviceInfo) {
         debug_check `${items >= 0} storageUtilisationCount has to be a positive number, got: ${items}`;
@@ -15492,11 +15536,11 @@ class PartiallyUpdatedState {
         const overflowBytes = !isU64(bytes);
         // TODO [ToDr] this is not specified in GP, but it seems sensible.
         if (overflowItems || overflowBytes) {
-            return result_Result.error(InsufficientFundsError);
+            return result_Result.error(InsufficientFundsError, () => `Storage utilisation overflow: items=${overflowItems}, bytes=${overflowBytes}`);
         }
         const thresholdBalance = ServiceAccountInfo.calculateThresholdBalance(items, bytes, serviceInfo.gratisStorage);
         if (serviceInfo.balance < thresholdBalance) {
-            return result_Result.error(InsufficientFundsError);
+            return result_Result.error(InsufficientFundsError, () => `Service balance (${serviceInfo.balance}) below threshold (${thresholdBalance})`);
         }
         // Update service info with new details.
         this.updateServiceInfo(serviceId, ServiceAccountInfo.create({
@@ -15507,20 +15551,23 @@ class PartiallyUpdatedState {
         return result_Result.ok(result_OK);
     }
     updateServiceInfo(serviceId, newInfo) {
-        const idx = this.stateUpdate.services.servicesUpdates.findIndex((x) => x.serviceId === serviceId);
-        const toRemove = idx === -1 ? 0 : 1;
-        const existingItem = this.stateUpdate.services.servicesUpdates[idx];
-        if (existingItem?.action.kind === UpdateServiceKind.Create) {
-            this.stateUpdate.services.servicesUpdates.splice(idx, toRemove, UpdateService.create({
-                serviceId,
+        const existingUpdate = this.stateUpdate.services.updated.get(serviceId);
+        if (existingUpdate?.action.kind === UpdateServiceKind.Create) {
+            this.stateUpdate.services.updated.set(serviceId, UpdateService.create({
                 serviceInfo: newInfo,
-                lookupHistory: existingItem.action.lookupHistory,
+                lookupHistory: existingUpdate.action.lookupHistory,
             }));
             return;
         }
-        this.stateUpdate.services.servicesUpdates.splice(idx, toRemove, UpdateService.update({
-            serviceId,
+        this.stateUpdate.services.updated.set(serviceId, UpdateService.update({
+            serviceInfo: newInfo,
+        }));
+    }
+    createService(serviceId, newInfo, newLookupHistory) {
+        this.stateUpdate.services.created.push(serviceId);
+        this.stateUpdate.services.updated.set(serviceId, UpdateService.create({
             serviceInfo: newInfo,
+            lookupHistory: newLookupHistory,
         }));
     }
     getPrivilegedServices() {
@@ -16996,7 +17043,7 @@ class ReadablePage extends MemoryPage {
     loadInto(result, startIndex, length) {
         const endIndex = startIndex + length;
         if (endIndex > PAGE_SIZE) {
-            return result_Result.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE));
+            return result_Result.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE), () => `Page fault: read beyond page boundary at ${this.start + PAGE_SIZE}`);
         }
         const bytes = this.data.subarray(startIndex, endIndex);
         // we zero the bytes, since data might not yet be initialized at `endIndex`.
@@ -17005,7 +17052,7 @@ class ReadablePage extends MemoryPage {
         return result_Result.ok(result_OK);
     }
     storeFrom(_address, _data) {
-        return result_Result.error(PageFault.fromMemoryIndex(this.start, true));
+        return result_Result.error(PageFault.fromMemoryIndex(this.start, true), () => `Page fault: attempted to write to read-only page at ${this.start}`);
     }
     setData(pageIndex, data) {
         this.data.set(data, pageIndex);
@@ -17039,7 +17086,7 @@ class WriteablePage extends MemoryPage {
     loadInto(result, startIndex, length) {
         const endIndex = startIndex + length;
         if (endIndex > PAGE_SIZE) {
-            return result_Result.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE));
+            return result_Result.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE), () => `Page fault: read beyond page boundary at ${this.start + PAGE_SIZE}`);
         }
         const bytes = this.view.subarray(startIndex, endIndex);
         // we zero the bytes, since the view might not yet be initialized at `endIndex`.
@@ -17125,7 +17172,7 @@ class Memory {
         memory_logger.insane `MEM[${address}] <- ${bytes_BytesBlob.blobFrom(bytes)}`;
         const pagesResult = this.getPages(address, bytes.length, AccessType.WRITE);
         if (pagesResult.isError) {
-            return result_Result.error(pagesResult.error);
+            return result_Result.error(pagesResult.error, pagesResult.details);
         }
         const pages = pagesResult.ok;
         let currentPosition = address;
@@ -17150,14 +17197,14 @@ class Memory {
         const pages = [];
         for (const pageNumber of pageRange) {
             if (pageNumber < RESERVED_NUMBER_OF_PAGES) {
-                return result_Result.error(PageFault.fromPageNumber(pageNumber, true));
+                return result_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_Result.error(PageFault.fromPageNumber(pageNumber));
+                return result_Result.error(PageFault.fromPageNumber(pageNumber), () => `Page fault: page ${pageNumber} not allocated`);
             }
             if (accessType === AccessType.WRITE && !page.isWriteable()) {
-                return result_Result.error(PageFault.fromPageNumber(pageNumber, true));
+                return result_Result.error(PageFault.fromPageNumber(pageNumber, true), () => `Page fault: attempted to write to read-only page ${pageNumber}`);
             }
             pages.push(page);
         }
@@ -17175,7 +17222,7 @@ class Memory {
         }
         const pagesResult = this.getPages(startAddress, result.length, AccessType.READ);
         if (pagesResult.isError) {
-            return result_Result.error(pagesResult.error);
+            return result_Result.error(pagesResult.error, pagesResult.details);
         }
         const pages = pagesResult.ok;
         let currentPosition = startAddress;
@@ -19114,7 +19161,7 @@ class ProgramDecoder {
         }
         catch (e) {
             program_decoder_logger.error `Invalid program: ${e}`;
-            return result_Result.error(ProgramDecoderError.InvalidProgramError);
+            return result_Result.error(ProgramDecoderError.InvalidProgramError, () => `Program decoder error: ${e}`);
         }
     }
 }
@@ -19857,10 +19904,10 @@ class AccumulateExternalities {
             const len = existingPreimage.slots.length;
             // https://graypaper.fluffylabs.dev/#/9a08063/380901380901?v=0.6.6
             if (len === PreimageStatusKind.Requested) {
-                return result_Result.error(RequestPreimageError.AlreadyRequested);
+                return result_Result.error(RequestPreimageError.AlreadyRequested, () => `Preimage already requested: hash=${hash}`);
             }
             if (len === PreimageStatusKind.Available || len === PreimageStatusKind.Reavailable) {
-                return result_Result.error(RequestPreimageError.AlreadyAvailable);
+                return result_Result.error(RequestPreimageError.AlreadyAvailable, () => `Preimage already available: hash=${hash}`);
             }
             // TODO [ToDr] Not sure if we should update the service info in that case,
             // but for now we let that case fall-through.
@@ -19885,15 +19932,13 @@ class AccumulateExternalities {
         const clampedLength = clampU64ToU32(length);
         if (existingPreimage === null) {
             // https://graypaper.fluffylabs.dev/#/9a08063/38a60038a600?v=0.6.6
-            this.updatedState.updatePreimage(UpdatePreimage.updateOrAdd({
-                serviceId: this.currentServiceId,
+            this.updatedState.updatePreimage(this.currentServiceId, UpdatePreimage.updateOrAdd({
                 lookupHistory: new LookupHistoryItem(hash, clampedLength, tryAsLookupHistorySlots([])),
             }));
         }
         else {
             /** https://graypaper.fluffylabs.dev/#/9a08063/38ca0038ca00?v=0.6.6 */
-            this.updatedState.updatePreimage(UpdatePreimage.updateOrAdd({
-                serviceId: this.currentServiceId,
+            this.updatedState.updatePreimage(this.currentServiceId, UpdatePreimage.updateOrAdd({
                 lookupHistory: new LookupHistoryItem(hash, clampedLength, tryAsLookupHistorySlots([...existingPreimage.slots, this.currentTimeslot])),
             }));
         }
@@ -19903,7 +19948,7 @@ class AccumulateExternalities {
         const serviceId = this.currentServiceId;
         const status = this.updatedState.getLookupHistory(this.currentTimeslot, this.currentServiceId, hash, length);
         if (status === null) {
-            return result_Result.error(ForgetPreimageError.NotFound);
+            return result_Result.error(ForgetPreimageError.NotFound, () => `Preimage not found: hash=${hash}, length=${length}`);
         }
         const s = slotsToPreimageStatus(status.slots);
         const updateStorageUtilisation = () => {
@@ -19916,10 +19961,9 @@ class AccumulateExternalities {
         if (s.status === PreimageStatusKind.Requested) {
             const res = updateStorageUtilisation();
             if (res.isError) {
-                return result_Result.error(ForgetPreimageError.StorageUtilisationError);
+                return result_Result.error(ForgetPreimageError.StorageUtilisationError, res.details);
             }
-            this.updatedState.updatePreimage(UpdatePreimage.remove({
-                serviceId,
+            this.updatedState.updatePreimage(serviceId, UpdatePreimage.remove({
                 hash: status.hash,
                 length: status.length,
             }));
@@ -19932,21 +19976,19 @@ class AccumulateExternalities {
             if (y < t - this.chainSpec.preimageExpungePeriod) {
                 const res = updateStorageUtilisation();
                 if (res.isError) {
-                    return result_Result.error(ForgetPreimageError.StorageUtilisationError);
+                    return result_Result.error(ForgetPreimageError.StorageUtilisationError, res.details);
                 }
-                this.updatedState.updatePreimage(UpdatePreimage.remove({
-                    serviceId,
+                this.updatedState.updatePreimage(serviceId, UpdatePreimage.remove({
                     hash: status.hash,
                     length: status.length,
                 }));
                 return result_Result.ok(result_OK);
             }
-            return result_Result.error(ForgetPreimageError.NotExpired);
+            return result_Result.error(ForgetPreimageError.NotExpired, () => `Preimage not expired: y=${y}, timeslot=${t}, period=${this.chainSpec.preimageExpungePeriod}`);
         }
         // https://graypaper.fluffylabs.dev/#/9a08063/38c80138c801?v=0.6.6
         if (s.status === PreimageStatusKind.Available) {
-            this.updatedState.updatePreimage(UpdatePreimage.updateOrAdd({
-                serviceId,
+            this.updatedState.updatePreimage(serviceId, UpdatePreimage.updateOrAdd({
                 lookupHistory: new LookupHistoryItem(status.hash, status.length, tryAsLookupHistorySlots([s.data[0], t])),
             }));
             return result_Result.ok(result_OK);
@@ -19955,13 +19997,12 @@ class AccumulateExternalities {
         if (s.status === PreimageStatusKind.Reavailable) {
             const y = s.data[1];
             if (y < t - this.chainSpec.preimageExpungePeriod) {
-                this.updatedState.updatePreimage(UpdatePreimage.updateOrAdd({
-                    serviceId,
+                this.updatedState.updatePreimage(serviceId, UpdatePreimage.updateOrAdd({
                     lookupHistory: new LookupHistoryItem(status.hash, status.length, tryAsLookupHistorySlots([s.data[2], t])),
                 }));
                 return result_Result.ok(result_OK);
             }
-            return result_Result.error(ForgetPreimageError.NotExpired);
+            return result_Result.error(ForgetPreimageError.NotExpired, () => `Preimage not expired: y=${y}, timeslot=${t}, period=${this.chainSpec.preimageExpungePeriod}`);
         }
         debug_assertNever(s);
     }
@@ -19970,17 +20011,17 @@ class AccumulateExternalities {
         const destination = this.getServiceInfo(destinationId);
         /** https://graypaper.fluffylabs.dev/#/9a08063/370401370401?v=0.6.6 */
         if (destination === null || destinationId === null) {
-            return result_Result.error(TransferError.DestinationNotFound);
+            return result_Result.error(TransferError.DestinationNotFound, () => `Destination service not found: ${destinationId}`);
         }
         /** https://graypaper.fluffylabs.dev/#/9a08063/371301371301?v=0.6.6 */
         if (gas < destination.onTransferMinGas) {
-            return result_Result.error(TransferError.GasTooLow);
+            return result_Result.error(TransferError.GasTooLow, () => `Gas ${gas} below minimum ${destination.onTransferMinGas}`);
         }
         /** https://graypaper.fluffylabs.dev/#/9a08063/371b01371b01?v=0.6.6 */
         const newBalance = source.balance - amount;
         const thresholdBalance = ServiceAccountInfo.calculateThresholdBalance(source.storageUtilisationCount, source.storageUtilisationBytes, source.gratisStorage);
         if (newBalance < thresholdBalance) {
-            return result_Result.error(TransferError.BalanceBelowThreshold);
+            return result_Result.error(TransferError.BalanceBelowThreshold, () => `Balance ${newBalance} below threshold ${thresholdBalance}`);
         }
         // outgoing transfer
         this.updatedState.stateUpdate.transfers.push(PendingTransfer.create({
@@ -20007,7 +20048,7 @@ class AccumulateExternalities {
         // check if we are priviledged to set gratis storage
         // https://graypaper.fluffylabs.dev/#/7e6ff6a/369203369603?v=0.6.7
         if (gratisStorage !== numbers_tryAsU64(0) && this.currentServiceId !== this.updatedState.getPrivilegedServices().manager) {
-            return result_Result.error(NewServiceError.UnprivilegedService);
+            return result_Result.error(NewServiceError.UnprivilegedService, () => `Service ${this.currentServiceId} not privileged to set gratis storage`);
         }
         // check if we have enough balance
         // https://graypaper.fluffylabs.dev/#/7e6ff6a/369e0336a303?v=0.6.7
@@ -20016,7 +20057,7 @@ class AccumulateExternalities {
         const thresholdForCurrent = ServiceAccountInfo.calculateThresholdBalance(currentService.storageUtilisationCount, currentService.storageUtilisationBytes, currentService.gratisStorage);
         const balanceLeftForCurrent = currentService.balance - thresholdForNew;
         if (balanceLeftForCurrent < thresholdForCurrent || bytes.overflow) {
-            return result_Result.error(NewServiceError.InsufficientFunds);
+            return result_Result.error(NewServiceError.InsufficientFunds, () => `Insufficient funds: balance=${currentService.balance}, required=${thresholdForNew}, overflow=${bytes.overflow}`);
         }
         // `a`: https://graypaper.fluffylabs.dev/#/ab2cdbd/366b02366d02?v=0.7.2
         const newAccount = ServiceAccountInfo.create({
@@ -20043,15 +20084,11 @@ class AccumulateExternalities {
                 // NOTE: It's safe to cast to `Number` here, bcs here service ID cannot be bigger than 2**16
                 const newServiceId = tryAsServiceId(Number(wantedServiceId));
                 if (this.getServiceInfo(newServiceId) !== null) {
-                    return result_Result.error(NewServiceError.RegistrarServiceIdAlreadyTaken);
+                    return result_Result.error(NewServiceError.RegistrarServiceIdAlreadyTaken, () => `Service ID ${newServiceId} already taken`);
                 }
                 // add the new service with selected ID
                 // https://graypaper.fluffylabs.dev/#/ab2cdbd/36be0336c003?v=0.7.2
-                this.updatedState.stateUpdate.services.servicesUpdates.push(UpdateService.create({
-                    serviceId: newServiceId,
-                    serviceInfo: newAccount,
-                    lookupHistory: newLookupItem,
-                }));
+                this.updatedState.createService(newServiceId, newAccount, newLookupItem);
                 // update the balance of current service
                 // https://graypaper.fluffylabs.dev/#/ab2cdbd/36c20336c403?v=0.7.2
                 this.updatedState.updateServiceInfo(this.currentServiceId, updatedCurrentAccount);
@@ -20062,12 +20099,8 @@ class AccumulateExternalities {
         }
         const newServiceId = this.nextNewServiceId;
         // add the new service
-        // https://graypaper.fluffylabs.dev/#/ab2cdbd/36e70336e903?v=0.7.2
-        this.updatedState.stateUpdate.services.servicesUpdates.push(UpdateService.create({
-            serviceId: newServiceId,
-            serviceInfo: newAccount,
-            lookupHistory: newLookupItem,
-        }));
+        // https://graypaper.fluffylabs.dev/#/7e6ff6a/36cb0236cb02?v=0.6.7
+        this.updatedState.createService(newServiceId, newAccount, newLookupItem);
         // update the balance of current service
         // https://graypaper.fluffylabs.dev/#/ab2cdbd/36ec0336ee03?v=0.7.2
         this.updatedState.updateServiceInfo(this.currentServiceId, updatedCurrentAccount);
@@ -20091,7 +20124,7 @@ class AccumulateExternalities {
         const currentDelegator = this.updatedState.getPrivilegedServices().delegator;
         if (currentDelegator !== this.currentServiceId) {
             accumulate_externalities_logger.trace `Current service id (${this.currentServiceId}) is not a validators manager. (expected: ${currentDelegator}) and cannot update validators data. Ignoring`;
-            return result_Result.error(UnprivilegedError);
+            return result_Result.error(UnprivilegedError, () => `Service ${this.currentServiceId} is not delegator (expected: ${currentDelegator})`);
         }
         this.updatedState.stateUpdate.validatorsData = validatorsData;
         return result_Result.ok(result_OK);
@@ -20106,11 +20139,11 @@ class AccumulateExternalities {
         const currentAssigners = this.updatedState.getPrivilegedServices().assigners[coreIndex];
         if (currentAssigners !== this.currentServiceId) {
             accumulate_externalities_logger.trace `Current service id (${this.currentServiceId}) is not an auth manager of core ${coreIndex} (expected: ${currentAssigners}) and cannot update authorization queue.`;
-            return result_Result.error(UpdatePrivilegesError.UnprivilegedService);
+            return result_Result.error(UpdatePrivilegesError.UnprivilegedService, () => `Service ${this.currentServiceId} not assigner for core ${coreIndex} (expected: ${currentAssigners})`);
         }
         if (assigners === null && Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)) {
             accumulate_externalities_logger.trace `The new auth manager is not a valid service id.`;
-            return result_Result.error(UpdatePrivilegesError.InvalidServiceId);
+            return result_Result.error(UpdatePrivilegesError.InvalidServiceId, () => `New auth manager is null for core ${coreIndex}`);
         }
         this.updatedState.stateUpdate.authorizationQueues.set(coreIndex, authQueue);
         return result_Result.ok(result_OK);
@@ -20143,10 +20176,10 @@ class AccumulateExternalities {
         const isManager = current.manager === this.currentServiceId;
         if (Compatibility.isLessThan(GpVersion.V0_7_1)) {
             if (!isManager) {
-                return result_Result.error(UpdatePrivilegesError.UnprivilegedService);
+                return result_Result.error(UpdatePrivilegesError.UnprivilegedService, () => `Service ${this.currentServiceId} is not manager`);
             }
             if (manager === null || delegator === null) {
-                return result_Result.error(UpdatePrivilegesError.InvalidServiceId, "Either manager or delegator is not a valid service id.");
+                return result_Result.error(UpdatePrivilegesError.InvalidServiceId, () => "Either manager or delegator is not a valid service id.");
             }
             this.updatedState.stateUpdate.privilegedServices = PrivilegedServices.create({
                 manager,
@@ -20159,7 +20192,7 @@ class AccumulateExternalities {
         }
         const original = this.updatedState.state.privilegedServices;
         if (manager === null || delegator === null || registrar === null) {
-            return result_Result.error(UpdatePrivilegesError.InvalidServiceId, "Either manager or delegator or registrar is not a valid service id.");
+            return result_Result.error(UpdatePrivilegesError.InvalidServiceId, () => "Either manager or delegator or registrar is not a valid service id.");
         }
         const newDelegator = this.updatePrivilegedServiceId(delegator, current.delegator, {
             isManager,
@@ -20199,23 +20232,22 @@ class AccumulateExternalities {
         // TODO [ToDr] what about newly created services?
         const service = serviceId === null ? null : this.updatedState.state.getService(serviceId);
         if (service === null || serviceId === null) {
-            return result_Result.error(ProvidePreimageError.ServiceNotFound);
+            return result_Result.error(ProvidePreimageError.ServiceNotFound, () => `Service not found: ${serviceId}`);
         }
         // calculating the hash
         const preimageHash = this.blake2b.hashBytes(preimage).asOpaque();
         // checking service internal lookup
         const stateLookup = this.updatedState.getLookupHistory(this.currentTimeslot, serviceId, preimageHash, numbers_tryAsU64(preimage.length));
         if (stateLookup === null || !LookupHistoryItem.isRequested(stateLookup)) {
-            return result_Result.error(ProvidePreimageError.WasNotRequested);
+            return result_Result.error(ProvidePreimageError.WasNotRequested, () => `Preimage was not requested: hash=${preimageHash}, service=${serviceId}`);
         }
         // checking already provided preimages
         const hasPreimage = this.updatedState.hasPreimage(serviceId, preimageHash);
         if (hasPreimage) {
-            return result_Result.error(ProvidePreimageError.AlreadyProvided);
+            return result_Result.error(ProvidePreimageError.AlreadyProvided, () => `Preimage already provided: hash=${preimageHash}, service=${serviceId}`);
         }
         // setting up the new preimage
-        this.updatedState.updatePreimage(UpdatePreimage.provide({
-            serviceId,
+        this.updatedState.updatePreimage(serviceId, UpdatePreimage.provide({
             preimage: PreimageItem.create({
                 hash: preimageHash,
                 blob: preimage,
@@ -20227,31 +20259,31 @@ class AccumulateExternalities {
     eject(destination, previousCodeHash) {
         const service = this.getServiceInfo(destination);
         if (service === null || destination === null) {
-            return result_Result.error(EjectError.InvalidService, "Service missing");
+            return result_Result.error(EjectError.InvalidService, () => "Service missing");
         }
         const currentService = this.getCurrentServiceInfo();
         // check if the service expects to be ejected by us:
         const expectedCodeHash = bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
         writeServiceIdAsLeBytes(this.currentServiceId, expectedCodeHash.raw);
         if (!service.codeHash.isEqualTo(expectedCodeHash)) {
-            return result_Result.error(EjectError.InvalidService, "Invalid code hash");
+            return result_Result.error(EjectError.InvalidService, () => "Invalid code hash");
         }
         // make sure the service only has required number of storage items?
         if (service.storageUtilisationCount !== REQUIRED_NUMBER_OF_STORAGE_ITEMS_FOR_EJECT) {
-            return result_Result.error(EjectError.InvalidPreimage, "Too many storage items");
+            return result_Result.error(EjectError.InvalidPreimage, () => "Too many storage items");
         }
         // storage items length
         const l = numbers_tryAsU64(maxU64(service.storageUtilisationBytes, LOOKUP_HISTORY_ENTRY_BYTES) - LOOKUP_HISTORY_ENTRY_BYTES);
         // check if we have a preimage with the entire storage.
         const [isPreviousCodeExpired, errorReason] = this.isPreviousCodeExpired(destination, previousCodeHash, l);
         if (!isPreviousCodeExpired) {
-            return result_Result.error(EjectError.InvalidPreimage, `Previous code available: ${errorReason}`);
+            return result_Result.error(EjectError.InvalidPreimage, () => `Previous code available: ${errorReason}`);
         }
         // compute new balance of the service.
         const newBalance = sumU64(currentService.balance, service.balance);
         // TODO [ToDr] what to do in case of overflow?
         if (newBalance.overflow) {
-            return result_Result.error(EjectError.InvalidService, "Balance overflow");
+            return result_Result.error(EjectError.InvalidService, () => "Balance overflow");
         }
         // update current service.
         this.updatedState.updateServiceInfo(this.currentServiceId, ServiceAccountInfo.create({
@@ -20259,11 +20291,13 @@ class AccumulateExternalities {
             balance: newBalance.value,
         }));
         // and finally add an ejected service.
-        this.updatedState.stateUpdate.services.servicesRemoved.push(destination);
+        this.updatedState.stateUpdate.services.removed.push(destination);
         // take care of the code preimage and its lookup history
         // Safe, because we know the preimage is valid, and it's the code of the service, which is bounded by maximal service code size anyway (much smaller than 2**32 bytes).
         const preimageLength = numbers_tryAsU32(Number(l));
-        this.updatedState.stateUpdate.services.preimages.push(UpdatePreimage.remove({ serviceId: destination, hash: previousCodeHash, length: preimageLength }));
+        const preimages = this.updatedState.stateUpdate.services.preimages.get(destination) ?? [];
+        preimages.push(UpdatePreimage.remove({ hash: previousCodeHash, length: preimageLength }));
+        this.updatedState.stateUpdate.services.preimages.set(destination, preimages);
         return result_Result.ok(result_OK);
     }
     read(serviceId, rawKey) {
@@ -20444,10 +20478,10 @@ class Assurances {
         for (const assurance of assurances) {
             const { anchor, validatorIndex, bitfield } = assurance;
             if (!anchor.isEqualTo(input.parentHash)) {
-                return result_Result.error(AssurancesError.InvalidAnchor, `anchor: expected: ${input.parentHash}, got ${anchor}`);
+                return result_Result.error(AssurancesError.InvalidAnchor, () => `anchor: expected: ${input.parentHash}, got ${anchor}`);
             }
             if (prevValidatorIndex >= validatorIndex) {
-                return result_Result.error(AssurancesError.InvalidOrder, `order: expected: ${prevValidatorIndex + 1}, got: ${validatorIndex}`);
+                return result_Result.error(AssurancesError.InvalidOrder, () => `order: expected: ${prevValidatorIndex + 1}, got: ${validatorIndex}`);
             }
             prevValidatorIndex = assurance.validatorIndex;
             debug_check `${bitfield.bitLength === coresCount} Invalid bitfield length of ${bitfield.bitLength}`;
@@ -20470,7 +20504,7 @@ class Assurances {
              * https://graypaper.fluffylabs.dev/#/579bd12/14e90014ea00
              */
             if (noOfAssurances > 0 && !isReportPending) {
-                return result_Result.error(AssurancesError.NoReportPending, `no report pending for core ${c} yet we got an assurance`);
+                return result_Result.error(AssurancesError.NoReportPending, () => `no report pending for core ${c} yet we got an assurance`);
             }
             /**
              * Remove work report if it's became available or timed out.
@@ -20516,7 +20550,7 @@ class Assurances {
             const v = assurance.view();
             const key = validatorData[v.validatorIndex.materialize()];
             if (key === undefined) {
-                return result_Result.error(AssurancesError.InvalidValidatorIndex);
+                return result_Result.error(AssurancesError.InvalidValidatorIndex, () => `Invalid validator index: ${v.validatorIndex.materialize()}`);
             }
             signatures.push({
                 signature: v.signature.materialize(),
@@ -20528,7 +20562,7 @@ class Assurances {
         const isAllSignaturesValid = signaturesValid.every((x) => x);
         if (!isAllSignaturesValid) {
             const invalidIndices = signaturesValid.reduce((acc, isValid, idx) => (isValid ? acc : acc.concat(idx)), []);
-            return result_Result.error(AssurancesError.InvalidSignature, `invalid signatures at ${invalidIndices.join(", ")}`);
+            return result_Result.error(AssurancesError.InvalidSignature, () => `invalid signatures at ${invalidIndices.join(", ")}`);
         }
         return result_Result.ok(result_OK);
     }
@@ -21139,7 +21173,7 @@ class HostCallMemory {
             return result_Result.ok(result_OK);
         }
         if (address + numbers_tryAsU64(bytes.length) > MEMORY_SIZE) {
-            return result_Result.error(new OutOfBounds());
+            return result_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);
     }
@@ -21148,7 +21182,7 @@ class HostCallMemory {
             return result_Result.ok(result_OK);
         }
         if (startAddress + numbers_tryAsU64(result.length) > MEMORY_SIZE) {
-            return result_Result.error(new OutOfBounds());
+            return result_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)));
     }
@@ -23091,18 +23125,18 @@ class Accumulate {
         const serviceInfo = updatedState.getServiceInfo(serviceId);
         if (serviceInfo === null) {
             accumulate_logger.log `Service with id ${serviceId} not found.`;
-            return result_Result.error(PvmInvocationError.NoService);
+            return result_Result.error(PvmInvocationError.NoService, () => `Accumulate: service ${serviceId} not found`);
         }
         const codeHash = serviceInfo.codeHash;
         // TODO [ToDr] Should we check that the preimage is still available?
         const code = updatedState.getPreimage(serviceId, codeHash.asOpaque());
         if (code === null) {
             accumulate_logger.log `Code with hash ${codeHash} not found for service ${serviceId}.`;
-            return result_Result.error(PvmInvocationError.NoPreimage);
+            return result_Result.error(PvmInvocationError.NoPreimage, () => `Accumulate: code with hash ${codeHash} not found for service ${serviceId}`);
         }
         if (code.length > W_C) {
             accumulate_logger.log `Code with hash ${codeHash} is too long for service ${serviceId}.`;
-            return result_Result.error(PvmInvocationError.PreimageTooLong);
+            return result_Result.error(PvmInvocationError.PreimageTooLong, () => `Accumulate: code length ${code.length} exceeds max ${W_C} for service ${serviceId}`);
         }
         const nextServiceId = generateNextServiceId({ serviceId, entropy, timeslot: slot }, this.chainSpec, this.blake2b);
         const partialState = new AccumulateExternalities(this.chainSpec, this.blake2b, updatedState, serviceId, nextServiceId, slot);
@@ -23357,19 +23391,16 @@ class Accumulate {
         const gasLimit = tryAsServiceGas(this.chainSpec.maxBlockGas > calculatedGasLimit ? this.chainSpec.maxBlockGas : calculatedGasLimit);
         return tryAsServiceGas(gasLimit);
     }
-    hasDuplicatedServicesCreated(updateServices) {
-        const createdServiceIds = new Set();
-        for (const update of updateServices) {
-            if (update.action.kind === UpdateServiceKind.Create) {
-                const serviceId = update.serviceId;
-                if (createdServiceIds.has(serviceId)) {
-                    accumulate_logger.log `Duplicated Service creation detected ${serviceId}. Block is invalid.`;
-                    return true;
-                }
-                createdServiceIds.add(serviceId);
-            }
-        }
-        return false;
+    /**
+     * Detects the very unlikely situation where multiple services are created with the same ID.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/30f20330f403?v=0.7.2
+     *
+     * NOTE: This is public only for testing purposes and should not be used outside of accumulation.
+     */
+    hasDuplicatedServiceIdCreated(createdIds) {
+        const uniqueIds = new Set(createdIds);
+        return uniqueIds.size !== createdIds.length;
     }
     async transition({ reports, slot, entropy }) {
         const statistics = new Map();
@@ -23391,8 +23422,9 @@ class Accumulate {
         const accumulated = accumulatableReports.subview(0, accumulatedReports);
         const { services, yieldedRoots, transfers, validatorsData, privilegedServices, authorizationQueues, ...stateUpdateRest } = state;
         assertEmpty(stateUpdateRest);
-        if (this.hasDuplicatedServicesCreated(services.servicesUpdates)) {
-            return result_Result.error(ACCUMULATION_ERROR);
+        if (this.hasDuplicatedServiceIdCreated(services.created)) {
+            accumulate_logger.trace `Duplicated Service creation detected. Block is invalid.`;
+            return result_Result.error(ACCUMULATION_ERROR, () => "Accumulate: duplicate service created");
         }
         const accStateUpdate = this.getAccumulationStateUpdate(accumulated.toArray(), toAccumulateLater, slot, Array.from(statistics.keys()), services);
         const accumulationOutputUnsorted = Array.from(yieldedRoots.entries()).map(([serviceId, root]) => {
@@ -23473,13 +23505,13 @@ class DeferredTransfers {
                 .toSorted((a, b) => a.source - b.source);
             const info = partiallyUpdatedState.getServiceInfo(serviceId);
             if (info === null) {
-                return result_Result.error(DeferredTransfersErrorCode.ServiceInfoNotExist);
+                return result_Result.error(DeferredTransfersErrorCode.ServiceInfoNotExist, () => `Deferred transfers: service info not found for ${serviceId}`);
             }
             const codeHash = info.codeHash;
             const code = partiallyUpdatedState.getPreimage(serviceId, codeHash.asOpaque());
             const newBalance = sumU64(info.balance, ...transfers.map((item) => item.amount));
             if (newBalance.overflow) {
-                return result_Result.error(DeferredTransfersErrorCode.ServiceBalanceOverflow);
+                return result_Result.error(DeferredTransfersErrorCode.ServiceBalanceOverflow, () => `Deferred transfers: balance overflow for service ${serviceId}`);
             }
             const newInfo = ServiceAccountInfo.create({ ...info, balance: newBalance.value });
             partiallyUpdatedState.updateServiceInfo(serviceId, newInfo);
@@ -23957,7 +23989,7 @@ function verifyReportsBasic(input) {
         const noOfPrerequisites = reportView.context.view().prerequisites.view().length;
         const noOfSegmentRootLookups = reportView.segmentRootLookup.view().length;
         if (noOfPrerequisites + noOfSegmentRootLookups > MAX_REPORT_DEPENDENCIES) {
-            return result_Result.error(ReportsError.TooManyDependencies, `Report at ${reportView.coreIndex.materialize()} has too many dependencies. Got ${noOfPrerequisites} + ${noOfSegmentRootLookups}, max: ${MAX_REPORT_DEPENDENCIES}`);
+            return result_Result.error(ReportsError.TooManyDependencies, () => `Report at ${reportView.coreIndex.materialize()} has too many dependencies. Got ${noOfPrerequisites} + ${noOfSegmentRootLookups}, max: ${MAX_REPORT_DEPENDENCIES}`);
         }
         /**
          * In order to ensure fair use of a block’s extrinsic space,
@@ -23976,7 +24008,7 @@ function verifyReportsBasic(input) {
             totalOutputsSize += item.view().result.view().okBlob?.raw.length ?? 0;
         }
         if (authOutputSize + totalOutputsSize > MAX_WORK_REPORT_SIZE_BYTES) {
-            return result_Result.error(ReportsError.WorkReportTooBig, `Work report at ${reportView.coreIndex.materialize()} too big. Got ${authOutputSize} + ${totalOutputsSize}, max: ${MAX_WORK_REPORT_SIZE_BYTES}`);
+            return result_Result.error(ReportsError.WorkReportTooBig, () => `Work report at ${reportView.coreIndex.materialize()} too big. Got ${authOutputSize} + ${totalOutputsSize}, max: ${MAX_WORK_REPORT_SIZE_BYTES}`);
         }
     }
     return result_Result.ok(result_OK);
@@ -24010,12 +24042,12 @@ function verifyContextualValidity(input, state, headerChain, maxLookupAnchorAge)
         for (const result of guarantee.report.results) {
             const service = state.getService(result.serviceId);
             if (service === null) {
-                return result_Result.error(ReportsError.BadServiceId, `No service with id: ${result.serviceId}`);
+                return result_Result.error(ReportsError.BadServiceId, () => `No service with id: ${result.serviceId}`);
             }
             // check service code hash
             // https://graypaper.fluffylabs.dev/#/5f542d7/154b02154b02
             if (!result.codeHash.isEqualTo(service.getInfo().codeHash)) {
-                return result_Result.error(ReportsError.BadCodeHash, `Service (${result.serviceId}) code hash mismatch. Got: ${result.codeHash}, expected: ${service.getInfo().codeHash}`);
+                return result_Result.error(ReportsError.BadCodeHash, () => `Service (${result.serviceId}) code hash mismatch. Got: ${result.codeHash}, expected: ${service.getInfo().codeHash}`);
             }
         }
     }
@@ -24026,7 +24058,7 @@ function verifyContextualValidity(input, state, headerChain, maxLookupAnchorAge)
      * https://graypaper.fluffylabs.dev/#/5f542d7/151f01152101
      */
     if (currentWorkPackages.size !== input.guarantees.length) {
-        return result_Result.error(ReportsError.DuplicatePackage, "Duplicate work package detected.");
+        return result_Result.error(ReportsError.DuplicatePackage, () => "Duplicate work package detected.");
     }
     const minLookupSlot = Math.max(0, input.slot - maxLookupAnchorAge);
     const contextResult = verifyRefineContexts(minLookupSlot, contexts, input.recentBlocksPartialUpdate, headerChain);
@@ -24071,7 +24103,7 @@ function verifyContextualValidity(input, state, headerChain, maxLookupAnchorAge)
                         : undefined;
             }
             if (root === undefined || !root.segmentTreeRoot.isEqualTo(lookup.segmentTreeRoot)) {
-                return result_Result.error(ReportsError.SegmentRootLookupInvalid, `Mismatching segment tree root for package ${lookup.workPackageHash}. Got: ${lookup.segmentTreeRoot}, expected: ${root?.segmentTreeRoot}`);
+                return result_Result.error(ReportsError.SegmentRootLookupInvalid, () => `Mismatching segment tree root for package ${lookup.workPackageHash}. Got: ${lookup.segmentTreeRoot}, expected: ${root?.segmentTreeRoot}`);
             }
         }
     }
@@ -24094,16 +24126,16 @@ function verifyRefineContexts(minLookupSlot, contexts, recentBlocksPartialUpdate
          */
         const recentBlock = recentBlocks.get(context.anchor);
         if (recentBlock === undefined) {
-            return result_Result.error(ReportsError.AnchorNotRecent, `Anchor block ${context.anchor} not found in recent blocks.`);
+            return result_Result.error(ReportsError.AnchorNotRecent, () => `Anchor block ${context.anchor} not found in recent blocks.`);
         }
         // check state root
         if (!recentBlock.postStateRoot.isEqualTo(context.stateRoot)) {
-            return result_Result.error(ReportsError.BadStateRoot, `Anchor state root mismatch. Got: ${context.stateRoot}, expected: ${recentBlock.postStateRoot}.`);
+            return result_Result.error(ReportsError.BadStateRoot, () => `Anchor state root mismatch. Got: ${context.stateRoot}, expected: ${recentBlock.postStateRoot}.`);
         }
         // check beefy root
         const beefyRoot = recentBlock.accumulationResult;
         if (!beefyRoot.isEqualTo(context.beefyRoot)) {
-            return result_Result.error(ReportsError.BadBeefyMmrRoot, `Invalid BEEFY super peak hash. Got: ${context.beefyRoot}, expected: ${beefyRoot}. Anchor: ${recentBlock.headerHash}`);
+            return result_Result.error(ReportsError.BadBeefyMmrRoot, () => `Invalid BEEFY super peak hash. Got: ${context.beefyRoot}, expected: ${beefyRoot}. Anchor: ${recentBlock.headerHash}`);
         }
         /**
          * We require that each lookup-anchor block be within the
@@ -24112,7 +24144,7 @@ function verifyRefineContexts(minLookupSlot, contexts, recentBlocksPartialUpdate
          * https://graypaper.fluffylabs.dev/#/5f542d7/154601154701
          */
         if (context.lookupAnchorSlot < minLookupSlot) {
-            return result_Result.error(ReportsError.SegmentRootLookupInvalid, `Lookup anchor slot's too old. Got: ${context.lookupAnchorSlot}, minimal: ${minLookupSlot}`);
+            return result_Result.error(ReportsError.SegmentRootLookupInvalid, () => `Lookup anchor slot's too old. Got: ${context.lookupAnchorSlot}, minimal: ${minLookupSlot}`);
         }
         /**
          * We also require that we have a record of it; this is one of
@@ -24129,7 +24161,7 @@ function verifyRefineContexts(minLookupSlot, contexts, recentBlocksPartialUpdate
                 verify_contextual_logger.warn `Lookup anchor check for ${context.lookupAnchor} would fail, but override is active.`;
             }
             else {
-                return result_Result.error(ReportsError.SegmentRootLookupInvalid, `Lookup anchor is not found in chain. Hash: ${context.lookupAnchor} (slot: ${context.lookupAnchorSlot})`);
+                return result_Result.error(ReportsError.SegmentRootLookupInvalid, () => `Lookup anchor is not found in chain. Hash: ${context.lookupAnchor} (slot: ${context.lookupAnchorSlot})`);
             }
         }
     }
@@ -24152,7 +24184,7 @@ function verifyDependencies({ currentWorkPackages, recentlyReported, prerequisit
             if (recentlyReported.has(preReqHash)) {
                 continue;
             }
-            return result_Result.error(isSegmentRoot ? ReportsError.SegmentRootLookupInvalid : ReportsError.DependencyMissing, `Missing work package ${preReqHash} in current extrinsic or recent history.`);
+            return result_Result.error(isSegmentRoot ? ReportsError.SegmentRootLookupInvalid : ReportsError.DependencyMissing, () => `Missing work package ${preReqHash} in current extrinsic or recent history.`);
         }
         return result_Result.ok(result_OK);
     };
@@ -24200,7 +24232,7 @@ function verifyWorkPackagesUniqueness(workPackageHashes, state) {
     // let's check if any of our packages is in the pipeline
     const intersection = packagesInPipeline.intersection(workPackageHashes);
     for (const packageHash of intersection) {
-        return result_Result.error(ReportsError.DuplicatePackage, `The same work package hash found in the pipeline (workPackageHash: ${packageHash})`);
+        return result_Result.error(ReportsError.DuplicatePackage, () => `The same work package hash found in the pipeline (workPackageHash: ${packageHash})`);
     }
     return result_Result.ok(result_OK);
 }
@@ -24239,7 +24271,7 @@ workReportHashes, slot, getGuarantorAssignment) {
         const credentialsView = guaranteeView.credentials.view();
         if (credentialsView.length < REQUIRED_CREDENTIALS_RANGE[0] ||
             credentialsView.length > REQUIRED_CREDENTIALS_RANGE[1]) {
-            return result_Result.error(ReportsError.InsufficientGuarantees, `Invalid number of credentials. Expected ${REQUIRED_CREDENTIALS_RANGE}, got ${credentialsView.length}`);
+            return result_Result.error(ReportsError.InsufficientGuarantees, () => `Invalid number of credentials. Expected ${REQUIRED_CREDENTIALS_RANGE}, got ${credentialsView.length}`);
         }
         /** Retrieve current core assignment. */
         const timeSlot = guaranteeView.slot.materialize();
@@ -24254,20 +24286,20 @@ workReportHashes, slot, getGuarantorAssignment) {
             const credentialView = credential.view();
             const validatorIndex = credentialView.validatorIndex.materialize();
             if (lastValidatorIndex >= validatorIndex) {
-                return result_Result.error(ReportsError.NotSortedOrUniqueGuarantors, `Credentials must be sorted by validator index. Got ${validatorIndex}, expected at least ${lastValidatorIndex + 1}`);
+                return result_Result.error(ReportsError.NotSortedOrUniqueGuarantors, () => `Credentials must be sorted by validator index. Got ${validatorIndex}, expected at least ${lastValidatorIndex + 1}`);
             }
             lastValidatorIndex = validatorIndex;
             const signature = credentialView.signature.materialize();
             const guarantorData = guarantorAssignments[validatorIndex];
             if (guarantorData === undefined) {
-                return result_Result.error(ReportsError.BadValidatorIndex, `Invalid validator index: ${validatorIndex}`);
+                return result_Result.error(ReportsError.BadValidatorIndex, () => `Invalid validator index: ${validatorIndex}`);
             }
             /**
              * Verify core assignment.
              * https://graypaper.fluffylabs.dev/#/5f542d7/14e40214e602
              */
             if (guarantorData.core !== coreIndex) {
-                return result_Result.error(ReportsError.WrongAssignment, `Invalid core assignment for validator ${validatorIndex}. Expected: ${guarantorData.core}, got: ${coreIndex}`);
+                return result_Result.error(ReportsError.WrongAssignment, () => `Invalid core assignment for validator ${validatorIndex}. Expected: ${guarantorData.core}, got: ${coreIndex}`);
             }
             signaturesToVerify.push({
                 signature,
@@ -24305,10 +24337,10 @@ function verifyReportsOrder(input, chainSpec) {
         const reportView = guarantee.view().report.view();
         const coreIndex = reportView.coreIndex.materialize();
         if (lastCoreIndex >= coreIndex) {
-            return result_Result.error(ReportsError.OutOfOrderGuarantee, `Core indices of work reports are not unique or in order. Got: ${coreIndex}, expected at least: ${lastCoreIndex + 1}`);
+            return result_Result.error(ReportsError.OutOfOrderGuarantee, () => `Core indices of work reports are not unique or in order. Got: ${coreIndex}, expected at least: ${lastCoreIndex + 1}`);
         }
         if (coreIndex >= noOfCores) {
-            return result_Result.error(ReportsError.BadCoreIndex, `Invalid core index. Got: ${coreIndex}, max: ${noOfCores}`);
+            return result_Result.error(ReportsError.BadCoreIndex, () => `Invalid core index. Got: ${coreIndex}, max: ${noOfCores}`);
         }
         lastCoreIndex = coreIndex;
     }
@@ -24333,7 +24365,7 @@ function verifyPostSignatureChecks(input, availabilityAssignment, authPools, ser
          * https://graypaper.fluffylabs.dev/#/5f542d7/15ea0015ea00
          */
         if (availabilityAssignment[coreIndex] !== null) {
-            return result_Result.error(ReportsError.CoreEngaged, `Report pending availability at core: ${coreIndex}`);
+            return result_Result.error(ReportsError.CoreEngaged, () => `Report pending availability at core: ${coreIndex}`);
         }
         /**
          * A report is valid only if the authorizer hash is present
@@ -24346,7 +24378,7 @@ function verifyPostSignatureChecks(input, availabilityAssignment, authPools, ser
         const authorizerPool = authPools.get(coreIndex);
         const pool = authorizerPool?.materialize() ?? [];
         if (pool.find((hash) => hash.isEqualTo(authorizerHash)) === undefined) {
-            return result_Result.error(ReportsError.CoreUnauthorized, `Authorizer hash not found in the pool of core ${coreIndex}: ${authorizerHash}`);
+            return result_Result.error(ReportsError.CoreUnauthorized, () => `Authorizer hash not found in the pool of core ${coreIndex}: ${authorizerHash}`);
         }
         /**
          * We require that the gas allotted for accumulation of each
@@ -24358,17 +24390,17 @@ function verifyPostSignatureChecks(input, availabilityAssignment, authPools, ser
         for (const result of report.results) {
             const service = services(result.serviceId);
             if (service === null) {
-                return result_Result.error(ReportsError.BadServiceId, `No service with id: ${result.serviceId}`);
+                return result_Result.error(ReportsError.BadServiceId, () => `No service with id: ${result.serviceId}`);
             }
             const info = service.getInfo();
             // check minimal accumulation gas
             if (result.gas < info.accumulateMinGas) {
-                return result_Result.error(ReportsError.ServiceItemGasTooLow, `Service (${result.serviceId}) gas is less than minimal. Got: ${result.gas}, expected at least: ${info.accumulateMinGas}`);
+                return result_Result.error(ReportsError.ServiceItemGasTooLow, () => `Service (${result.serviceId}) gas is less than minimal. Got: ${result.gas}, expected at least: ${info.accumulateMinGas}`);
             }
         }
         const totalGas = sumU64(...report.results.map((x) => x.gas));
         if (totalGas.overflow || totalGas.value > G_A) {
-            return result_Result.error(ReportsError.WorkReportGasTooHigh, `Total gas too high. Got: ${totalGas.value} (ovfl: ${totalGas.overflow}), maximal: ${G_A}`);
+            return result_Result.error(ReportsError.WorkReportGasTooHigh, () => `Total gas too high. Got: ${totalGas.value} (ovfl: ${totalGas.overflow}), maximal: ${G_A}`);
         }
     }
     return result_Result.ok(result_OK);
@@ -24454,7 +24486,7 @@ class Reports {
         }
         const reporters = SortedSet.fromArray(bytesBlobComparator, signaturesToVerify.ok.map((x) => x.key)).slice();
         if (hasAnyOffenders(reporters, input.offenders)) {
-            return result_Result.error(ReportsError.BannedValidator);
+            return result_Result.error(ReportsError.BannedValidator, () => "One or more reporters are banned validators");
         }
         return result_Result.ok({
             stateUpdate: {
@@ -24494,7 +24526,7 @@ class Reports {
             return signaturesToVerify[idx].key;
         })
             .filter((x) => x !== null);
-        return result_Result.error(ReportsError.BadSignature, `Invalid signatures for validators with keys: ${invalidKeys.join(", ")}`);
+        return result_Result.error(ReportsError.BadSignature, () => `Invalid signatures for validators with keys: ${invalidKeys.join(", ")}`);
     }
     /**
      * Get the guarantor assignment (both core and validator data)
@@ -24510,10 +24542,10 @@ class Reports {
         const minTimeSlot = Math.max(0, headerRotation - 1) * rotationPeriod;
         // https://graypaper.fluffylabs.dev/#/5f542d7/155e00156900
         if (guaranteeTimeSlot > headerTimeSlot) {
-            return result_Result.error(ReportsError.FutureReportSlot, `Report slot is in future. Block ${headerTimeSlot}, Report: ${guaranteeTimeSlot}`);
+            return result_Result.error(ReportsError.FutureReportSlot, () => `Report slot is in future. Block ${headerTimeSlot}, Report: ${guaranteeTimeSlot}`);
         }
         if (guaranteeTimeSlot < minTimeSlot) {
-            return result_Result.error(ReportsError.ReportEpochBeforeLast, `Report slot is too old. Block ${headerTimeSlot}, Report: ${guaranteeTimeSlot}`);
+            return result_Result.error(ReportsError.ReportEpochBeforeLast, () => `Report slot is too old. Block ${headerTimeSlot}, Report: ${guaranteeTimeSlot}`);
         }
         // TODO [ToDr] [opti] below code needs cache.
         // The `G` and `G*` sets should only be computed once per rotation.
@@ -25081,6 +25113,16 @@ class OnChain {
         });
         const { statistics, ...statisticsRest } = statisticsUpdate;
         assertEmpty(statisticsRest);
+        // Concat accumulatePreimages updates with preimages
+        for (const [serviceId, accPreimageUpdates] of accumulatePreimages.entries()) {
+            const preimagesUpdates = preimages.get(serviceId);
+            if (preimagesUpdates === undefined) {
+                preimages.set(serviceId, accPreimageUpdates);
+            }
+            else {
+                preimages.set(serviceId, preimagesUpdates.concat(accPreimageUpdates));
+            }
+        }
         return result_Result.ok({
             ...(maybeAuthorizationQueues !== undefined ? { authQueues: maybeAuthorizationQueues } : {}),
             ...(maybeDesignatedValidatorData !== undefined ? { designatedValidatorData: maybeDesignatedValidatorData } : {}),
@@ -25102,7 +25144,7 @@ class OnChain {
             recentlyAccumulated,
             accumulationOutputLog,
             ...servicesUpdate,
-            preimages: preimages.concat(accumulatePreimages),
+            preimages,
         });
     }
     getUsedAuthorizerHashes(guarantees) {
@@ -25119,11 +25161,11 @@ class OnChain {
 }
 function checkOffendersMatch(offendersMark, headerOffendersMark) {
     if (offendersMark.size !== headerOffendersMark.length) {
-        return result_Result.error(OFFENDERS_ERROR, `Length mismatch: ${offendersMark.size} vs ${headerOffendersMark.length}`);
+        return result_Result.error(OFFENDERS_ERROR, () => `Length mismatch: ${offendersMark.size} vs ${headerOffendersMark.length}`);
     }
     for (const key of headerOffendersMark) {
         if (!offendersMark.has(key)) {
-            return result_Result.error(OFFENDERS_ERROR, `Missing key: ${key}`);
+            return result_Result.error(OFFENDERS_ERROR, () => `Missing key: ${key}`);
         }
     }
     return result_Result.ok(result_OK);
@@ -25205,7 +25247,7 @@ class Importer {
         if (!this.currentHash.isEqualTo(parentHash)) {
             const state = this.states.getState(parentHash);
             if (state === null) {
-                const e = result_Result.error(BlockVerifierError.StateRootNotFound);
+                const e = result_Result.error(BlockVerifierError.StateRootNotFound, () => `State not found for parent block ${parentHash}`);
                 if (!e.isError) {
                     throw new Error("unreachable, just adding to make compiler happy");
                 }
@@ -25401,7 +25443,7 @@ const importBlockResultCodec = descriptors_codec.custom({
     }
     if (kind === 1) {
         const error = d.bytesBlob();
-        return result_Result.error(error.asText());
+        return result_Result.error(error.asText(), () => error.asText());
     }
     throw new Error(`Invalid Result: ${kind}`);
 }, (s) => {
@@ -25445,14 +25487,14 @@ class MainReady extends State {
     sendBlock(port, block) {
         // TODO [ToDr] How to make a better API to pass this binary data around?
         // Currently we don't guarantee that the underlying buffer is actually `ArrayBuffer`.
-        port.sendSignal("block", block, [block.buffer]);
+        port.sendSignal("block", block, []);
     }
     async importBlock(port, block) {
-        const res = await port.sendRequest("importBlock", block, [block.buffer]);
+        const res = await port.sendRequest("importBlock", block, []);
         if (res instanceof Uint8Array) {
             return decoder_Decoder.decodeObject(importBlockResultCodec, res);
         }
-        return result_Result.error("Invalid worker response.");
+        return result_Result.error("Invalid worker response.", () => "Invalid worker response: expected Uint8Array");
     }
     async getStateEntries(port, hash) {
         const res = await port.sendRequest("getStateEntries", hash, [hash.buffer]);
@@ -25564,13 +25606,13 @@ class ImporterReady extends State {
                     response = result_Result.ok(this.importer.getBestStateRootHash() ?? ZERO_HASH.asOpaque());
                 }
                 else {
-                    response = result_Result.error(resultToString(res));
+                    response = result_Result.error(resultToString(res), () => resultToString(res));
                 }
             }
             catch (e) {
                 state_machine_logger.error `Failed to import block: ${e}`;
                 state_machine_logger.error `${e instanceof Error ? e.stack : ""}`;
-                response = result_Result.error(`${e}`);
+                response = result_Result.error(`${e}`, () => `${e}`);
             }
             const encoded = encoder_Encoder.encodeObject(importBlockResultCodec, response);
             return {