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

package/index.js

@@ -11465,6 +11465,7 @@ function accumulation_output_accumulationOutputComparator(a, b) {
 
 ;// CONCATENATED MODULE: ./packages/jam/block/gp-constants.ts
 
+
 /**
  * This file lists all of the constants defined in the GrayPaper appendix.
  *
@@ -11475,7 +11476,7 @@ function accumulation_output_accumulationOutputComparator(a, b) {
  * here are only temporarily for convenience. When we figure out better names
  * and places for these this file will be eradicated.
  *
- * https://graypaper.fluffylabs.dev/#/579bd12/413000413000
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/442300442300?v=0.7.2
  */
 /** `G_I`: The gas allocated to invoke a work-package’s Is-Authorized logic. */
 const gp_constants_G_I = 50_000_000;
@@ -11491,8 +11492,8 @@ const S = 1024;
 const gp_constants_T = 128;
 /** `W_A`: The maximum size of is-authorized code in octets. */
 const gp_constants_W_A = 64_000;
-/** `W_B`: The maximum size of an encoded work-package with extrinsic data and imports. */
-const gp_constants_W_B = 13_794_305;
+/** `W_B`: The maximum size of the concatenated variable-size blobs, extrinsics and imported segments of a work-package, in octets */
+const gp_constants_W_B = compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_2) ? 13_791_360 : 13_794_305;
 /** `W_C`: The maximum size of service code in octets. */
 const gp_constants_W_C = 4_000_000;
 /** `W_M`: The maximum number of imports in a work-package. */
@@ -12591,31 +12592,29 @@ var state_update_UpdatePreimageKind;
  * 3. Update `LookupHistory` with given value.
  */
 class state_update_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 state_update_UpdatePreimage(serviceId, {
+    static provide({ preimage, slot }) {
+        return new state_update_UpdatePreimage({
             kind: state_update_UpdatePreimageKind.Provide,
             preimage,
             slot,
         });
     }
     /** The preimage should be removed completely from the database. */
-    static remove({ serviceId, hash, length }) {
-        return new state_update_UpdatePreimage(serviceId, {
+    static remove({ hash, length }) {
+        return new state_update_UpdatePreimage({
             kind: state_update_UpdatePreimageKind.Remove,
             hash,
             length,
         });
     }
     /** Update the lookup history of some preimage or add a new one (request). */
-    static updateOrAdd({ serviceId, lookupHistory }) {
-        return new state_update_UpdatePreimage(serviceId, {
+    static updateOrAdd({ lookupHistory }) {
+        return new state_update_UpdatePreimage({
             kind: state_update_UpdatePreimageKind.UpdateOrAdd,
             item: lookupHistory,
         });
@@ -12652,23 +12651,21 @@ var state_update_UpdateServiceKind;
     UpdateServiceKind[UpdateServiceKind["Create"] = 1] = "Create";
 })(state_update_UpdateServiceKind || (state_update_UpdateServiceKind = {}));
 /**
- * Update service info of a particular `ServiceId` or create a new one.
+ * Update service info or create a new one.
  */
 class state_update_UpdateService {
-    serviceId;
     action;
-    constructor(serviceId, action) {
-        this.serviceId = serviceId;
+    constructor(action) {
         this.action = action;
     }
-    static update({ serviceId, serviceInfo }) {
-        return new state_update_UpdateService(serviceId, {
+    static update({ serviceInfo }) {
+        return new state_update_UpdateService({
             kind: state_update_UpdateServiceKind.Update,
             account: serviceInfo,
         });
     }
-    static create({ serviceId, serviceInfo, lookupHistory, }) {
-        return new state_update_UpdateService(serviceId, {
+    static create({ serviceInfo, lookupHistory, }) {
+        return new state_update_UpdateService({
             kind: state_update_UpdateServiceKind.Create,
             account: serviceInfo,
             lookupHistory,
@@ -12689,17 +12686,15 @@ var state_update_UpdateStorageKind;
  * Can either create/modify an entry or remove it.
  */
 class state_update_UpdateStorage {
-    serviceId;
     action;
-    constructor(serviceId, action) {
-        this.serviceId = serviceId;
+    constructor(action) {
         this.action = action;
     }
-    static set({ serviceId, storage }) {
-        return new state_update_UpdateStorage(serviceId, { kind: state_update_UpdateStorageKind.Set, storage });
+    static set({ storage }) {
+        return new state_update_UpdateStorage({ kind: state_update_UpdateStorageKind.Set, storage });
     }
-    static remove({ serviceId, key }) {
-        return new state_update_UpdateStorage(serviceId, { kind: state_update_UpdateStorageKind.Remove, key });
+    static remove({ key }) {
+        return new state_update_UpdateStorage({ kind: state_update_UpdateStorageKind.Remove, key });
     }
     get key() {
         if (this.action.kind === state_update_UpdateStorageKind.Remove) {
@@ -12908,12 +12903,12 @@ class 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;
         }
@@ -12925,7 +12920,7 @@ class InMemoryState extends WithDebug {
         if (result.isError) {
             return result;
         }
-        this.removeServices(servicesRemoved);
+        this.removeServices(removed);
         return result_Result.ok(result_OK);
     }
     removeServices(servicesRemoved) {
@@ -12934,87 +12929,100 @@ class 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 === state_update_UpdateStorageKind.Set) {
-                const { key, value } = action.storage;
-                service.data.storage.set(key.toString(), service_StorageItem.create({ key, value }));
-            }
-            else if (kind === state_update_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 === state_update_UpdateStorageKind.Set) {
+                    const { key, value } = update.action.storage;
+                    service.data.storage.set(key.toString(), service_StorageItem.create({ key, value }));
+                }
+                else if (kind === state_update_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 === state_update_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 service_LookupHistoryItem(preimage.hash, length, service_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]);
+            for (const update of updates) {
+                const { kind } = update.action;
+                if (kind === state_update_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}`);
+                    }
+                    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 service_LookupHistoryItem(preimage.hash, length, service_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 {
-                        // 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 === state_update_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 === state_update_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 === state_update_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 === state_update_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 === state_update_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!`);
                 }
@@ -14938,7 +14946,6 @@ function hasher_getKeccakTrieHasher(hasher) {
 
 
 
-
 /** What should be done with that key? */
 var StateEntryUpdateAction;
 (function (StateEntryUpdateAction) {
@@ -14954,76 +14961,88 @@ function* serialize_state_update_serializeStateUpdate(spec, blake2b, update) {
     yield* serializeBasicKeys(spec, update);
     const encode = (codec, val) => 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.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.serviceStorage(blake2b, serviceId, key);
-                yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
-                break;
-            }
-            case UpdateStorageKind.Remove: {
-                const key = action.key;
-                const codec = serialize.serviceStorage(blake2b, serviceId, key);
-                yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
-                break;
+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.serviceStorage(blake2b, serviceId, key);
+                    yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
+                    break;
+                }
+                case UpdateStorageKind.Remove: {
+                    const key = action.key;
+                    const codec = serialize.serviceStorage(blake2b, serviceId, key);
+                    yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
+                    break;
+                }
             }
-            default:
-                assertNever(action);
         }
     }
 }
-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.servicePreimages(blake2b, serviceId, hash);
-                yield [StateEntryUpdateAction.Insert, codec.key, blob];
-                if (action.slot !== null) {
-                    const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, tryAsU32(blob.length));
-                    yield [
-                        StateEntryUpdateAction.Insert,
-                        codec2.key,
-                        encode(codec2.Codec, tryAsLookupHistorySlots([action.slot])),
-                    ];
+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.servicePreimages(blake2b, serviceId, hash);
+                    yield [StateEntryUpdateAction.Insert, codec.key, blob];
+                    if (action.slot !== null) {
+                        const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, tryAsU32(blob.length));
+                        yield [
+                            StateEntryUpdateAction.Insert,
+                            codec2.key,
+                            encode(codec2.Codec, tryAsLookupHistorySlots([action.slot])),
+                        ];
+                    }
+                    break;
+                }
+                case UpdatePreimageKind.UpdateOrAdd: {
+                    const { hash, length, slots } = action.item;
+                    const codec = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
+                    yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, slots)];
+                    break;
+                }
+                case UpdatePreimageKind.Remove: {
+                    const { hash, length } = action;
+                    const codec = serialize.servicePreimages(blake2b, serviceId, hash);
+                    yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
+                    const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
+                    yield [StateEntryUpdateAction.Remove, codec2.key, EMPTY_BLOB];
+                    break;
                 }
-                break;
-            }
-            case UpdatePreimageKind.UpdateOrAdd: {
-                const { hash, length, slots } = action.item;
-                const codec = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
-                yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, slots)];
-                break;
-            }
-            case UpdatePreimageKind.Remove: {
-                const { hash, length } = action;
-                const codec = serialize.servicePreimages(blake2b, serviceId, hash);
-                yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
-                const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
-                yield [StateEntryUpdateAction.Remove, codec2.key, EMPTY_BLOB];
-                break;
             }
-            default:
-                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.serviceData(serviceId);
         yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, action.account)];
@@ -15746,7 +15765,7 @@ class preimages_Preimages {
             }
         }
         const { preimages, slot } = input;
-        const pendingChanges = [];
+        const pendingChanges = new Map();
         // select preimages for integration
         for (const preimage of preimages) {
             const { requester, blob } = preimage;
@@ -15763,11 +15782,12 @@ class preimages_Preimages {
                 return Result.error(PreimagesErrorCode.PreimageUnneeded);
             }
             // 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.ok({
             preimages: pendingChanges,
@@ -16901,6 +16921,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.
  *
@@ -16930,10 +16958,11 @@ class state_update_AccumulationStateUpdate {
     /** Create new empty state update. */
     static empty() {
         return new state_update_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. */
@@ -16945,10 +16974,13 @@ class state_update_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 state_update_AccumulationStateUpdate(serviceUpdates, transfers, new Map(from.yieldedRoots));
@@ -16996,9 +17028,9 @@ class state_update_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) {
@@ -17007,7 +17039,8 @@ class state_update_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;
         }
@@ -17022,10 +17055,11 @@ class state_update_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;
         }
@@ -17038,7 +17072,8 @@ class state_update_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;
         }
@@ -17047,10 +17082,11 @@ class state_update_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);
@@ -17087,14 +17123,15 @@ class state_update_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.
@@ -17102,8 +17139,10 @@ class state_update_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) {
         check `${items >= 0} storageUtilisationCount has to be a positive number, got: ${items}`;
@@ -17127,22 +17166,25 @@ class state_update_PartiallyUpdatedState {
         return Result.ok(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() {
         if (this.stateUpdate.privilegedServices !== null) {
             return this.stateUpdate.privilegedServices;
@@ -21205,15 +21247,13 @@ class accumulate_externalities_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])),
             }));
         }
@@ -21238,8 +21278,7 @@ class accumulate_externalities_AccumulateExternalities {
             if (res.isError) {
                 return Result.error(ForgetPreimageError.StorageUtilisationError);
             }
-            this.updatedState.updatePreimage(UpdatePreimage.remove({
-                serviceId,
+            this.updatedState.updatePreimage(serviceId, UpdatePreimage.remove({
                 hash: status.hash,
                 length: status.length,
             }));
@@ -21254,8 +21293,7 @@ class accumulate_externalities_AccumulateExternalities {
                 if (res.isError) {
                     return Result.error(ForgetPreimageError.StorageUtilisationError);
                 }
-                this.updatedState.updatePreimage(UpdatePreimage.remove({
-                    serviceId,
+                this.updatedState.updatePreimage(serviceId, UpdatePreimage.remove({
                     hash: status.hash,
                     length: status.length,
                 }));
@@ -21265,8 +21303,7 @@ class accumulate_externalities_AccumulateExternalities {
         }
         // 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.ok(OK);
@@ -21275,8 +21312,7 @@ class accumulate_externalities_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.ok(OK);
@@ -21367,11 +21403,7 @@ class accumulate_externalities_AccumulateExternalities {
                 }
                 // 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);
@@ -21382,12 +21414,8 @@ class accumulate_externalities_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);
@@ -21534,8 +21562,7 @@ class accumulate_externalities_AccumulateExternalities {
             return Result.error(ProvidePreimageError.AlreadyProvided);
         }
         // setting up the new preimage
-        this.updatedState.updatePreimage(UpdatePreimage.provide({
-            serviceId,
+        this.updatedState.updatePreimage(serviceId, UpdatePreimage.provide({
             preimage: PreimageItem.create({
                 hash: preimageHash,
                 blob: preimage,
@@ -21579,11 +21606,13 @@ class accumulate_externalities_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 = 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.ok(OK);
     }
     read(serviceId, rawKey) {
@@ -22468,9 +22497,6 @@ class host_call_memory_HostCallMemory {
         }
         return this.memory.loadInto(result, tryAsMemoryIndex(Number(startAddress)));
     }
-    getMemory() {
-        return this.memory;
-    }
 }
 
 ;// CONCATENATED MODULE: ./packages/core/pvm-host-calls/host-call-registers.ts
@@ -24542,19 +24568,16 @@ class accumulate_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();
@@ -24576,7 +24599,8 @@ class accumulate_Accumulate {
         const accumulated = accumulatableReports.subview(0, accumulatedReports);
         const { services, yieldedRoots, transfers, validatorsData, privilegedServices, authorizationQueues, ...stateUpdateRest } = state;
         assertEmpty(stateUpdateRest);
-        if (this.hasDuplicatedServicesCreated(services.servicesUpdates)) {
+        if (this.hasDuplicatedServiceIdCreated(services.created)) {
+            accumulate_logger.trace `Duplicated Service creation detected. Block is invalid.`;
             return Result.error(ACCUMULATION_ERROR);
         }
         const accStateUpdate = this.getAccumulationStateUpdate(accumulated.toArray(), toAccumulateLater, slot, Array.from(statistics.keys()), services);
@@ -26266,6 +26290,16 @@ class chain_stf_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.ok({
             ...(maybeAuthorizationQueues !== undefined ? { authQueues: maybeAuthorizationQueues } : {}),
             ...(maybeDesignatedValidatorData !== undefined ? { designatedValidatorData: maybeDesignatedValidatorData } : {}),
@@ -26287,7 +26321,7 @@ class chain_stf_OnChain {
             recentlyAccumulated,
             accumulationOutputLog,
             ...servicesUpdate,
-            preimages: preimages.concat(accumulatePreimages),
+            preimages,
         });
     }
     getUsedAuthorizerHashes(guarantees) {