@typeberry/lib 0.2.0-e767e74 → 0.2.0-ef1ea0e

package/index.cjs

@@ -304,7 +304,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$1 = {
@@ -318,7 +318,7 @@ const Result$1 = {
         };
     },
     /** Create new [`Result`] with `Error` status. */
-    error: (error, details = "") => {
+    error: (error, details) => {
         check `${error !== undefined} 'Error' type cannot be undefined.`;
         return {
             isOk: false,
@@ -431,7 +431,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
@@ -1122,8 +1122,8 @@ class Decoder {
     /**
      * Create a new [`Decoder`] instance given a raw array of bytes as a source.
      */
-    static fromBlob(source) {
-        return new Decoder(source);
+    static fromBlob(source, context) {
+        return new Decoder(source, undefined, context);
     }
     /**
      * Decode a single object from all of the source bytes.
@@ -1418,7 +1418,7 @@ class Decoder {
     ensureHasBytes(bytes) {
         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}.`);
         }
     }
 }
@@ -1432,6 +1432,8 @@ function decodeVariableLengthExtraBytes(firstByte) {
     }
     return 0;
 }
+class EndOfDataError extends Error {
+}
 
 /** Wrapper for `Decoder` that can skip bytes of fields in the data buffer instead of decoding them. */
 class Skipper {
@@ -2249,6 +2251,8 @@ var codec$1;
             return ret;
         };
     })();
+    /** Zero-size `void` value. */
+    codec.nothing = Descriptor.new("void", { bytes: 0, isExact: true }, (_e, _v) => { }, (_d) => { }, (_s) => { });
     /** Variable-length U32. */
     codec.varU32 = Descriptor.new("var_u32", { bytes: 4, isExact: false }, (e, v) => e.varU32(v), (d) => d.varU32(), (d) => d.varU32());
     /** Variable-length U64. */
@@ -2448,6 +2452,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}`);
             }
         }
@@ -2525,6 +2532,7 @@ var index$q = /*#__PURE__*/Object.freeze({
   Decoder: Decoder,
   Descriptor: Descriptor,
   Encoder: Encoder,
+  EndOfDataError: EndOfDataError,
   ObjectView: ObjectView,
   SequenceView: SequenceView,
   TYPICAL_DICTIONARY_LENGTH: TYPICAL_DICTIONARY_LENGTH,
@@ -4785,7 +4793,7 @@ class SortedArray {
             isEqual: false,
         };
     }
-    /** Create a new SortedSet from two sorted collections. */
+    /** Create a new SortedArray from two sorted collections. */
     static fromTwoSortedCollections(first, second) {
         check `${first.comparator === second.comparator} Cannot merge arrays if they do not use the same comparator`;
         const comparator = first.comparator;
@@ -5142,31 +5150,6 @@ const fullChainSpec = new ChainSpec({
     maxLookupAnchorAge: tryAsU32(14_400),
 });
 
-/**
- * Configuration object for typeberry workers.
- */
-class WorkerConfig {
-    chainSpec;
-    dbPath;
-    omitSealVerification;
-    /**
-     * Since we loose prototypes when transferring the context,
-     * this function is re-initializing proper types.
-     *
-     * TODO [ToDr] instead of doing this hack, we might prefer to pass data
-     * between workers using JAM codec maybe?
-     */
-    static reInit(config) {
-        const { chainSpec, dbPath, omitSealVerification } = config;
-        return new WorkerConfig(new ChainSpec(chainSpec), dbPath, omitSealVerification);
-    }
-    constructor(chainSpec, dbPath, omitSealVerification = false) {
-        this.chainSpec = chainSpec;
-        this.dbPath = dbPath;
-        this.omitSealVerification = omitSealVerification;
-    }
-}
-
 /** Bootnode class represents a single contact point in the network */
 class Bootnode {
     id;
@@ -5200,7 +5183,6 @@ var index$m = /*#__PURE__*/Object.freeze({
   EST_EPOCH_LENGTH: EST_EPOCH_LENGTH,
   EST_VALIDATORS: EST_VALIDATORS,
   EST_VALIDATORS_SUPER_MAJORITY: EST_VALIDATORS_SUPER_MAJORITY,
-  WorkerConfig: WorkerConfig,
   fullChainSpec: fullChainSpec,
   tinyChainSpec: tinyChainSpec
 });
@@ -7311,9 +7293,7 @@ var chain_spec$1 = {
 	id: "typeberry-default",
 	bootnodes: [
 		"e3r2oc62zwfj3crnuifuvsxvbtlzetk4o5qyhetkhagsc2fgl2oka@127.0.0.1:40000",
-		"eecgwpgwq3noky4ijm4jmvjtmuzv44qvigciusxakq5epnrfj2utb@127.0.0.1:12345",
-		"en5ejs5b2tybkfh4ym5vpfh7nynby73xhtfzmazumtvcijpcsz6ma@127.0.0.1:12346",
-		"ekwmt37xecoq6a7otkm4ux5gfmm4uwbat4bg5m223shckhaaxdpqa@127.0.0.1:12347"
+		"eyonydqt7gj7bjdek62lwdeuxdzr5q7nmxa2p5zwwtoijgamdnkka@127.0.0.1:12345"
 	],
 	genesis_header: "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001ee155ace9c40292074cb6aff8c9ccdd273c81648ff1149ef36bcea6ebb8a3e25bb30a42c1e62f0afda5f0a4e8a562f7a13a24cea00ee81917b86b89e801314aaff71c6c03ff88adb5ed52c9681de1629a54e702fc14729f6b50d2f0a76f185b34418fb8c85bb3985394a8c2756d3643457ce614546202a2f50b093d762499acedee6d555b82024f1ccf8a1e37e60fa60fd40b1958c4bb3006af78647950e1b91ad93247bd01307550ec7acd757ce6fb805fcf73db364063265b30a949e90d9339326edb21e5541717fde24ec085000b28709847b8aab1ac51f84e94b37ca1b66cab2b9ff25c2410fbe9b8a717abb298c716a03983c98ceb4def2087500b8e3410746846d17469fb2f95ef365efcab9f4e22fa1feb53111c995376be8019981ccf30aa5444688b3cab47697b37d5cac5707bb3289e986b19b17db437206931a8d151e5c8fe2b9d8a606966a79edd2f9e5db47e83947ce368ccba53bf6ba20a40b8b8c5d436f92ecf605421e873a99ec528761eb52a88a2f9a057b3b3003e6f32a2105650944fcd101621fd5bb3124c9fd191d114b7ad936c1d79d734f9f21392eab0084d01534b31c1dd87c81645fd762482a90027754041ca1b56133d0466c0600ffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
 	genesis_state: {
@@ -7359,9 +7339,7 @@ var authorship = {
 var chain_spec = {
 	id: "typeberry-dev",
 	bootnodes: [
-		"eecgwpgwq3noky4ijm4jmvjtmuzv44qvigciusxakq5epnrfj2utb@127.0.0.1:12345",
-		"en5ejs5b2tybkfh4ym5vpfh7nynby73xhtfzmazumtvcijpcsz6ma@127.0.0.1:12346",
-		"ekwmt37xecoq6a7otkm4ux5gfmm4uwbat4bg5m223shckhaaxdpqa@127.0.0.1:12347"
+		"eyonydqt7gj7bjdek62lwdeuxdzr5q7nmxa2p5zwwtoijgamdnkka@127.0.0.1:12345"
 	],
 	genesis_header: "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001ee155ace9c40292074cb6aff8c9ccdd273c81648ff1149ef36bcea6ebb8a3e25bb30a42c1e62f0afda5f0a4e8a562f7a13a24cea00ee81917b86b89e801314aaff71c6c03ff88adb5ed52c9681de1629a54e702fc14729f6b50d2f0a76f185b34418fb8c85bb3985394a8c2756d3643457ce614546202a2f50b093d762499acedee6d555b82024f1ccf8a1e37e60fa60fd40b1958c4bb3006af78647950e1b91ad93247bd01307550ec7acd757ce6fb805fcf73db364063265b30a949e90d9339326edb21e5541717fde24ec085000b28709847b8aab1ac51f84e94b37ca1b66cab2b9ff25c2410fbe9b8a717abb298c716a03983c98ceb4def2087500b8e3410746846d17469fb2f95ef365efcab9f4e22fa1feb53111c995376be8019981ccf30aa5444688b3cab47697b37d5cac5707bb3289e986b19b17db437206931a8d151e5c8fe2b9d8a606966a79edd2f9e5db47e83947ce368ccba53bf6ba20a40b8b8c5d436f92ecf605421e873a99ec528761eb52a88a2f9a057b3b3003e6f32a2105650944fcd101621fd5bb3124c9fd191d114b7ad936c1d79d734f9f21392eab0084d01534b31c1dd87c81645fd762482a90027754041ca1b56133d0466c0600ffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
 	genesis_state: {
@@ -7784,16 +7762,18 @@ class NodeConfiguration {
         version: "number",
         flavor: knownChainSpecFromJson,
         chain_spec: JipChainSpec.fromJson,
-        database_base_path: "string",
+        database_base_path: json.optional("string"),
         authorship: AuthorshipOptions.fromJson,
     }, NodeConfiguration.new);
     static new({ $schema, version, flavor, chain_spec, database_base_path, authorship }) {
         if (version !== 1) {
             throw new Error("Only version=1 config is supported.");
         }
-        return new NodeConfiguration($schema, version, flavor, chain_spec, database_base_path, authorship);
+        return new NodeConfiguration($schema, version, flavor, chain_spec, database_base_path ?? undefined, authorship);
     }
-    constructor($schema, version, flavor, chainSpec, databaseBasePath, authorship) {
+    constructor($schema, version, flavor, chainSpec, 
+    /** If database path is not provided, we load an in-memory db. */
+    databaseBasePath, authorship) {
         this.$schema = $schema;
         this.version = version;
         this.flavor = flavor;
@@ -7879,6 +7859,7 @@ class InMemoryBlocks {
     getExtrinsic(hash) {
         return this.extrinsicsByHeaderHash.get(hash) ?? null;
     }
+    async close() { }
 }
 
 /**
@@ -8072,6 +8053,8 @@ function accumulationOutputComparator(a, b) {
 const O = 8;
 /** `Q`: The number of items in the authorizations queue. */
 const Q = 80;
+/** `W_B`: The maximum size of the concatenated variable-size blobs, extrinsics and imported segments of a work-package, in octets */
+Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? 13_791_360 : 13_794_305;
 /** `W_T`: The size of a transfer memo in octets. */
 const W_T = 128;
 /**
@@ -9062,31 +9045,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,
         });
@@ -9123,23 +9104,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,
@@ -9160,17 +9139,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) {
@@ -9355,12 +9332,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;
         }
@@ -9372,7 +9349,7 @@ class InMemoryState extends WithDebug {
         if (result.isError) {
             return result;
         }
-        this.removeServices(servicesRemoved);
+        this.removeServices(removed);
         return Result$1.ok(OK);
     }
     removeServices(servicesRemoved) {
@@ -9381,89 +9358,102 @@ 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$1.error(UpdateError.NoService, `Attempting to update storage of non-existing service: ${serviceId}`);
-            }
-            if (kind === UpdateStorageKind.Set) {
-                const { key, value } = action.storage;
-                service.data.storage.set(key.toString(), StorageItem.create({ key, value }));
-            }
-            else if (kind === UpdateStorageKind.Remove) {
-                const { key } = action;
-                check `
+    updateStorage(storageUpdates) {
+        if (storageUpdates === undefined) {
+            return Result$1.ok(OK);
+        }
+        for (const [serviceId, updates] of storageUpdates.entries()) {
+            for (const update of updates) {
+                const { kind } = update.action;
+                const service = this.services.get(serviceId);
+                if (service === undefined) {
+                    return Result$1.error(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;
+                    check `
           ${service.data.storage.has(key.toString())}
-          Attempting to remove non-existing storage item at ${serviceId}: ${action.key}
+          Attempting to remove non-existing storage item at ${serviceId}: ${update.action.key}
         `;
-                service.data.storage.delete(key.toString());
-            }
-            else {
-                assertNever(kind);
+                    service.data.storage.delete(key.toString());
+                }
+                else {
+                    assertNever(kind);
+                }
             }
         }
         return Result$1.ok(OK);
     }
-    updatePreimages(preimages) {
-        for (const { serviceId, action } of preimages ?? []) {
+    updatePreimages(preimagesUpdates) {
+        if (preimagesUpdates === undefined) {
+            return Result$1.ok(OK);
+        }
+        for (const [serviceId, updates] of preimagesUpdates.entries()) {
             const service = this.services.get(serviceId);
             if (service === undefined) {
-                return Result$1.error(UpdateError.NoService, `Attempting to update preimage of non-existing service: ${serviceId}`);
+                return Result$1.error(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$1.error(UpdateError.PreimageExists, `Overwriting existing preimage at ${serviceId}: ${preimage}`);
-                }
-                service.data.preimages.set(preimage.hash, preimage);
-                if (slot !== null) {
-                    const lookupHistory = service.data.lookupHistory.get(preimage.hash);
-                    const length = tryAsU32(preimage.blob.length);
-                    const lookup = new LookupHistoryItem(preimage.hash, length, tryAsLookupHistorySlots([slot]));
-                    if (lookupHistory === undefined) {
-                        // no lookup history for that preimage at all (edge case, should be requested)
-                        service.data.lookupHistory.set(preimage.hash, [lookup]);
+            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$1.error(UpdateError.PreimageExists, () => `Overwriting existing preimage at ${serviceId}: ${preimage}`);
+                    }
+                    service.data.preimages.set(preimage.hash, preimage);
+                    if (slot !== null) {
+                        const lookupHistory = service.data.lookupHistory.get(preimage.hash);
+                        const length = tryAsU32(preimage.blob.length);
+                        const lookup = new LookupHistoryItem(preimage.hash, length, tryAsLookupHistorySlots([slot]));
+                        if (lookupHistory === undefined) {
+                            // no lookup history for that preimage at all (edge case, should be requested)
+                            service.data.lookupHistory.set(preimage.hash, [lookup]);
+                        }
+                        else {
+                            // insert or replace exiting entry
+                            const index = lookupHistory.map((x) => x.length).indexOf(length);
+                            lookupHistory.splice(index, index === -1 ? 0 : 1, lookup);
+                        }
                     }
-                    else {
-                        // insert or replace exiting entry
-                        const index = lookupHistory.map((x) => x.length).indexOf(length);
-                        lookupHistory.splice(index, index === -1 ? 0 : 1, lookup);
+                }
+                else if (kind === UpdatePreimageKind.Remove) {
+                    const { hash, length } = update.action;
+                    service.data.preimages.delete(hash);
+                    const history = service.data.lookupHistory.get(hash) ?? [];
+                    const idx = history.map((x) => x.length).indexOf(length);
+                    if (idx !== -1) {
+                        history.splice(idx, 1);
                     }
                 }
-            }
-            else if (kind === UpdatePreimageKind.Remove) {
-                const { hash, length } = action;
-                service.data.preimages.delete(hash);
-                const history = service.data.lookupHistory.get(hash) ?? [];
-                const idx = history.map((x) => x.length).indexOf(length);
-                if (idx !== -1) {
-                    history.splice(idx, 1);
+                else if (kind === UpdatePreimageKind.UpdateOrAdd) {
+                    const { item } = update.action;
+                    const history = service.data.lookupHistory.get(item.hash) ?? [];
+                    const existingIdx = history.map((x) => x.length).indexOf(item.length);
+                    const removeCount = existingIdx === -1 ? 0 : 1;
+                    history.splice(existingIdx, removeCount, item);
+                    service.data.lookupHistory.set(item.hash, history);
+                }
+                else {
+                    assertNever(kind);
                 }
-            }
-            else if (kind === UpdatePreimageKind.UpdateOrAdd) {
-                const { item } = action;
-                const history = service.data.lookupHistory.get(item.hash) ?? [];
-                const existingIdx = history.map((x) => x.length).indexOf(item.length);
-                const removeCount = existingIdx === -1 ? 0 : 1;
-                history.splice(existingIdx, removeCount, item);
-                service.data.lookupHistory.set(item.hash, history);
-            }
-            else {
-                assertNever(kind);
             }
         }
         return Result$1.ok(OK);
     }
     updateServices(servicesUpdates) {
-        for (const { serviceId, action } of servicesUpdates ?? []) {
-            const { kind, account } = action;
+        if (servicesUpdates === undefined) {
+            return Result$1.ok(OK);
+        }
+        for (const [serviceId, update] of servicesUpdates.entries()) {
+            const { kind, account } = update.action;
             if (kind === UpdateServiceKind.Create) {
-                const { lookupHistory } = action;
+                const { lookupHistory } = update.action;
                 if (this.services.has(serviceId)) {
-                    return Result$1.error(UpdateError.DuplicateService, `${serviceId} already exists!`);
+                    return Result$1.error(UpdateError.DuplicateService, () => `${serviceId} already exists!`);
                 }
                 this.services.set(serviceId, new InMemoryService(serviceId, {
                     info: account,
@@ -9475,7 +9465,7 @@ class InMemoryState extends WithDebug {
             else if (kind === UpdateServiceKind.Update) {
                 const existingService = this.services.get(serviceId);
                 if (existingService === undefined) {
-                    return Result$1.error(UpdateError.NoService, `Cannot update ${serviceId} because it does not exist.`);
+                    return Result$1.error(UpdateError.NoService, () => `Cannot update ${serviceId} because it does not exist.`);
                 }
                 existingService.data.info = account;
             }
@@ -10729,76 +10719,88 @@ function* 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)];
@@ -11067,31 +11069,35 @@ var LeafDbError;
  * Note that reading the actual values may require accessing the original database.
  */
 class LeafDb {
-    leaves;
+    leafs;
     db;
     /**
      * Parse given blob containing concatenated leaf nodes into leaf db.
      */
     static fromLeavesBlob(blob, db) {
         if (blob.length % TRIE_NODE_BYTES !== 0) {
-            return Result$1.error(LeafDbError.InvalidLeafData, `${blob.length} is not a multiply of ${TRIE_NODE_BYTES}: ${blob}`);
+            return Result$1.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$1.error(LeafDbError.InvalidLeafData, `Branch node detected: ${nodeData}`);
+                return Result$1.error(LeafDbError.InvalidLeafData, () => `Branch node detected: ${nodeData}`);
             }
             leaves.insert(node.asLeafNode());
         }
         return Result$1.ok(new LeafDb(leaves, db));
     }
+    /** Create leaf db from sorted set of leaves. */
+    static fromLeaves(leaves, db) {
+        return new LeafDb(leaves, db);
+    }
     /** A mapping between an embedded value or db lookup key. */
     lookup;
-    constructor(leaves, db) {
-        this.leaves = leaves;
+    constructor(leafs, db) {
+        this.leafs = leafs;
         this.db = db;
-        this.lookup = TruncatedHashDictionary.fromEntries(leaves.array.map((leaf) => {
+        this.lookup = TruncatedHashDictionary.fromEntries(leafs.array.map((leaf) => {
             const key = leaf.getKey().asOpaque();
             const value = leaf.hasEmbeddedValue()
                 ? {
@@ -11100,7 +11106,7 @@ class LeafDb {
                 }
                 : {
                     kind: LookupKind.DbKey,
-                    key: leaf.getValueHash().raw,
+                    key: leaf.getValueHash(),
                 };
             return [key, value];
         }));
@@ -11120,7 +11126,7 @@ class LeafDb {
     }
     getStateRoot(blake2b) {
         const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
-        return InMemoryTrie.computeStateRoot(blake2bTrieHasher, this.leaves).asOpaque();
+        return InMemoryTrie.computeStateRoot(blake2bTrieHasher, this.leafs).asOpaque();
     }
     intoStateEntries() {
         const entries = [];
@@ -11145,144 +11151,89 @@ var LookupKind;
     LookupKind[LookupKind["DbKey"] = 1] = "DbKey";
 })(LookupKind || (LookupKind = {}));
 
-/** Codec for a map with string keys. */
-const codecMap = (value, extractKey, { typicalLength = TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => {
-    const keyA = extractKey(a);
-    const keyB = extractKey(b);
-    if (keyA < keyB) {
-        return Ordering.Less;
+function updateLeafs(leafs, blake2b, data) {
+    const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
+    // We will collect all values that don't fit directly into leaf nodes.
+    const values = [];
+    for (const [action, key, value] of data) {
+        if (action === StateEntryUpdateAction.Insert) {
+            const leafNode = InMemoryTrie.constructLeaf(blake2bTrieHasher, key.asOpaque(), value);
+            leafs.replace(leafNode);
+            if (!leafNode.hasEmbeddedValue()) {
+                values.push([leafNode.getValueHash(), value]);
+            }
+        }
+        else if (action === StateEntryUpdateAction.Remove) {
+            const leafNode = InMemoryTrie.constructLeaf(blake2bTrieHasher, key.asOpaque(), BytesBlob.empty());
+            leafs.removeOne(leafNode);
+            // TODO [ToDr] Handle ref-counting values or updating some header-hash-based references.
+        }
+        else {
+            assertNever(action);
+        }
     }
-    if (keyA > keyB) {
-        return Ordering.Greater;
+    return {
+        values,
+        leafs,
+    };
+}
+
+/** In-memory serialized-states db. */
+class InMemorySerializedStates {
+    spec;
+    blake2b;
+    db = HashDictionary.new();
+    valuesDb = HashDictionary.new();
+    constructor(spec, blake2b) {
+        this.spec = spec;
+        this.blake2b = blake2b;
     }
-    return Ordering.Equal;
-}, } = {}) => {
-    return Descriptor.new(`Map<${value.name}>[?]`, {
-        bytes: typicalLength * value.sizeHint.bytes,
-        isExact: false,
-    }, (e, v) => {
-        const data = Array.from(v.values());
-        data.sort((a, b) => compare(a, b).value);
-        e.varU32(tryAsU32(data.length));
-        for (const v of data) {
-            value.encode(e, v);
+    async insertInitialState(headerHash, entries) {
+        // convert state entries into leafdb
+        const { values, leafs } = updateLeafs(SortedSet.fromArray(leafComparator, []), this.blake2b, Array.from(entries, (x) => [StateEntryUpdateAction.Insert, x[0], x[1]]));
+        // insert values to the db.
+        for (const val of values) {
+            this.valuesDb.set(val[0], val[1]);
         }
-    }, (d) => {
-        const map = new Map();
-        const len = d.varU32();
-        let prevValue = null;
-        for (let i = 0; i < len; i += 1) {
-            const v = value.decode(d);
-            const k = extractKey(v);
-            if (map.has(k)) {
-                throw new Error(`Duplicate item in the dictionary encoding: "${k}"!`);
-            }
-            if (prevValue !== null && compare(prevValue, v).isGreaterOrEqual()) {
-                throw new Error(`The keys in dictionary encoding are not sorted "${extractKey(prevValue)}" >= "${extractKey(v)}"!`);
-            }
-            map.set(k, v);
-            prevValue = v;
+        this.db.set(headerHash, leafs);
+        return Result$1.ok(OK);
+    }
+    async getStateRoot(state) {
+        return state.backend.getStateRoot(this.blake2b);
+    }
+    async updateAndSetState(header, state, update) {
+        const blake2b = this.blake2b;
+        const updatedValues = serializeStateUpdate(this.spec, blake2b, update);
+        const { values, leafs } = updateLeafs(state.backend.leafs, blake2b, updatedValues);
+        // insert values to the db
+        // valuesdb can be shared between all states because it's just
+        // <valuehash> -> <value> mapping and existence is managed by trie leafs.
+        for (const val of values) {
+            this.valuesDb.set(val[0], val[1]);
+        }
+        // make sure to clone the leafs before writing, since the collection is re-used.
+        this.db.set(header, SortedSet.fromSortedArray(leafComparator, leafs.slice()));
+        return Result$1.ok(OK);
+    }
+    getState(header) {
+        const leafs = this.db.get(header);
+        if (leafs === undefined) {
+            return null;
         }
-        return map;
-    }, (s) => {
-        const len = s.decoder.varU32();
-        s.sequenceFixLen(value, len);
-    });
-};
-const lookupHistoryItemCodec = codec$1.object({
-    hash: codec$1.bytes(HASH_SIZE).asOpaque(),
-    length: codec$1.u32,
-    slots: readonlyArray(codec$1.sequenceVarLen(codec$1.u32.asOpaque())).convert(seeThrough, tryAsLookupHistorySlots),
-}, "LookupHistoryItem", ({ hash, length, slots }) => new LookupHistoryItem(hash, length, slots));
-const lookupHistoryEntryCodec = codec$1.object({
-    key: codec$1.bytes(HASH_SIZE).asOpaque(),
-    data: codec$1.sequenceVarLen(lookupHistoryItemCodec),
-});
-const lookupHistoryCodec = codec$1
-    .sequenceVarLen(lookupHistoryEntryCodec)
-    .convert((dict) => {
-    const entries = [];
-    for (const [key, data] of dict) {
-        entries.push({
-            key,
-            data,
+        // now create a leafdb with shared values db.
+        const leafDb = LeafDb.fromLeaves(leafs, {
+            get: (key) => {
+                const val = this.valuesDb.get(key);
+                if (val === undefined) {
+                    throw new Error(`Missing value at key: ${key}`);
+                }
+                return val.raw;
+            },
         });
+        return SerializedState.new(this.spec, this.blake2b, leafDb);
     }
-    return entries;
-}, (items) => {
-    const dict = HashDictionary.new();
-    for (const { key, data } of items) {
-        const items = dict.get(key) ?? [];
-        items.push(...data);
-        dict.set(key, items);
-    }
-    return dict;
-});
-class ServiceWithCodec extends InMemoryService {
-    static Codec = codec$1.Class(ServiceWithCodec, {
-        serviceId: codec$1.u32.asOpaque(),
-        data: codec$1.object({
-            info: ServiceAccountInfo.Codec,
-            preimages: codecHashDictionary(PreimageItem.Codec, (x) => x.hash),
-            lookupHistory: lookupHistoryCodec,
-            storage: codecMap(StorageItem.Codec, (x) => x.key.toString()),
-        }),
-    });
-    constructor(id, data) {
-        super(id, data);
-    }
-    static create({ serviceId, data }) {
-        return new ServiceWithCodec(serviceId, data);
-    }
-}
-const inMemoryStateCodec = (spec) => codec$1.Class(class State extends InMemoryState {
-    static create(data) {
-        return InMemoryState.new(spec, data);
-    }
-}, {
-    // alpha
-    authPools: serialize.authPools.Codec,
-    // phi
-    authQueues: serialize.authQueues.Codec,
-    // beta
-    recentBlocks: serialize.recentBlocks.Codec,
-    // gamma_k
-    nextValidatorData: codecPerValidator(ValidatorData.Codec),
-    // gamma_z
-    epochRoot: codec$1.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
-    // gamma_s
-    sealingKeySeries: SafroleSealingKeysData.Codec,
-    // gamma_a
-    ticketsAccumulator: readonlyArray(codec$1.sequenceVarLen(Ticket.Codec)).convert((x) => x, asKnownSize),
-    // psi
-    disputesRecords: serialize.disputesRecords.Codec,
-    // eta
-    entropy: serialize.entropy.Codec,
-    // iota
-    designatedValidatorData: serialize.designatedValidators.Codec,
-    // kappa
-    currentValidatorData: serialize.currentValidators.Codec,
-    // lambda
-    previousValidatorData: serialize.previousValidators.Codec,
-    // rho
-    availabilityAssignment: serialize.availabilityAssignment.Codec,
-    // tau
-    timeslot: serialize.timeslot.Codec,
-    // chi
-    privilegedServices: serialize.privilegedServices.Codec,
-    // pi
-    statistics: serialize.statistics.Codec,
-    // omega
-    accumulationQueue: serialize.accumulationQueue.Codec,
-    // xi
-    recentlyAccumulated: serialize.recentlyAccumulated.Codec,
-    // theta
-    accumulationOutputLog: serialize.accumulationOutputLog.Codec,
-    // delta
-    services: codec$1.dictionary(codec$1.u32.asOpaque(), ServiceWithCodec.Codec, {
-        sortKeys: (a, b) => a - b,
-    }),
-});
+    async close() { }
+}
 
 /** A potential error that occured during state update. */
 var StateUpdateError;
@@ -11295,13 +11246,15 @@ var StateUpdateError;
 class InMemoryStates {
     spec;
     db = HashDictionary.new();
+    blake2b;
     constructor(spec) {
         this.spec = spec;
+        this.blake2b = Blake2b.createHasher();
     }
     async updateAndSetState(headerHash, state, update) {
         const res = state.applyUpdate(update);
         if (res.isOk) {
-            return await this.insertState(headerHash, state);
+            return await this.insertInitialState(headerHash, state);
         }
         switch (res.error) {
             case UpdateError.DuplicateService:
@@ -11313,31 +11266,34 @@ class InMemoryStates {
         }
     }
     async getStateRoot(state) {
-        const blake2b = await Blake2b.createHasher();
+        const blake2b = await this.blake2b;
         return StateEntries.serializeInMemory(this.spec, blake2b, state).getRootHash(blake2b);
     }
     /** Insert a full state into the database. */
-    async insertState(headerHash, state) {
-        const encoded = Encoder.encodeObject(inMemoryStateCodec(this.spec), state, this.spec);
-        this.db.set(headerHash, encoded);
+    async insertInitialState(headerHash, state) {
+        const copy = InMemoryState.copyFrom(this.spec, state, state.intoServicesData());
+        this.db.set(headerHash, copy);
         return Result$1.ok(OK);
     }
     getState(headerHash) {
-        const encodedState = this.db.get(headerHash);
-        if (encodedState === undefined) {
+        const state = this.db.get(headerHash);
+        if (state === undefined) {
             return null;
         }
-        return Decoder.decodeObject(inMemoryStateCodec(this.spec), encodedState, this.spec);
+        return InMemoryState.copyFrom(this.spec, state, state.intoServicesData());
     }
+    async close() { }
 }
 
 var index$d = /*#__PURE__*/Object.freeze({
   __proto__: null,
   InMemoryBlocks: InMemoryBlocks,
+  InMemorySerializedStates: InMemorySerializedStates,
   InMemoryStates: InMemoryStates,
   LeafDb: LeafDb,
   get LeafDbError () { return LeafDbError; },
-  get StateUpdateError () { return StateUpdateError; }
+  get StateUpdateError () { return StateUpdateError; },
+  updateLeafs: updateLeafs
 });
 
 /**
@@ -12395,6 +12351,14 @@ const NoMachineError = Symbol("Machine index not found.");
 const SegmentExportError = Symbol("Too many segments already exported.");
 
 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.
  *
@@ -12424,10 +12388,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. */
@@ -12439,10 +12404,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));
@@ -12490,9 +12458,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) {
@@ -12501,7 +12469,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;
         }
@@ -12516,10 +12485,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;
         }
@@ -12532,7 +12502,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;
         }
@@ -12541,10 +12512,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);
@@ -12581,14 +12553,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.
@@ -12596,8 +12569,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) {
         check `${items >= 0} storageUtilisationCount has to be a positive number, got: ${items}`;
@@ -12606,11 +12581,11 @@ class PartiallyUpdatedState {
         const overflowBytes = !isU64(bytes);
         // TODO [ToDr] this is not specified in GP, but it seems sensible.
         if (overflowItems || overflowBytes) {
-            return Result$1.error(InsufficientFundsError);
+            return Result$1.error(InsufficientFundsError, () => `Storage utilisation overflow: items=${overflowItems}, bytes=${overflowBytes}`);
         }
         const thresholdBalance = ServiceAccountInfo.calculateThresholdBalance(items, bytes, serviceInfo.gratisStorage);
         if (serviceInfo.balance < thresholdBalance) {
-            return Result$1.error(InsufficientFundsError);
+            return Result$1.error(InsufficientFundsError, () => `Service balance (${serviceInfo.balance}) below threshold (${thresholdBalance})`);
         }
         // Update service info with new details.
         this.updateServiceInfo(serviceId, ServiceAccountInfo.create({
@@ -12621,22 +12596,25 @@ class PartiallyUpdatedState {
         return Result$1.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;
@@ -14255,7 +14233,7 @@ class ReadablePage extends MemoryPage {
     loadInto(result, startIndex, length) {
         const endIndex = startIndex + length;
         if (endIndex > PAGE_SIZE$1) {
-            return Result$1.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE$1));
+            return Result$1.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE$1), () => `Page fault: read beyond page boundary at ${this.start + PAGE_SIZE$1}`);
         }
         const bytes = this.data.subarray(startIndex, endIndex);
         // we zero the bytes, since data might not yet be initialized at `endIndex`.
@@ -14264,7 +14242,7 @@ class ReadablePage extends MemoryPage {
         return Result$1.ok(OK);
     }
     storeFrom(_address, _data) {
-        return Result$1.error(PageFault.fromMemoryIndex(this.start, true));
+        return Result$1.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);
@@ -14293,7 +14271,7 @@ class WriteablePage extends MemoryPage {
     loadInto(result, startIndex, length) {
         const endIndex = startIndex + length;
         if (endIndex > PAGE_SIZE$1) {
-            return Result$1.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE$1));
+            return Result$1.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE$1), () => `Page fault: read beyond page boundary at ${this.start + PAGE_SIZE$1}`);
         }
         const bytes = this.view.subarray(startIndex, endIndex);
         // we zero the bytes, since the view might not yet be initialized at `endIndex`.
@@ -14363,7 +14341,7 @@ class Memory {
         logger$3.insane `MEM[${address}] <- ${BytesBlob.blobFrom(bytes)}`;
         const pagesResult = this.getPages(address, bytes.length, AccessType.WRITE);
         if (pagesResult.isError) {
-            return Result$1.error(pagesResult.error);
+            return Result$1.error(pagesResult.error, pagesResult.details);
         }
         const pages = pagesResult.ok;
         let currentPosition = address;
@@ -14388,14 +14366,14 @@ class Memory {
         const pages = [];
         for (const pageNumber of pageRange) {
             if (pageNumber < RESERVED_NUMBER_OF_PAGES) {
-                return Result$1.error(PageFault.fromPageNumber(pageNumber, true));
+                return Result$1.error(PageFault.fromPageNumber(pageNumber, true), () => `Page fault: attempted to access reserved page ${pageNumber}`);
             }
             const page = this.memory.get(pageNumber);
             if (page === undefined) {
-                return Result$1.error(PageFault.fromPageNumber(pageNumber));
+                return Result$1.error(PageFault.fromPageNumber(pageNumber), () => `Page fault: page ${pageNumber} not allocated`);
             }
             if (accessType === AccessType.WRITE && !page.isWriteable()) {
-                return Result$1.error(PageFault.fromPageNumber(pageNumber, true));
+                return Result$1.error(PageFault.fromPageNumber(pageNumber, true), () => `Page fault: attempted to write to read-only page ${pageNumber}`);
             }
             pages.push(page);
         }
@@ -14413,7 +14391,7 @@ class Memory {
         }
         const pagesResult = this.getPages(startAddress, result.length, AccessType.READ);
         if (pagesResult.isError) {
-            return Result$1.error(pagesResult.error);
+            return Result$1.error(pagesResult.error, pagesResult.details);
         }
         const pages = pagesResult.ok;
         let currentPosition = startAddress;
@@ -16218,7 +16196,7 @@ class ProgramDecoder {
         }
         catch (e) {
             logger$2.error `Invalid program: ${e}`;
-            return Result$1.error(ProgramDecoderError.InvalidProgramError);
+            return Result$1.error(ProgramDecoderError.InvalidProgramError, () => `Program decoder error: ${e}`);
         }
     }
 }
@@ -16499,7 +16477,7 @@ class HostCallMemory {
             return Result$1.ok(OK);
         }
         if (address + tryAsU64(bytes.length) > MEMORY_SIZE) {
-            return Result$1.error(new OutOfBounds());
+            return Result$1.error(new OutOfBounds(), () => `Memory access out of bounds: address ${address} + length ${bytes.length} exceeds memory size`);
         }
         return this.memory.storeFrom(tryAsMemoryIndex(Number(address)), bytes);
     }
@@ -16508,13 +16486,10 @@ class HostCallMemory {
             return Result$1.ok(OK);
         }
         if (startAddress + tryAsU64(result.length) > MEMORY_SIZE) {
-            return Result$1.error(new OutOfBounds());
+            return Result$1.error(new OutOfBounds(), () => `Memory access out of bounds: address ${startAddress} + length ${result.length} exceeds memory size`);
         }
         return this.memory.loadInto(result, tryAsMemoryIndex(Number(startAddress)));
     }
-    getMemory() {
-        return this.memory;
-    }
 }
 
 class HostCallRegisters {
@@ -17602,32 +17577,33 @@ class Preimages {
             }
             if (prevPreimage.requester > currPreimage.requester ||
                 currPreimage.blob.compare(prevPreimage.blob).isLessOrEqual()) {
-                return Result$1.error(PreimagesErrorCode.PreimagesNotSortedUnique);
+                return Result$1.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$1.error(PreimagesErrorCode.AccountNotFound);
+                return Result$1.error(PreimagesErrorCode.AccountNotFound, () => `Service not found: ${requester}`);
             }
             const hasPreimage = service.hasPreimage(hash);
             const slots = service.getLookupHistory(hash, tryAsU32(blob.length));
             // https://graypaper.fluffylabs.dev/#/5f542d7/181800181900
             // https://graypaper.fluffylabs.dev/#/5f542d7/116f0011a500
             if (hasPreimage || slots === null || !LookupHistoryItem.isRequested(slots)) {
-                return Result$1.error(PreimagesErrorCode.PreimageUnneeded);
+                return Result$1.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$1.ok({
             preimages: pendingChanges,