@typeberry/jam 0.4.0 → 0.4.1-0a3acb2

package/bootstrap-importer.mjs

@@ -3550,7 +3550,11 @@ var TestSuite;
 })(TestSuite || (TestSuite = {}));
 const ALL_VERSIONS_IN_ORDER = [compatibility_GpVersion.V0_6_7, compatibility_GpVersion.V0_7_0, compatibility_GpVersion.V0_7_1, compatibility_GpVersion.V0_7_2];
 const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
-const DEFAULT_VERSION = compatibility_GpVersion.V0_7_2;
+/**
+ * Current version is set to track the jam-conformance testing.
+ * Since we are currently at 0.7.1 not 0.7.2, we set our default version accordingly.
+ */
+const DEFAULT_VERSION = compatibility_GpVersion.V0_7_1;
 const env = typeof process === "undefined" ? {} : process.env;
 let CURRENT_VERSION = parseCurrentVersion(env.GP_VERSION) ?? DEFAULT_VERSION;
 let CURRENT_SUITE = parseCurrentSuite(env.TEST_SUITE) ?? DEFAULT_SUITE;
@@ -3609,8 +3613,8 @@ class compatibility_Compatibility {
     /**
      * Allows selecting different values for different Gray Paper versions from one record.
      *
-     * @param fallback The default value to return if no value is found for the current.
-     * @param record A record mapping versions to values, checking if the version is greater or equal to the current version.
+     * fallback The default value to return if no value is found for the current.
+     * versions A record mapping versions to values, checking if the version is greater or equal to the current version.
      * @returns The value for the current version, or the default value.
      */
     static selectIfGreaterOrEqual({ fallback, versions, }) {
@@ -3773,7 +3777,7 @@ const workspacePathFix = dev_env.NODE_ENV === "development"
 
 ;// CONCATENATED MODULE: ./packages/core/utils/opaque.ts
 /**
- * @fileoverview `Opaque<Type, Token>` constructs a unique type which is a subset of Type with a
+ * `Opaque<Type, Token>` constructs a unique type which is a subset of Type with a
  * specified unique token Token. It means that base type cannot be assigned to unique type by accident.
  * Good examples of opaque types include:
  * - JWTs or other tokens - these are special kinds of string used for authorization purposes.
@@ -7100,11 +7104,9 @@ function sequenceViewFixLen(type, { fixedLength }) {
 
 /** Helper function to create most used hashes in the block */
 class TransitionHasher {
-    context;
     keccakHasher;
     blake2b;
-    constructor(context, keccakHasher, blake2b) {
-        this.context = context;
+    constructor(keccakHasher, blake2b) {
         this.keccakHasher = keccakHasher;
         this.blake2b = blake2b;
     }
@@ -7226,9 +7228,438 @@ class ArrayView {
     }
 }
 
+;// CONCATENATED MODULE: ./packages/core/collections/blob-dictionary.ts
+
+
+/** A map which uses byte blobs as keys */
+class BlobDictionary extends WithDebug {
+    mapNodeThreshold;
+    /**
+     * The root node of the dictionary.
+     *
+     * This is the main internal data structure that organizes entries
+     * in a tree-like fashion (array-based nodes up to `mapNodeThreshold`,
+     * map-based nodes beyond it). All insertions, updates, and deletions
+     * operate through this structure.
+     */
+    root = Node.withList();
+    /**
+     * Auxiliary map that stores references to the original keys and their values.
+     *
+     * - Overriding a value in the main structure does not replace the original key reference.
+     * - Used for efficient iteration over `keys()`, `values()`, `entries()`, and computing `size`.
+     */
+    keyvals = new Map();
+    /**
+     * Protected constructor used internally by `BlobDictionary.new`
+     * and `BlobDictionary.fromEntries`.
+     *
+     * This enforces controlled instantiation — users should create instances
+     * through the provided static factory methods instead of calling the
+     * constructor directly.
+     *
+     * @param mapNodeThreshold - The threshold that determines when the dictionary
+     * switches from using an array-based (`ListChildren`) node to a map-based (`MapChildren`) node for storing entries.
+     */
+    constructor(mapNodeThreshold) {
+        super();
+        this.mapNodeThreshold = mapNodeThreshold;
+    }
+    /**
+     * Returns the number of entries in the dictionary.
+     *
+     * The count is derived from the auxiliary `keyvals` map, which stores
+     * all original key references and their associated values. This ensures
+     * that the `size` reflects the actual number of entries, independent of
+     * internal overrides in the main `root` structure.
+     *
+     * @returns The total number of entries in the dictionary.
+     */
+    get size() {
+        return this.keyvals.size;
+    }
+    [TEST_COMPARE_USING]() {
+        const vals = Array.from(this);
+        vals.sort((a, b) => a[0].compare(b[0]).value);
+        return vals;
+    }
+    /**
+     * Creates an empty `BlobDictionary`.
+     *
+     * @param mapNodeThreshold - The threshold that determines when the dictionary
+     * switches from using an array-based (`ListChildren`) node to a map-based (`MapChildren`) node for storing entries.
+     * Defaults to `0`.
+     *
+     * @returns A new, empty `BlobDictionary` instance.
+     */
+    static new(mapNodeThreshold = 0) {
+        return new BlobDictionary(mapNodeThreshold);
+    }
+    /**
+     * Creates a new `BlobDictionary` initialized with the given entries.
+     *
+     * @param entries - An array of `[key, value]` pairs used to populate the dictionary.
+     * @param mapNodeThreshold - The threshold that determines when the dictionary
+     * switches from using an array-based (`ListChildren`) node to a map-based (`MapChildren`) node for storing entries.
+     * Defaults to `0`.
+     *
+     * @returns A new `BlobDictionary` containing the provided entries.
+     */
+    static fromEntries(entries, mapNodeThreshold) {
+        const dict = BlobDictionary.new(mapNodeThreshold);
+        for (const [key, value] of entries) {
+            dict.set(key, value);
+        }
+        return dict;
+    }
+    /**
+     * Internal helper that inserts, updates or deletes an entry in the dictionary.
+     *
+     * Behaviour details:
+     * - Passing `undefined` as `value` indicates a deletion. (E.g. `delete` uses `internalSet(key, undefined)`.)
+     * - When an add (new entry) or a delete actually changes the structure, the method returns the affected leaf node.
+     * - When the call only overrides an existing value (no structural add/delete), the method returns `null`.
+     *
+     * This method is intended for internal use by the dictionary implementation and allows `undefined` as a
+     * sentinel value to signal removals.
+     *
+     * @param key - The key to insert, update or remove.
+     * @param value - The value to associate with the key, or `undefined` to remove the key.
+     * @returns The leaf node created or removed on add/delete, or `null` if the operation only overwrote an existing value.
+     */
+    internalSet(key, value) {
+        let node = this.root;
+        const keyChunkGenerator = key.chunks(CHUNK_SIZE);
+        let depth = 0;
+        for (;;) {
+            const maybeKeyChunk = keyChunkGenerator.next().value;
+            if (maybeKeyChunk === undefined) {
+                if (value === undefined) {
+                    return node.remove(key);
+                }
+                return node.set(key, value);
+            }
+            const keyChunk = opaque_asOpaqueType(maybeKeyChunk);
+            if (node.children instanceof ListChildren) {
+                const subkey = bytes_BytesBlob.blobFrom(key.raw.subarray(CHUNK_SIZE * depth));
+                const leaf = value !== undefined ? node.children.insert(subkey, { key, value }) : node.children.remove(subkey);
+                if (subkey.length > CHUNK_SIZE && node.children.children.length > this.mapNodeThreshold) {
+                    node.convertListChildrenToMap();
+                }
+                return leaf;
+            }
+            depth += 1;
+            const children = node.children;
+            if (children instanceof ListChildren) {
+                throw new Error("We handle list node earlier. If we fall through, we know it's for the `Map` case.");
+            }
+            if (children instanceof MapChildren) {
+                const maybeNode = children.getChild(keyChunk);
+                if (maybeNode !== undefined) {
+                    // simply go one level deeper
+                    node = maybeNode;
+                }
+                else {
+                    // we are trying to remove an item, but it does not exist
+                    if (value === undefined) {
+                        return null;
+                    }
+                    // no more child nodes, we insert a new one.
+                    const newNode = Node.withList();
+                    children.setChild(keyChunk, newNode);
+                    node = newNode;
+                }
+                continue;
+            }
+            assertNever(children);
+        }
+    }
+    /**
+     * Adds a new entry to the dictionary or updates the value of an existing key.
+     *
+     * If an entry with the given key already exists, its value is replaced
+     * with the new one.
+     *
+     * @param key - The key to add or update in the dictionary.
+     * @param value - The value to associate with the specified key.
+     * @returns Nothing (`void`).
+     */
+    set(key, value) {
+        const leaf = this.internalSet(key, value);
+        if (leaf !== null) {
+            this.keyvals.set(leaf.key, leaf);
+        }
+    }
+    /**
+     * Retrieves the value associated with the given key from the dictionary.
+     *
+     * If the key does not exist, this method returns `undefined`.
+     *
+     * @param key - The key whose associated value should be retrieved.
+     * @returns The value associated with the specified key, or `undefined` if the key is not present.
+     */
+    get(key) {
+        let node = this.root;
+        const pathChunksGenerator = key.chunks(CHUNK_SIZE);
+        let depth = 0;
+        while (node !== undefined) {
+            const maybePathChunk = pathChunksGenerator.next().value;
+            if (node.children instanceof ListChildren) {
+                const subkey = bytes_BytesBlob.blobFrom(key.raw.subarray(depth * CHUNK_SIZE));
+                const child = node.children.find(subkey);
+                if (child !== null) {
+                    return child.value;
+                }
+            }
+            if (maybePathChunk === undefined) {
+                return node.getLeaf()?.value;
+            }
+            if (node.children instanceof MapChildren) {
+                const pathChunk = opaque_asOpaqueType(maybePathChunk);
+                node = node.children.getChild(pathChunk);
+                depth += 1;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Checks whether the dictionary contains an entry for the given key.
+     *
+     * ⚠️ **Note:** Avoid using `has(...)` together with `get(...)` in a pattern like this:
+     *
+     * ```ts
+     * if (dict.has(key)) {
+     *   const value = dict.get(key);
+     *   ...
+     * }
+     * ```
+     *
+     * This approach performs two lookups for the same key.
+     *
+     * Instead, prefer the following pattern, which retrieves the value once:
+     *
+     * ```ts
+     * const value = dict.get(key);
+     * if (value !== undefined) {
+     *   ...
+     * }
+     * ```
+     *
+     * @param key - The key to check for.
+     * @returns `true` if the dictionary contains an entry for the given key, otherwise `false`.
+     */
+    has(key) {
+        return this.get(key) !== undefined;
+    }
+    /**
+     * Removes an entry with the specified key from the dictionary.
+     *
+     * Internally, this calls {@link internalSet} with `undefined` to mark the entry as deleted.
+     *
+     * @param key - The key of the entry to remove.
+     * @returns `true` if an entry was removed (i.e. the key existed), otherwise `false`.
+     */
+    delete(key) {
+        const leaf = this.internalSet(key, undefined);
+        if (leaf !== null) {
+            this.keyvals.delete(leaf.key);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Returns an iterator over the keys in the dictionary.
+     *
+     * The iterator yields each key in insertion order.
+     *
+     * @returns An iterator over all keys in the dictionary.
+     */
+    keys() {
+        return this.keyvals.keys();
+    }
+    /**
+     * Returns an iterator over the values in the dictionary.
+     *
+     * The iterator yields each value in insertion order.
+     *
+     * @returns An iterator over all values in the dictionary.
+     */
+    *values() {
+        for (const leaf of this.keyvals.values()) {
+            yield leaf.value;
+        }
+    }
+    /**
+     * Returns an iterator over the `[key, value]` pairs in the dictionary.
+     *
+     * The iterator yields entries in insertion order.
+     *
+     * @returns An iterator over `[key, value]` tuples for each entry in the dictionary.
+     */
+    *entries() {
+        for (const leaf of this.keyvals.values()) {
+            yield [leaf.key, leaf.value];
+        }
+    }
+    /**
+     * Default iterator for the dictionary.
+     *
+     * Equivalent to calling {@link entries}.
+     * Enables iteration with `for...of`:
+     *
+     * ```ts
+     * for (const [key, value] of dict) {
+     *   ...
+     * }
+     * ```
+     *
+     * @returns An iterator over `[key, value]` pairs.
+     */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /**
+     * Creates a new sorted array of values, ordered by their corresponding keys.
+     *
+     * Iterates over all entries in the dictionary and sorts them according
+     * to the provided comparator function applied to the keys.
+     *
+     * @param comparator - A comparator function that can compare two keys.
+     *
+     * @returns A new array containing all values from the dictionary,
+     * sorted according to their keys.
+     */
+    toSortedArray(comparator) {
+        const vals = Array.from(this);
+        vals.sort((a, b) => comparator(a[0], b[0]).value);
+        return vals.map((x) => x[1]);
+    }
+}
+const CHUNK_SIZE = 6;
+/**
+ * A function to transform a bytes chunk (up to 6 bytes into U48 number)
+ *
+ * Note that it uses 3 additional bits to store length(`value * 8 + len;`),
+ * It is needed to distinguish shorter chunks that have 0s at the end, for example: [1, 2] and [1, 2, 0]
+ * */
+function bytesAsU48(bytes) {
+    const len = bytes.length;
+    debug_check `${len <= CHUNK_SIZE} Length has to be <= ${CHUNK_SIZE}, got: ${len}`;
+    let value = bytes[3] | (bytes[2] << 8) | (bytes[1] << 16) | (bytes[0] << 24);
+    for (let i = 4; i < bytes.length; i++) {
+        value = value * 256 + bytes[i];
+    }
+    return value * 8 + len;
+}
+class Node {
+    leaf;
+    children;
+    convertListChildrenToMap() {
+        if (!(this.children instanceof ListChildren)) {
+            return;
+        }
+        this.children = MapChildren.fromListNode(this.children);
+    }
+    static withList() {
+        return new Node(undefined, ListChildren.new());
+    }
+    static withMap() {
+        return new Node(undefined, MapChildren.new());
+    }
+    constructor(leaf, children) {
+        this.leaf = leaf;
+        this.children = children;
+    }
+    getLeaf() {
+        return this.leaf;
+    }
+    remove(_key) {
+        if (this.leaf === undefined) {
+            return null;
+        }
+        const removedLeaf = this.leaf;
+        this.leaf = undefined;
+        return removedLeaf;
+    }
+    set(key, value) {
+        if (this.leaf === undefined) {
+            this.leaf = { key, value };
+            return this.leaf;
+        }
+        this.leaf.value = value;
+        return null;
+    }
+}
+class ListChildren {
+    children = [];
+    constructor() { }
+    find(key) {
+        const result = this.children.find((item) => item[0].isEqualTo(key));
+        if (result !== undefined) {
+            return result[1];
+        }
+        return null;
+    }
+    remove(key) {
+        const existingIndex = this.children.findIndex((item) => item[0].isEqualTo(key));
+        if (existingIndex >= 0) {
+            const ret = this.children.splice(existingIndex, 1);
+            return ret[0][1];
+        }
+        return null;
+    }
+    insert(key, leaf) {
+        const existingIndex = this.children.findIndex((item) => item[0].isEqualTo(key));
+        if (existingIndex >= 0) {
+            const existing = this.children[existingIndex];
+            existing[1].value = leaf.value;
+            return null;
+        }
+        this.children.push([key, leaf]);
+        return leaf;
+    }
+    static new() {
+        return new ListChildren();
+    }
+}
+class MapChildren {
+    children = new Map();
+    constructor() { }
+    static new() {
+        return new MapChildren();
+    }
+    static fromListNode(node) {
+        const mapNode = new MapChildren();
+        for (const [key, leaf] of node.children) {
+            const currentKeyChunk = opaque_asOpaqueType(bytes_BytesBlob.blobFrom(key.raw.subarray(0, CHUNK_SIZE)));
+            const subKey = bytes_BytesBlob.blobFrom(key.raw.subarray(CHUNK_SIZE));
+            let child = mapNode.getChild(currentKeyChunk);
+            if (child === undefined) {
+                child = Node.withList();
+                mapNode.setChild(currentKeyChunk, child);
+            }
+            const children = child.children;
+            children.insert(subKey, leaf);
+        }
+        return mapNode;
+    }
+    getChild(keyChunk) {
+        const chunkAsNumber = bytesAsU48(keyChunk.raw);
+        return this.children.get(chunkAsNumber);
+    }
+    setChild(keyChunk, node) {
+        const chunkAsNumber = bytesAsU48(keyChunk.raw);
+        this.children.set(chunkAsNumber, node);
+    }
+}
+
 ;// CONCATENATED MODULE: ./packages/core/collections/hash-dictionary.ts
-/** A map which uses hashes as keys. */
-class hash_dictionary_HashDictionary {
+/**
+ * A map which uses hashes as keys.
+ *
+ * @deprecated
+ * */
+class StringHashDictionary {
     // TODO [ToDr] [crit] We can't use `TrieHash` directly in the map,
     // because of the way it's being compared. Hence having `string` here.
     // This has to be benchmarked and re-written to a custom map most likely.
@@ -7294,6 +7725,17 @@ class hash_dictionary_HashDictionary {
     }
 }
 
+/**
+ * A value that indicates when `BlobDictionary` transforms Array nodes into Map nodes.
+ * In practice, it doesn't matter much because, in real life, arrays in this structure usually have a length close to 1.
+ */
+const BLOB_DICTIONARY_THRESHOLD = 5;
+class hash_dictionary_HashDictionary extends BlobDictionary {
+    constructor() {
+        super(BLOB_DICTIONARY_THRESHOLD);
+    }
+}
+
 ;// CONCATENATED MODULE: ./packages/core/collections/hash-set.ts
 
 /** A set specialized for storing hashes. */
@@ -7758,6 +8200,18 @@ class SortedSet extends SortedArray {
 
 
 
+function getTruncatedKey(key) {
+    // Always return exactly TRUNCATED_HASH_SIZE bytes.
+    if (key.length === TRUNCATED_HASH_SIZE) {
+        return key;
+    }
+    return bytes_Bytes.fromBlob(key.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE);
+}
+/**
+ * A value that indicates when `BlobDictionary` transforms Array nodes into Map nodes.
+ * In practice, it doesn't matter much because, in real life, arrays in this structure usually have a length close to 1.
+ */
+const truncated_hash_dictionary_BLOB_DICTIONARY_THRESHOLD = 5;
 /**
  * A collection of hash-based keys (likely `StateKey`s) which ignores
  * differences on the last byte.
@@ -7770,48 +8224,37 @@ class TruncatedHashDictionary {
      * Each key will be copied and have the last byte replace with a 0.
      */
     static fromEntries(entries) {
-        /** Copy key bytes of an entry and replace the last one with 0. */
-        const mapped = Array.from(entries).map(([key, value]) => {
-            const newKey = bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
-            newKey.raw.set(key.raw.subarray(0, TRUNCATED_HASH_SIZE));
-            return [newKey, value];
-        });
-        return new TruncatedHashDictionary(hash_dictionary_HashDictionary.fromEntries(mapped));
+        return new TruncatedHashDictionary(BlobDictionary.fromEntries(Array.from(entries).map(([key, value]) => [getTruncatedKey(key), value]), truncated_hash_dictionary_BLOB_DICTIONARY_THRESHOLD));
     }
-    /** A truncated key which we re-use to query the dictionary. */
-    truncatedKey = bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
     constructor(dict) {
         this.dict = dict;
     }
     [TEST_COMPARE_USING]() {
-        return this.dict;
+        return Array.from(this.dict);
     }
     /** Return number of items in the dictionary. */
     get size() {
         return this.dict.size;
     }
     /** Retrieve a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-    get(fullKey) {
-        this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-        return this.dict.get(this.truncatedKey);
+    get(key) {
+        const truncatedKey = getTruncatedKey(key);
+        return this.dict.get(truncatedKey);
     }
     /** Return true if the key is present in the dictionary */
-    has(fullKey) {
-        this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-        return this.dict.has(this.truncatedKey);
+    has(key) {
+        const truncatedKey = getTruncatedKey(key);
+        return this.dict.has(truncatedKey);
     }
     /** Set or update a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-    set(fullKey, value) {
-        // NOTE we can't use the the shared key here, since the collection will
-        // store the key for us, hence the copy.
-        const key = bytes_Bytes.zero(hash_HASH_SIZE);
-        key.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-        this.dict.set(key.asOpaque(), value);
+    set(key, value) {
+        const truncatedKey = getTruncatedKey(key);
+        this.dict.set(truncatedKey, value);
     }
     /** Remove a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-    delete(fullKey) {
-        this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-        this.dict.delete(this.truncatedKey);
+    delete(key) {
+        const truncatedKey = getTruncatedKey(key);
+        this.dict.delete(truncatedKey);
     }
     /** Iterator over values of the dictionary. */
     values() {
@@ -7819,9 +8262,7 @@ class TruncatedHashDictionary {
     }
     /** Iterator over entries of the dictionary (with truncated keys) */
     *entries() {
-        for (const [key, value] of this.dict.entries()) {
-            yield [bytes_Bytes.fromBlob(key.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE).asOpaque(), value];
-        }
+        yield* this.dict.entries();
     }
     [Symbol.iterator]() {
         return this.entries();
@@ -7838,6 +8279,7 @@ class TruncatedHashDictionary {
 
 
 
+
 ;// CONCATENATED MODULE: ./packages/jam/config/chain-spec.ts
 
 
@@ -10630,11 +11072,32 @@ const ENTROPY_ENTRIES = 4;
 
 var state_update_UpdatePreimageKind;
 (function (UpdatePreimageKind) {
-    /** Insert new preimage and optionally update it's lookup history. */
+    /**
+     * Insert new preimage and optionally update it's lookup history.
+     *
+     * Used in: `provide`
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/383904383904?v=0.7.2
+     */
     UpdatePreimageKind[UpdatePreimageKind["Provide"] = 0] = "Provide";
-    /** Remove a preimage and it's lookup history. */
+    /**
+     * Remove a preimage and it's lookup history.
+     *
+     * Used in: `forget` and `eject`
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/38c701380202?v=0.7.2
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/379102379302?v=0.7.2
+     */
     UpdatePreimageKind[UpdatePreimageKind["Remove"] = 1] = "Remove";
-    /** update or add lookup history for preimage hash/len to given value. */
+    /**
+     * Update or add lookup history for preimage hash/len to given value.
+     *
+     * Used in: `solicit` and `forget`
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/382802382802?v=0.7.2
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/384002384b02?v=0.7.2
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/38c60038ea00?v=0.7.2
+     */
     UpdatePreimageKind[UpdatePreimageKind["UpdateOrAdd"] = 2] = "UpdateOrAdd";
 })(state_update_UpdatePreimageKind || (state_update_UpdatePreimageKind = {}));
 /**
@@ -10642,7 +11105,7 @@ var state_update_UpdatePreimageKind;
  *
  * Can be one of the following cases:
  * 1. Provide a new preimage blob and set the lookup history to available at `slot`.
- * 2. Remove (expunge) a preimage and it's lookup history.
+ * 2. Remove (forget) a preimage and it's lookup history.
  * 3. Update `LookupHistory` with given value.
  */
 class UpdatePreimage {
@@ -13212,7 +13675,6 @@ class LeafNode {
     /**
      * Get the byte length of embedded value.
      *
-     * @remark
      * Note in case this node only contains hash this is going to be 0.
      */
     getValueLength() {
@@ -13223,7 +13685,6 @@ class LeafNode {
     /**
      * Returns the embedded value.
      *
-     * @remark
      * Note that this is going to be empty for a regular leaf node (i.e. containing a hash).
      */
     getValue() {
@@ -13233,7 +13694,6 @@ class LeafNode {
     /**
      * Returns contained value hash.
      *
-     * @remark
      * Note that for embedded value this is going to be full 0-padded 32 bytes.
      */
     getValueHash() {
@@ -14254,7 +14714,11 @@ class PartiallyUpdatedState {
         const service = this.state.getService(serviceId);
         return service?.getPreimage(hash) ?? null;
     }
-    /** Get status of a preimage of current service taking into account any updates. */
+    /**
+     * Get status of a preimage of current service taking into account any updates.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/110201110201?v=0.7.2
+     */
     getLookupHistory(currentTimeslot, serviceId, hash, length) {
         const updatedService = this.stateUpdate.services.updated.get(serviceId);
         /** Return lookup history item for newly created service */
@@ -14291,12 +14755,7 @@ class PartiallyUpdatedState {
                 return new LookupHistoryItem(hash, updatedPreimage.length, service_tryAsLookupHistorySlots([currentTimeslot]));
             }
             case state_update_UpdatePreimageKind.Remove: {
-                const state = stateFallback();
-                // kinda impossible, since we know it's there because it's removed.
-                if (state === null) {
-                    return null;
-                }
-                return new LookupHistoryItem(hash, state.length, service_tryAsLookupHistorySlots([...state.slots, currentTimeslot]));
+                return null;
             }
             case state_update_UpdatePreimageKind.UpdateOrAdd: {
                 return action.item;
@@ -14389,7 +14848,7 @@ const gas_tryAsSmallGas = (v) => opaque_asOpaqueType(numbers_tryAsU32(v));
 /** Attempt to convert given number into U64 gas representation. */
 const tryAsBigGas = (v) => opaque_asOpaqueType(numbers_tryAsU64(v));
 /** Attempt to convert given number into gas. */
-const tryAsGas = (v) => typeof v === "number" && v < 2 ** 32 ? gas_tryAsSmallGas(v) : tryAsBigGas(v);
+const gas_tryAsGas = (v) => typeof v === "number" && v < 2 ** 32 ? gas_tryAsSmallGas(v) : tryAsBigGas(v);
 
 ;// CONCATENATED MODULE: ./packages/core/pvm-interface/memory.ts
 
@@ -14672,7 +15131,7 @@ const tryAsRegisterIndex = (index) => {
     debug_check `${index >= 0 && index < registers_NO_OF_REGISTERS} Incorrect register index: ${index}!`;
     return opaque_asOpaqueType(index);
 };
-class Registers {
+class registers_Registers {
     bytes;
     asSigned;
     asUnsigned;
@@ -14691,7 +15150,7 @@ class Registers {
     }
     static fromBytes(bytes) {
         debug_check `${bytes.length === registers_NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
-        return new Registers(bytes);
+        return new registers_Registers(bytes);
     }
     getBytesAsLittleEndian(index, len) {
         const offset = index << REGISTER_SIZE_SHIFT;
@@ -15005,49 +15464,10 @@ class NoopMissing {
     }
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/gas.ts
-
-
-/** Create a new gas counter instance depending on the gas value. */
-function gasCounter(gas) {
-    return new GasCounterU64(numbers_tryAsU64(gas));
-}
-class GasCounterU64 {
-    gas;
-    initialGas;
-    constructor(gas) {
-        this.gas = gas;
-        this.initialGas = tryAsGas(gas);
-    }
-    set(g) {
-        this.gas = numbers_tryAsU64(g);
-    }
-    get() {
-        return tryAsGas(this.gas);
-    }
-    sub(g) {
-        const result = this.gas - numbers_tryAsU64(g);
-        if (result >= 0n) {
-            this.gas = numbers_tryAsU64(result);
-            return false;
-        }
-        this.gas = numbers_tryAsU64(0n);
-        return true;
-    }
-    used() {
-        const gasConsumed = numbers_tryAsU64(this.initialGas) - this.gas;
-        // In we have less than zero left we assume that all gas has been consumed.
-        if (gasConsumed < 0) {
-            return this.initialGas;
-        }
-        return tryAsGas(gasConsumed);
-    }
-}
-
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory-index.ts
 
 
-const tryAsMemoryIndex = (index) => {
+const memory_index_tryAsMemoryIndex = (index) => {
     debug_check `${index >= 0 && index <= MAX_MEMORY_INDEX} Incorrect memory index: ${index}!`;
     return opaque_asOpaqueType(index);
 };
@@ -15061,25 +15481,25 @@ const tryAsSbrkIndex = (index) => {
 
 const memory_consts_PAGE_SIZE_SHIFT = 12;
 // PAGE_SIZE has to be a power of 2
-const PAGE_SIZE = 1 << memory_consts_PAGE_SIZE_SHIFT;
+const memory_consts_PAGE_SIZE = 1 << memory_consts_PAGE_SIZE_SHIFT;
 const MIN_ALLOCATION_SHIFT = (() => {
     const MIN_ALLOCATION_SHIFT = 7;
     debug_check `${MIN_ALLOCATION_SHIFT >= 0 && MIN_ALLOCATION_SHIFT < memory_consts_PAGE_SIZE_SHIFT} incorrect minimal allocation shift`;
     return MIN_ALLOCATION_SHIFT;
 })();
-const MIN_ALLOCATION_LENGTH = PAGE_SIZE >> MIN_ALLOCATION_SHIFT;
-const LAST_PAGE_NUMBER = (MEMORY_SIZE - PAGE_SIZE) / PAGE_SIZE;
+const MIN_ALLOCATION_LENGTH = memory_consts_PAGE_SIZE >> MIN_ALLOCATION_SHIFT;
+const LAST_PAGE_NUMBER = (MEMORY_SIZE - memory_consts_PAGE_SIZE) / memory_consts_PAGE_SIZE;
 /** https://graypaper.fluffylabs.dev/#/68eaa1f/35a60235a602?v=0.6.4 */
 const RESERVED_NUMBER_OF_PAGES = 16;
 /** https://graypaper.fluffylabs.dev/#/68eaa1f/35a60235a602?v=0.6.4 */
-const MAX_NUMBER_OF_PAGES = MEMORY_SIZE / PAGE_SIZE;
+const MAX_NUMBER_OF_PAGES = MEMORY_SIZE / memory_consts_PAGE_SIZE;
 
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/pages/page-utils.ts
 
 
 /** Ensure that given memory `index` is within `[0...PAGE_SIZE)` and can be used to index a page */
 const tryAsPageIndex = (index) => {
-    debug_check `${index >= 0 && index < PAGE_SIZE}, Incorect page index: ${index}!`;
+    debug_check `${index >= 0 && index < memory_consts_PAGE_SIZE}, Incorect page index: ${index}!`;
     return opaque_asOpaqueType(index);
 };
 /** Ensure that given `index` represents an index of one of the pages. */
@@ -15107,17 +15527,17 @@ function getNextPageNumber(pageNumber) {
 
 
 function alignToPageSize(length) {
-    return PAGE_SIZE * Math.ceil(length / PAGE_SIZE);
+    return memory_consts_PAGE_SIZE * Math.ceil(length / memory_consts_PAGE_SIZE);
 }
 function getPageNumber(address) {
     return tryAsPageNumber(address >>> memory_consts_PAGE_SIZE_SHIFT);
 }
 function getStartPageIndex(address) {
-    return tryAsMemoryIndex((address >>> memory_consts_PAGE_SIZE_SHIFT) << memory_consts_PAGE_SIZE_SHIFT);
+    return memory_index_tryAsMemoryIndex((address >>> memory_consts_PAGE_SIZE_SHIFT) << memory_consts_PAGE_SIZE_SHIFT);
 }
 function getStartPageIndexFromPageNumber(pageNumber) {
     // >>> 0 is needed to avoid changing sign of the number
-    return tryAsMemoryIndex((pageNumber << memory_consts_PAGE_SIZE_SHIFT) >>> 0);
+    return memory_index_tryAsMemoryIndex((pageNumber << memory_consts_PAGE_SIZE_SHIFT) >>> 0);
 }
 
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/errors.ts
@@ -15139,7 +15559,7 @@ class PageFault {
         return new PageFault(numbers_tryAsU32(startPageIndex), isAccessFault);
     }
     static fromMemoryIndex(maybeMemoryIndex, isAccessFault = false) {
-        const memoryIndex = tryAsMemoryIndex(maybeMemoryIndex % MEMORY_SIZE);
+        const memoryIndex = memory_index_tryAsMemoryIndex(maybeMemoryIndex % MEMORY_SIZE);
         const startPageIndex = getStartPageIndex(memoryIndex);
         return new PageFault(numbers_tryAsU32(startPageIndex), isAccessFault);
     }
@@ -15218,9 +15638,9 @@ class MemoryRange {
     constructor(start, length) {
         this.start = start;
         this.length = length;
-        this.end = tryAsMemoryIndex((this.start + this.length) % MEMORY_SIZE);
+        this.end = memory_index_tryAsMemoryIndex((this.start + this.length) % MEMORY_SIZE);
         if (length > 0) {
-            this.lastIndex = tryAsMemoryIndex((this.end - 1 + MEMORY_SIZE) % MEMORY_SIZE);
+            this.lastIndex = memory_index_tryAsMemoryIndex((this.end - 1 + MEMORY_SIZE) % MEMORY_SIZE);
         }
     }
     /** Creates a memory range from given starting point and length */
@@ -15263,7 +15683,7 @@ class MemoryRange {
  *
  * it should be in `memory-consts` but it cannot be there because of circular dependency
  */
-const RESERVED_MEMORY_RANGE = MemoryRange.fromStartAndLength(tryAsMemoryIndex(0), RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+const RESERVED_MEMORY_RANGE = MemoryRange.fromStartAndLength(memory_index_tryAsMemoryIndex(0), RESERVED_NUMBER_OF_PAGES * memory_consts_PAGE_SIZE);
 
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/page-range.ts
 
@@ -15301,7 +15721,7 @@ class PageRange {
         // lastIndex is not null because we just ensured that the range is not empty
         const pageWithLastIndex = getPageNumber(range.lastIndex ?? range.end);
         const endPage = getNextPageNumber(pageWithLastIndex);
-        if ((startPage === endPage || startPage === pageWithLastIndex) && range.length > PAGE_SIZE) {
+        if ((startPage === endPage || startPage === pageWithLastIndex) && range.length > memory_consts_PAGE_SIZE) {
             // full range
             return new PageRange(startPage, MAX_NUMBER_OF_PAGES);
         }
@@ -15365,8 +15785,8 @@ class ReadablePage extends MemoryPage {
     }
     loadInto(result, startIndex, length) {
         const endIndex = startIndex + length;
-        if (endIndex > PAGE_SIZE) {
-            return Result.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE), () => `Page fault: read beyond page boundary at ${this.start + PAGE_SIZE}`);
+        if (endIndex > memory_consts_PAGE_SIZE) {
+            return Result.error(PageFault.fromMemoryIndex(this.start + memory_consts_PAGE_SIZE), () => `Page fault: read beyond page boundary at ${this.start + memory_consts_PAGE_SIZE}`);
         }
         const bytes = this.data.subarray(startIndex, endIndex);
         // we zero the bytes, since data might not yet be initialized at `endIndex`.
@@ -15399,8 +15819,8 @@ class WriteablePage extends MemoryPage {
     constructor(pageNumber, initialData) {
         super(pageNumber);
         const dataLength = initialData?.length ?? 0;
-        const initialPageLength = Math.min(PAGE_SIZE, Math.max(dataLength, MIN_ALLOCATION_LENGTH));
-        this.buffer = new ArrayBuffer(initialPageLength, { maxByteLength: PAGE_SIZE });
+        const initialPageLength = Math.min(memory_consts_PAGE_SIZE, Math.max(dataLength, MIN_ALLOCATION_LENGTH));
+        this.buffer = new ArrayBuffer(initialPageLength, { maxByteLength: memory_consts_PAGE_SIZE });
         this.view = new Uint8Array(this.buffer);
         if (initialData !== undefined) {
             this.view.set(initialData);
@@ -15408,8 +15828,8 @@ class WriteablePage extends MemoryPage {
     }
     loadInto(result, startIndex, length) {
         const endIndex = startIndex + length;
-        if (endIndex > PAGE_SIZE) {
-            return Result.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE), () => `Page fault: read beyond page boundary at ${this.start + PAGE_SIZE}`);
+        if (endIndex > memory_consts_PAGE_SIZE) {
+            return Result.error(PageFault.fromMemoryIndex(this.start + memory_consts_PAGE_SIZE), () => `Page fault: read beyond page boundary at ${this.start + memory_consts_PAGE_SIZE}`);
         }
         const bytes = this.view.subarray(startIndex, endIndex);
         // we zero the bytes, since the view might not yet be initialized at `endIndex`.
@@ -15418,16 +15838,16 @@ class WriteablePage extends MemoryPage {
         return Result.ok(OK);
     }
     storeFrom(startIndex, bytes) {
-        if (this.buffer.byteLength < startIndex + bytes.length && this.buffer.byteLength < PAGE_SIZE) {
-            const newLength = Math.min(PAGE_SIZE, Math.max(MIN_ALLOCATION_LENGTH, startIndex + bytes.length));
+        if (this.buffer.byteLength < startIndex + bytes.length && this.buffer.byteLength < memory_consts_PAGE_SIZE) {
+            const newLength = Math.min(memory_consts_PAGE_SIZE, Math.max(MIN_ALLOCATION_LENGTH, startIndex + bytes.length));
             this.buffer.resize(newLength);
         }
         this.view.set(bytes, startIndex);
         return Result.ok(OK);
     }
     setData(pageIndex, data) {
-        if (this.buffer.byteLength < pageIndex + data.length && this.buffer.byteLength < PAGE_SIZE) {
-            const newLength = Math.min(PAGE_SIZE, Math.max(MIN_ALLOCATION_LENGTH, pageIndex + data.length));
+        if (this.buffer.byteLength < pageIndex + data.length && this.buffer.byteLength < memory_consts_PAGE_SIZE) {
+            const newLength = Math.min(memory_consts_PAGE_SIZE, Math.max(MIN_ALLOCATION_LENGTH, pageIndex + data.length));
             this.buffer.resize(newLength);
         }
         this.view.set(data, pageIndex);
@@ -15478,10 +15898,10 @@ class Memory {
         this.memory = memory;
     }
     store(address, bytes) {
-        return this.storeFrom(tryAsMemoryIndex(address), bytes);
+        return this.storeFrom(memory_index_tryAsMemoryIndex(address), bytes);
     }
     read(address, output) {
-        return this.loadInto(output, tryAsMemoryIndex(address));
+        return this.loadInto(output, memory_index_tryAsMemoryIndex(address));
     }
     reset() {
         this.sbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end);
@@ -15508,8 +15928,8 @@ class Memory {
         let currentPosition = address;
         let bytesLeft = bytes.length;
         for (const page of pages) {
-            const pageStartIndex = tryAsPageIndex(currentPosition % PAGE_SIZE);
-            const bytesToWrite = Math.min(PAGE_SIZE - pageStartIndex, bytesLeft);
+            const pageStartIndex = tryAsPageIndex(currentPosition % memory_consts_PAGE_SIZE);
+            const bytesToWrite = Math.min(memory_consts_PAGE_SIZE - pageStartIndex, bytesLeft);
             const sourceStartIndex = currentPosition - address;
             const source = bytes.subarray(sourceStartIndex, sourceStartIndex + bytesToWrite);
             page.storeFrom(pageStartIndex, source);
@@ -15558,8 +15978,8 @@ class Memory {
         let currentPosition = startAddress;
         let bytesLeft = result.length;
         for (const page of pages) {
-            const pageStartIndex = tryAsPageIndex(currentPosition % PAGE_SIZE);
-            const bytesToRead = Math.min(PAGE_SIZE - pageStartIndex, bytesLeft);
+            const pageStartIndex = tryAsPageIndex(currentPosition % memory_consts_PAGE_SIZE);
+            const bytesToRead = Math.min(memory_consts_PAGE_SIZE - pageStartIndex, bytesLeft);
             const destinationStartIndex = currentPosition - startAddress;
             const destination = result.subarray(destinationStartIndex);
             page.loadInto(destination, pageStartIndex, bytesToRead);
@@ -15586,7 +16006,7 @@ class Memory {
         const newSbrkIndex = tryAsSbrkIndex(alignToPageSize(newVirtualSbrkIndex));
         // TODO [MaSi]: `getPageNumber` works incorrectly for SbrkIndex. Sbrk index should be changed to MemoryIndex
         const firstPageNumber = getPageNumber(currentSbrkIndex);
-        const pagesToAllocate = (newSbrkIndex - currentSbrkIndex) / PAGE_SIZE;
+        const pagesToAllocate = (newSbrkIndex - currentSbrkIndex) / memory_consts_PAGE_SIZE;
         const rangeToAllocate = PageRange.fromStartAndLength(firstPageNumber, pagesToAllocate);
         for (const pageNumber of rangeToAllocate) {
             const page = new WriteablePage(pageNumber);
@@ -15641,8 +16061,8 @@ class MemoryBuilder {
     setReadablePages(start, end, data = new Uint8Array()) {
         this.ensureNotFinalized();
         debug_check `${start < end} end has to be bigger than start`;
-        debug_check `${start % PAGE_SIZE === 0} start needs to be a multiple of page size (${PAGE_SIZE})`;
-        debug_check `${end % PAGE_SIZE === 0} end needs to be a multiple of page size (${PAGE_SIZE})`;
+        debug_check `${start % memory_consts_PAGE_SIZE === 0} start needs to be a multiple of page size (${memory_consts_PAGE_SIZE})`;
+        debug_check `${end % memory_consts_PAGE_SIZE === 0} end needs to be a multiple of page size (${memory_consts_PAGE_SIZE})`;
         debug_check `${data.length <= end - start} the initial data is longer than address range`;
         const length = end - start;
         const range = MemoryRange.fromStartAndLength(start, length);
@@ -15651,7 +16071,7 @@ class MemoryBuilder {
         const noOfPages = pages.length;
         for (let i = 0; i < noOfPages; i++) {
             const pageNumber = pages[i];
-            const dataChunk = data.subarray(i * PAGE_SIZE, (i + 1) * PAGE_SIZE);
+            const dataChunk = data.subarray(i * memory_consts_PAGE_SIZE, (i + 1) * memory_consts_PAGE_SIZE);
             const page = new ReadablePage(pageNumber, dataChunk);
             this.initialMemory.set(pageNumber, page);
         }
@@ -15669,8 +16089,8 @@ class MemoryBuilder {
     setWriteablePages(start, end, data = new Uint8Array()) {
         this.ensureNotFinalized();
         debug_check `${start < end} end has to be bigger than start`;
-        debug_check `${start % PAGE_SIZE === 0} start needs to be a multiple of page size (${PAGE_SIZE})`;
-        debug_check `${end % PAGE_SIZE === 0} end needs to be a multiple of page size (${PAGE_SIZE})`;
+        debug_check `${start % memory_consts_PAGE_SIZE === 0} start needs to be a multiple of page size (${memory_consts_PAGE_SIZE})`;
+        debug_check `${end % memory_consts_PAGE_SIZE === 0} end needs to be a multiple of page size (${memory_consts_PAGE_SIZE})`;
         debug_check `${data.length <= end - start} the initial data is longer than address range`;
         const length = end - start;
         const range = MemoryRange.fromStartAndLength(start, length);
@@ -15679,7 +16099,7 @@ class MemoryBuilder {
         const noOfPages = pages.length;
         for (let i = 0; i < noOfPages; i++) {
             const pageNumber = pages[i];
-            const dataChunk = data.subarray(i * PAGE_SIZE, (i + 1) * PAGE_SIZE);
+            const dataChunk = data.subarray(i * memory_consts_PAGE_SIZE, (i + 1) * memory_consts_PAGE_SIZE);
             const page = new WriteablePage(pageNumber, dataChunk);
             this.initialMemory.set(pageNumber, page);
         }
@@ -15691,8 +16111,8 @@ class MemoryBuilder {
      */
     setData(start, data) {
         this.ensureNotFinalized();
-        const pageOffset = start % PAGE_SIZE;
-        const remainingSpaceOnPage = PAGE_SIZE - pageOffset;
+        const pageOffset = start % memory_consts_PAGE_SIZE;
+        const remainingSpaceOnPage = memory_consts_PAGE_SIZE - pageOffset;
         debug_check `${data.length <= remainingSpaceOnPage} The data has to fit into a single page.`;
         const length = data.length;
         const range = MemoryRange.fromStartAndLength(start, length);
@@ -15883,27 +16303,27 @@ class Program {
     static fromSpi(blob, args, hasMetadata) {
         const { code: spiCode, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
         const { code, memory: rawMemory, registers } = decodeStandardProgram(spiCode, args);
-        const regs = new Registers();
+        const regs = new registers_Registers();
         regs.copyFrom(registers);
         const memoryBuilder = new MemoryBuilder();
         for (const { start, end, data } of rawMemory.readable) {
-            const startIndex = tryAsMemoryIndex(start);
-            const endIndex = tryAsMemoryIndex(end);
+            const startIndex = memory_index_tryAsMemoryIndex(start);
+            const endIndex = memory_index_tryAsMemoryIndex(end);
             memoryBuilder.setReadablePages(startIndex, endIndex, data ?? new Uint8Array());
         }
         for (const { start, end, data } of rawMemory.writeable) {
-            const startIndex = tryAsMemoryIndex(start);
-            const endIndex = tryAsMemoryIndex(end);
+            const startIndex = memory_index_tryAsMemoryIndex(start);
+            const endIndex = memory_index_tryAsMemoryIndex(end);
             memoryBuilder.setWriteablePages(startIndex, endIndex, data ?? new Uint8Array());
         }
-        const heapStart = tryAsMemoryIndex(rawMemory.sbrkIndex);
+        const heapStart = memory_index_tryAsMemoryIndex(rawMemory.sbrkIndex);
         const heapEnd = tryAsSbrkIndex(rawMemory.heapEnd);
         const memory = memoryBuilder.finalize(heapStart, heapEnd);
         return new Program(code, regs, memory, metadata);
     }
     static fromGeneric(blob, hasMetadata) {
         const { code, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
-        const regs = new Registers();
+        const regs = new registers_Registers();
         const memory = new Memory();
         return new Program(code, regs, memory, metadata);
     }
@@ -16918,6 +17338,45 @@ class BasicBlocks {
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/basic-blocks/index.ts
 
 
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/gas.ts
+
+
+/** Create a new gas counter instance depending on the gas value. */
+function gasCounter(gas) {
+    return new GasCounterU64(numbers_tryAsU64(gas));
+}
+class GasCounterU64 {
+    gas;
+    initialGas;
+    constructor(gas) {
+        this.gas = gas;
+        this.initialGas = gas_tryAsGas(gas);
+    }
+    set(g) {
+        this.gas = numbers_tryAsU64(g);
+    }
+    get() {
+        return gas_tryAsGas(this.gas);
+    }
+    sub(g) {
+        const result = this.gas - numbers_tryAsU64(g);
+        if (result >= 0n) {
+            this.gas = numbers_tryAsU64(result);
+            return false;
+        }
+        this.gas = numbers_tryAsU64(0n);
+        return true;
+    }
+    used() {
+        const gasConsumed = numbers_tryAsU64(this.initialGas) - this.gas;
+        // In we have less than zero left we assume that all gas has been consumed.
+        if (gasConsumed < 0) {
+            return this.initialGas;
+        }
+        return gas_tryAsGas(gasConsumed);
+    }
+}
+
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/instruction-gas-map.ts
 
 
@@ -17494,7 +17953,7 @@ class LoadOps {
     }
     loadNumber(address, registerIndex, numberLength) {
         const registerBytes = this.regs.getBytesAsLittleEndian(registerIndex, REG_SIZE_BYTES);
-        const loadResult = this.memory.loadInto(registerBytes.subarray(0, numberLength), tryAsMemoryIndex(address));
+        const loadResult = this.memory.loadInto(registerBytes.subarray(0, numberLength), memory_index_tryAsMemoryIndex(address));
         if (loadResult.isError) {
             if (loadResult.error.isAccessFault) {
                 this.instructionResult.status = result_Result.FAULT_ACCESS;
@@ -17510,7 +17969,7 @@ class LoadOps {
     loadSignedNumber(address, registerIndex, numberLength) {
         // load all bytes from register to correctly handle the sign.
         const registerBytes = this.regs.getBytesAsLittleEndian(registerIndex, REG_SIZE_BYTES);
-        const loadResult = this.memory.loadInto(registerBytes.subarray(0, numberLength), tryAsMemoryIndex(address));
+        const loadResult = this.memory.loadInto(registerBytes.subarray(0, numberLength), memory_index_tryAsMemoryIndex(address));
         if (loadResult.isError) {
             if (loadResult.error.isAccessFault) {
                 this.instructionResult.status = result_Result.FAULT_ACCESS;
@@ -17932,7 +18391,7 @@ class StoreOps {
         this.store(address, secondImmediateDecoder.getExtendedBytesAsLittleEndian());
     }
     store(address, bytes) {
-        const storeResult = this.memory.storeFrom(tryAsMemoryIndex(address), bytes);
+        const storeResult = this.memory.storeFrom(memory_index_tryAsMemoryIndex(address), bytes);
         if (storeResult.isOk) {
             return;
         }
@@ -17941,7 +18400,7 @@ class StoreOps {
         }
         else {
             this.instructionResult.status = result_Result.FAULT;
-            this.instructionResult.exitParam = getStartPageIndex(tryAsMemoryIndex(storeResult.error.address));
+            this.instructionResult.exitParam = getStartPageIndex(memory_index_tryAsMemoryIndex(storeResult.error.address));
         }
     }
 }
@@ -18740,11 +19199,11 @@ class ProgramDecoder {
 
 
 const interpreter_logger = Logger.new(import.meta.filename, "pvm");
-class Interpreter {
+class interpreter_Interpreter {
     useSbrkGas;
-    registers = new Registers();
+    registers = new registers_Registers();
     memory = new Memory();
-    gas = gasCounter(tryAsGas(0));
+    gas = gasCounter(gas_tryAsGas(0));
     code = new Uint8Array();
     mask = Mask.empty();
     pc = 0;
@@ -18878,8 +19337,8 @@ class Interpreter {
                     break;
                 case ArgumentType.TWO_REGISTERS:
                     if (this.useSbrkGas && currentInstruction === Instruction.SBRK) {
-                        const calculateSbrkCost = (length) => (alignToPageSize(length) / PAGE_SIZE) * 16;
-                        const underflow = this.gas.sub(tryAsGas(calculateSbrkCost(this.registers.getLowerU32(argsResult.firstRegisterIndex))));
+                        const calculateSbrkCost = (length) => (alignToPageSize(length) / memory_consts_PAGE_SIZE) * 16;
+                        const underflow = this.gas.sub(gas_tryAsGas(calculateSbrkCost(this.registers.getLowerU32(argsResult.firstRegisterIndex))));
                         if (underflow) {
                             this.status = status_Status.OOG;
                             return this.status;
@@ -18974,12 +19433,88 @@ class Interpreter {
     }
 }
 
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/debugger-adapter.ts
+
+
+
+
+
+
+class DebuggerAdapter {
+    pvm;
+    constructor(useSbrkGas = false) {
+        this.pvm = new Interpreter({ useSbrkGas });
+    }
+    resetGeneric(rawProgram, flatRegisters, initialGas) {
+        this.pvm.resetGeneric(rawProgram, 0, tryAsGas(initialGas), new Registers(flatRegisters));
+    }
+    reset(rawProgram, pc, gas, maybeRegisters, maybeMemory) {
+        this.pvm.resetGeneric(rawProgram, pc, tryAsGas(gas), maybeRegisters, maybeMemory);
+    }
+    getPageDump(pageNumber) {
+        const page = this.pvm.getMemoryPage(pageNumber);
+        if (page === null) {
+            // page wasn't allocated so we return an empty page
+            return safeAllocUint8Array(PAGE_SIZE);
+        }
+        if (page.length === PAGE_SIZE) {
+            // page was allocated and has a proper size so we can simply return it
+            return page;
+        }
+        // page was allocated but it is shorter than PAGE_SIZE so we have to extend it
+        const fullPage = safeAllocUint8Array(PAGE_SIZE);
+        fullPage.set(page);
+        return fullPage;
+    }
+    setMemory(address, value) {
+        this.pvm.memory.storeFrom(tryAsMemoryIndex(address), value);
+    }
+    getExitArg() {
+        return this.pvm.getExitParam() ?? 0;
+    }
+    getStatus() {
+        return this.pvm.getStatus();
+    }
+    nextStep() {
+        return this.pvm.nextStep() === Status.OK;
+    }
+    nSteps(steps) {
+        check `${steps >>> 0 > 0} Expected a positive integer got ${steps}`;
+        for (let i = 0; i < steps; i++) {
+            const isOk = this.nextStep();
+            if (!isOk) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getRegisters() {
+        return this.pvm.registers.getAllU64();
+    }
+    setRegisters(registers) {
+        this.pvm.registers.copyFrom(new Registers(registers));
+    }
+    getProgramCounter() {
+        return this.pvm.getPC();
+    }
+    setNextProgramCounter(nextPc) {
+        this.pvm.setNextPC(nextPc);
+    }
+    getGasLeft() {
+        return BigInt(this.pvm.gas.get());
+    }
+    setGasLeft(gas) {
+        this.pvm.gas.set(tryAsGas(gas));
+    }
+}
+
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/index.ts
 
 
 
 
 
+
 ;// CONCATENATED MODULE: ./node_modules/@fluffylabs/anan-as/build/debug-raw.js
 async function instantiate(module, imports = {}) {
   const adaptedImports = {
@@ -19433,12 +19968,12 @@ class AnanasMemory {
 }
 class AnanasGasCounter {
     instance;
-    initialGas = tryAsGas(0n);
+    initialGas = gas_tryAsGas(0n);
     constructor(instance) {
         this.instance = instance;
     }
     get() {
-        return tryAsGas(this.instance.getGasLeft());
+        return gas_tryAsGas(this.instance.getGasLeft());
     }
     set(g) {
         this.instance.setGasLeft(BigInt(g));
@@ -19543,7 +20078,7 @@ class InterpreterInstanceManager {
         const instances = [];
         switch (interpreter) {
             case PvmBackend.BuiltIn:
-                instances.push(new Interpreter({
+                instances.push(new interpreter_Interpreter({
                     useSbrkGas: false,
                 }));
                 break;
@@ -19717,10 +20252,10 @@ class Info {
         const chunk = encodedInfo.raw.subarray(Number(offset), Number(offset + length));
         const writeResult = memory.storeFrom(outputStart, chunk);
         if (writeResult.isError) {
-            logger_logger.trace `INFO(${serviceId}, off: ${offset}, len: ${length}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] INFO(${serviceId}, off: ${offset}, len: ${length}) <- PANIC`;
             return PvmExecution.Panic;
         }
-        logger_logger.trace `INFO(${serviceId}, off: ${offset}, len: ${length}) <- ${bytes_BytesBlob.blobFrom(chunk)}`;
+        logger_logger.trace `[${this.currentServiceId}] INFO(${serviceId}, off: ${offset}, len: ${length}) <- ${bytes_BytesBlob.blobFrom(chunk)}`;
         if (accountInfo === null) {
             regs.set(IN_OUT_REG, HostCallResult.NONE);
             return;
@@ -19944,7 +20479,7 @@ class AccumulateExternalities {
             const bytes = serviceInfo.storageUtilisationBytes - length - LOOKUP_HISTORY_ENTRY_BYTES;
             return this.updatedState.updateServiceStorageUtilisation(this.currentServiceId, items, bytes, serviceInfo);
         };
-        // https://graypaper.fluffylabs.dev/#/9a08063/389501389501?v=0.6.6
+        // https://graypaper.fluffylabs.dev/#/ab2cdbd/380802380802?v=0.7.2
         if (s.status === PreimageStatusKind.Requested) {
             const res = updateStorageUtilisation();
             if (res.isError) {
@@ -19957,7 +20492,7 @@ class AccumulateExternalities {
             return Result.ok(OK);
         }
         const t = this.currentTimeslot;
-        // https://graypaper.fluffylabs.dev/#/9a08063/378102378102?v=0.6.6
+        // https://graypaper.fluffylabs.dev/#/ab2cdbd/380802380802?v=0.7.2
         if (s.status === PreimageStatusKind.Unavailable) {
             const y = s.data[1];
             if (y < t - this.chainSpec.preimageExpungePeriod) {
@@ -19973,14 +20508,14 @@ class AccumulateExternalities {
             }
             return Result.error(ForgetPreimageError.NotExpired, () => `Preimage not expired: y=${y}, timeslot=${t}, period=${this.chainSpec.preimageExpungePeriod}`);
         }
-        // https://graypaper.fluffylabs.dev/#/9a08063/38c80138c801?v=0.6.6
+        // https://graypaper.fluffylabs.dev/#/ab2cdbd/382802383302?v=0.7.2
         if (s.status === PreimageStatusKind.Available) {
             this.updatedState.updatePreimage(serviceId, UpdatePreimage.updateOrAdd({
                 lookupHistory: new LookupHistoryItem(status.hash, status.length, service_tryAsLookupHistorySlots([s.data[0], t])),
             }));
             return Result.ok(OK);
         }
-        // https://graypaper.fluffylabs.dev/#/9a08063/38d00138d001?v=0.6.6
+        // https://graypaper.fluffylabs.dev/#/ab2cdbd/384002384c02?v=0.7.2
         if (s.status === PreimageStatusKind.Reavailable) {
             const y = s.data[1];
             if (y < t - this.chainSpec.preimageExpungePeriod) {
@@ -20816,13 +21351,11 @@ class AccumulateDataItem {
  * - gas cost and reports length for each service (statistics)
  */
 class AccumulateData {
-    autoAccumulateServicesByServiceId;
     reportsDataByServiceId;
     transfersByServiceId;
     serviceIds;
     gasLimitByServiceId;
     constructor(reports, transfers, autoAccumulateServicesByServiceId) {
-        this.autoAccumulateServicesByServiceId = autoAccumulateServicesByServiceId;
         const serviceIdsFromAutoAccumulate = new Set(autoAccumulateServicesByServiceId.keys());
         const { reportsDataByServiceId, serviceIds: serviceIdsFromReports, gasLimitByServiceId: reportsGasLimitByServiceId, } = this.transformReports(reports);
         this.reportsDataByServiceId = reportsDataByServiceId;
@@ -21142,12 +21675,12 @@ function createMergeContext(chainSpec, state, inputState, results) {
 }
 function updatePrivilegedService(currentServiceId, serviceIdUpdatedByManager, selfUpdatedServiceId) {
     if (currentServiceId === serviceIdUpdatedByManager) {
-        return serviceIdUpdatedByManager;
+        return selfUpdatedServiceId;
     }
-    return selfUpdatedServiceId;
+    return serviceIdUpdatedByManager;
 }
 function mergePrivilegedServices(mergeContext, [serviceId, { stateUpdate }]) {
-    const { outputState, currentPrivilegedServices, chainSpec } = mergeContext;
+    const { outputState, currentPrivilegedServices, chainSpec, privilegedServicesUpdatedByManager } = mergeContext;
     const currentManager = currentPrivilegedServices.manager;
     const currentRegistrar = currentPrivilegedServices.registrar;
     const currentDelegator = currentPrivilegedServices.delegator;
@@ -21165,28 +21698,35 @@ function mergePrivilegedServices(mergeContext, [serviceId, { stateUpdate }]) {
             });
         }
         if (serviceId === currentRegistrar) {
-            const newRegistrar = updatePrivilegedService(currentPrivilegedServices.registrar, outputState.privilegedServices.registrar, privilegedServices.registrar);
+            const newRegistrar = updatePrivilegedService(currentPrivilegedServices.registrar, privilegedServicesUpdatedByManager.registrar, privilegedServices.registrar);
             outputState.privilegedServices = PrivilegedServices.create({
                 ...outputState.privilegedServices,
                 registrar: newRegistrar,
             });
         }
         if (serviceId === currentDelegator) {
-            const newDelegator = updatePrivilegedService(currentPrivilegedServices.delegator, outputState.privilegedServices.delegator, privilegedServices.delegator);
+            const newDelegator = updatePrivilegedService(currentPrivilegedServices.delegator, privilegedServicesUpdatedByManager.delegator, privilegedServices.delegator);
             outputState.privilegedServices = PrivilegedServices.create({
                 ...outputState.privilegedServices,
                 delegator: newDelegator,
             });
         }
-        const assignersFromOutputState = outputState.privilegedServices;
-        const newAssigners = currentAssigners.map((currentAssigner, coreIndex) => serviceId === currentAssigner
-            ? updatePrivilegedService(currentPrivilegedServices.assigners[coreIndex], assignersFromOutputState.assigners[coreIndex], privilegedServices.assigners[coreIndex])
-            : currentAssigner);
-        const newAssignersPerCore = tryAsPerCore(newAssigners, chainSpec);
-        outputState.privilegedServices = PrivilegedServices.create({
-            ...outputState.privilegedServices,
-            assigners: newAssignersPerCore,
+        let shouldUpdateAssigners = false;
+        const newAssigners = currentAssigners.map((currentAssigner, coreIndex) => {
+            if (serviceId === currentAssigner) {
+                const newAssigner = updatePrivilegedService(currentPrivilegedServices.assigners[coreIndex], privilegedServicesUpdatedByManager.assigners[coreIndex], privilegedServices.assigners[coreIndex]);
+                shouldUpdateAssigners = shouldUpdateAssigners || newAssigner !== currentAssigner;
+                return newAssigner;
+            }
+            return currentAssigner;
         });
+        if (shouldUpdateAssigners) {
+            const newAssignersPerCore = tryAsPerCore(newAssigners, chainSpec);
+            outputState.privilegedServices = PrivilegedServices.create({
+                ...outputState.privilegedServices,
+                assigners: newAssignersPerCore,
+            });
+        }
     }
 }
 function mergeValidatorsData(mergeContext, [serviceId, { stateUpdate }]) {
@@ -21331,7 +21871,7 @@ class Assign {
         const memoryReadResult = memory.loadInto(res, authorizationQueueStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `ASSIGN() <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] ASSIGN() <- PANIC`;
             return PvmExecution.Panic;
         }
         if (maybeCoreIndex >= this.chainSpec.coresCount) {
@@ -21346,18 +21886,18 @@ class Assign {
         const result = this.partialState.updateAuthorizationQueue(coreIndex, fixedSizeAuthQueue, assigners);
         if (result.isOk) {
             regs.set(assign_IN_OUT_REG, HostCallResult.OK);
-            logger_logger.trace `ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- OK`;
+            logger_logger.trace `[${this.currentServiceId}] ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- OK`;
             return;
         }
         const e = result.error;
         if (e === UpdatePrivilegesError.UnprivilegedService) {
             regs.set(assign_IN_OUT_REG, HostCallResult.HUH);
-            logger_logger.trace `ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`;
+            logger_logger.trace `[${this.currentServiceId}] ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`;
             return;
         }
         if (e === UpdatePrivilegesError.InvalidServiceId) {
             regs.set(assign_IN_OUT_REG, HostCallResult.WHO);
-            logger_logger.trace `ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`;
+            logger_logger.trace `[${this.currentServiceId}] ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`;
             return;
         }
         assertNever(e);
@@ -21428,7 +21968,7 @@ class Bless {
             decoder.resetTo(0);
             const memoryReadResult = memory.loadInto(result, memIndex);
             if (memoryReadResult.isError) {
-                logger_logger.trace `BLESS(m: ${manager}, v: ${delegator}, r: ${registrar}) <- PANIC`;
+                logger_logger.trace `[${this.currentServiceId}] BLESS(m: ${manager}, v: ${delegator}, r: ${registrar}) <- PANIC`;
                 return PvmExecution.Panic;
             }
             const { serviceId, gas } = decoder.object(serviceIdAndGasCodec);
@@ -21441,26 +21981,26 @@ class Bless {
         const authorizersDecoder = decoder_Decoder.fromBlob(res);
         const memoryReadResult = memory.loadInto(res, authorization);
         if (memoryReadResult.isError) {
-            logger_logger.trace `BLESS(m: ${manager}, v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] BLESS(m: ${manager}, v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- PANIC`;
             return PvmExecution.Panic;
         }
         // `a`
         const authorizers = tryAsPerCore(authorizersDecoder.sequenceFixLen(descriptors_codec.u32.asOpaque(), this.chainSpec.coresCount), this.chainSpec);
         const updateResult = this.partialState.updatePrivilegedServices(manager, authorizers, delegator, registrar, autoAccumulate);
         if (updateResult.isOk) {
-            logger_logger.trace `BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- OK`;
+            logger_logger.trace `[${this.currentServiceId}] BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- OK`;
             regs.set(bless_IN_OUT_REG, HostCallResult.OK);
             return;
         }
         const e = updateResult.error;
         // NOTE: `UpdatePrivilegesError.UnprivilegedService` won't happen in 0.7.1+
         if (e === UpdatePrivilegesError.UnprivilegedService) {
-            logger_logger.trace `BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- HUH`;
+            logger_logger.trace `[${this.currentServiceId}] BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- HUH`;
             regs.set(bless_IN_OUT_REG, HostCallResult.HUH);
             return;
         }
         if (e === UpdatePrivilegesError.InvalidServiceId) {
-            logger_logger.trace `BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- WHO`;
+            logger_logger.trace `[${this.currentServiceId}] BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- WHO`;
             regs.set(bless_IN_OUT_REG, HostCallResult.WHO);
             return;
         }
@@ -21490,7 +22030,7 @@ class GasHostCall {
     }
     execute(gas, regs) {
         const gasValue = gas.get();
-        logger_logger.trace `GAS <- ${gasValue}`;
+        logger_logger.trace `[${this.currentServiceId}] GAS <- ${gasValue}`;
         regs.set(7, numbers_tryAsU64(gasValue));
         return Promise.resolve(undefined);
     }
@@ -21522,7 +22062,7 @@ class Checkpoint {
     async execute(gas, regs) {
         await this.gasHostCall.execute(gas, regs);
         this.partialState.checkpoint();
-        logger_logger.trace `CHECKPOINT()`;
+        logger_logger.trace `[${this.currentServiceId}] CHECKPOINT()`;
         return;
     }
 }
@@ -21562,18 +22102,18 @@ class Designate {
         const memoryReadResult = memory.loadInto(res, validatorsStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `DESIGNATE() <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] DESIGNATE() <- PANIC`;
             return PvmExecution.Panic;
         }
         const decoder = decoder_Decoder.fromBlob(res);
         const validatorsData = decoder.sequenceFixLen(ValidatorData.Codec, this.chainSpec.validatorsCount);
         const result = this.partialState.updateValidatorsData(tryAsPerValidator(validatorsData, this.chainSpec));
         if (result.isError) {
-            logger_logger.trace `DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- HUH`;
+            logger_logger.trace `[${this.currentServiceId}] DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- HUH`;
             regs.set(designate_IN_OUT_REG, HostCallResult.HUH);
         }
         else {
-            logger_logger.trace `DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- OK`;
+            logger_logger.trace `[${this.currentServiceId}] DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- OK`;
             regs.set(designate_IN_OUT_REG, HostCallResult.OK);
         }
     }
@@ -21614,29 +22154,29 @@ class Eject {
         const previousCodeHash = bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
         const memoryReadResult = memory.loadInto(previousCodeHash.raw, preimageHashStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace `EJECT(${serviceId}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] EJECT(${serviceId}) <- PANIC`;
             return PvmExecution.Panic;
         }
         // cannot eject self
         if (serviceId === this.currentServiceId) {
             regs.set(eject_IN_OUT_REG, HostCallResult.WHO);
-            logger_logger.trace `EJECT(${serviceId}, ${previousCodeHash}) <- WHO`;
+            logger_logger.trace `[${this.currentServiceId}] EJECT(${serviceId}, ${previousCodeHash}) <- WHO`;
             return;
         }
         const result = this.partialState.eject(serviceId, previousCodeHash);
         // All good!
         if (result.isOk) {
-            logger_logger.trace `EJECT(${serviceId}, ${previousCodeHash}) <- OK`;
+            logger_logger.trace `[${this.currentServiceId}] EJECT(${serviceId}, ${previousCodeHash}) <- OK`;
             regs.set(eject_IN_OUT_REG, HostCallResult.OK);
             return;
         }
         const e = result.error;
         if (e === EjectError.InvalidService) {
-            logger_logger.trace `EJECT(${serviceId}, ${previousCodeHash}) <- WHO ${resultToString(result)}`;
+            logger_logger.trace `[${this.currentServiceId}] EJECT(${serviceId}, ${previousCodeHash}) <- WHO ${resultToString(result)}`;
             regs.set(eject_IN_OUT_REG, HostCallResult.WHO);
         }
         else if (e === EjectError.InvalidPreimage) {
-            logger_logger.trace `EJECT(${serviceId}, ${previousCodeHash}) <- HUH ${resultToString(result)}`;
+            logger_logger.trace `[${this.currentServiceId}] EJECT(${serviceId}, ${previousCodeHash}) <- HUH ${resultToString(result)}`;
             regs.set(eject_IN_OUT_REG, HostCallResult.HUH);
         }
         else {
@@ -21655,9 +22195,9 @@ class Eject {
 
 const forget_IN_OUT_REG = 7;
 /**
- * Mark a preimage hash as unavailable.
+ * Delete preimage hash or mark as unavailable if it was available.
  *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/382d01382d01?v=0.6.7
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/385d01385d01?v=0.7.2
  */
 class Forget {
     currentServiceId;
@@ -21678,11 +22218,11 @@ class Forget {
         const memoryReadResult = memory.loadInto(hash.raw, hashStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `FORGET(${hash}, ${length}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] FORGET(${hash}, ${length}) <- PANIC`;
             return PvmExecution.Panic;
         }
         const result = this.partialState.forgetPreimage(hash.asOpaque(), length);
-        logger_logger.trace `FORGET(${hash}, ${length}) <- ${resultToString(result)}`;
+        logger_logger.trace `[${this.currentServiceId}] FORGET(${hash}, ${length}) <- ${resultToString(result)}`;
         if (result.isOk) {
             regs.set(forget_IN_OUT_REG, HostCallResult.OK);
         }
@@ -21739,11 +22279,11 @@ class New {
         const memoryReadResult = memory.loadInto(codeHash.raw, codeHashStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}, ${requestedServiceId}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}, ${requestedServiceId}) <- PANIC`;
             return PvmExecution.Panic;
         }
         const assignedId = this.partialState.newService(codeHash.asOpaque(), codeLength, gas, allowance, gratisStorage, requestedServiceId);
-        logger_logger.trace `NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}, ${requestedServiceId}) <- ${resultToString(assignedId)}`;
+        logger_logger.trace `[${this.currentServiceId}] NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}, ${requestedServiceId}) <- ${resultToString(assignedId)}`;
         if (assignedId.isOk) {
             regs.set(new_IN_OUT_REG, numbers_tryAsU64(assignedId.ok));
             return;
@@ -21803,11 +22343,11 @@ class Provide {
         const preimage = bytes_BytesBlob.blobFrom(safe_alloc_uint8array_safeAllocUint8Array(length));
         const memoryReadResult = memory.loadInto(preimage.raw, preimageStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace `PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- PANIC`;
             return PvmExecution.Panic;
         }
         const result = this.partialState.providePreimage(serviceId, preimage);
-        logger_logger.trace `PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- ${resultToString(result)}`;
+        logger_logger.trace `[${this.currentServiceId}] PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- ${resultToString(result)}`;
         if (result.isOk) {
             regs.set(provide_IN_OUT_REG, HostCallResult.OK);
             return;
@@ -21863,35 +22403,35 @@ class Query {
         const memoryReadResult = memory.loadInto(hash.raw, hashStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `QUERY(${hash}, ${length}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] QUERY(${hash}, ${length}) <- PANIC`;
             return PvmExecution.Panic;
         }
         const result = this.partialState.checkPreimageStatus(hash.asOpaque(), length);
         const zero = numbers_tryAsU64(0n);
         if (result === null) {
-            logger_logger.trace `QUERY(${hash}, ${length}) <- NONE`;
+            logger_logger.trace `[${this.currentServiceId}] QUERY(${hash}, ${length}) <- NONE`;
             regs.set(IN_OUT_REG_1, HostCallResult.NONE);
             regs.set(IN_OUT_REG_2, zero);
             return;
         }
         switch (result.status) {
             case PreimageStatusKind.Requested:
-                logger_logger.trace `QUERY(${hash}, ${length}) <- REQUESTED`;
+                logger_logger.trace `[${this.currentServiceId}] QUERY(${hash}, ${length}) <- REQUESTED`;
                 regs.set(IN_OUT_REG_1, zero);
                 regs.set(IN_OUT_REG_2, zero);
                 return;
             case PreimageStatusKind.Available:
-                logger_logger.trace `QUERY(${hash}, ${length}) <- AVAILABLE [${result.data}]`;
+                logger_logger.trace `[${this.currentServiceId}] QUERY(${hash}, ${length}) <- AVAILABLE [${result.data}]`;
                 regs.set(IN_OUT_REG_1, numbers_tryAsU64((BigInt(result.data[0]) << UPPER_BITS_SHIFT) + 1n));
                 regs.set(IN_OUT_REG_2, zero);
                 return;
             case PreimageStatusKind.Unavailable:
-                logger_logger.trace `QUERY(${hash}, ${length}) <- UNAVAILABLE [${result.data.join(", ")}]`;
+                logger_logger.trace `[${this.currentServiceId}] QUERY(${hash}, ${length}) <- UNAVAILABLE [${result.data.join(", ")}]`;
                 regs.set(IN_OUT_REG_1, numbers_tryAsU64((BigInt(result.data[0]) << UPPER_BITS_SHIFT) + 2n));
                 regs.set(IN_OUT_REG_2, numbers_tryAsU64(result.data[1]));
                 return;
             case PreimageStatusKind.Reavailable:
-                logger_logger.trace `QUERY(${hash}, ${length}) <- REAVAILABLE [${result.data.join(", ")}]`;
+                logger_logger.trace `[${this.currentServiceId}] QUERY(${hash}, ${length}) <- REAVAILABLE [${result.data.join(", ")}]`;
                 regs.set(IN_OUT_REG_1, numbers_tryAsU64((BigInt(result.data[0]) << UPPER_BITS_SHIFT) + 3n));
                 regs.set(IN_OUT_REG_2, numbers_tryAsU64((BigInt(result.data[2]) << UPPER_BITS_SHIFT) + BigInt(result.data[1])));
                 return;
@@ -21932,11 +22472,11 @@ class Solicit {
         const hash = bytes_Bytes.zero(hash_HASH_SIZE);
         const memoryReadResult = memory.loadInto(hash.raw, hashStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace `SOLICIT(${hash}, ${length}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] SOLICIT(${hash}, ${length}) <- PANIC`;
             return PvmExecution.Panic;
         }
         const result = this.partialState.requestPreimage(hash.asOpaque(), length);
-        logger_logger.trace `SOLICIT(${hash}, ${length}) <- ${resultToString(result)}`;
+        logger_logger.trace `[${this.currentServiceId}] SOLICIT(${hash}, ${length}) <- ${resultToString(result)}`;
         if (result.isOk) {
             regs.set(solicit_IN_OUT_REG, HostCallResult.OK);
             return;
@@ -21994,7 +22534,7 @@ class Transfer {
      */
     basicGasCost = compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_2)
         ? gas_tryAsSmallGas(10)
-        : (regs) => tryAsGas(10n + regs.get(TRANSFER_GAS_FEE_REG));
+        : (regs) => gas_tryAsGas(10n + regs.get(TRANSFER_GAS_FEE_REG));
     tracedRegisters = traceRegisters(transfer_IN_OUT_REG, AMOUNT_REG, TRANSFER_GAS_FEE_REG, MEMO_START_REG);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
@@ -22013,16 +22553,16 @@ class Transfer {
         const memoryReadResult = memory.loadInto(memo.raw, memoStart);
         // page fault while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `TRANSFER(${destination}, ${amount}, ${transferGasFee}, ${memo}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] TRANSFER(${destination}, ${amount}, ${transferGasFee}, ${memo}) <- PANIC`;
             return PvmExecution.Panic;
         }
         const transferResult = this.partialState.transfer(destination, amount, transferGasFee, memo);
-        logger_logger.trace `TRANSFER(${destination}, ${amount}, ${transferGasFee}, ${memo}) <- ${resultToString(transferResult)}`;
+        logger_logger.trace `[${this.currentServiceId}] TRANSFER(${destination}, ${amount}, ${transferGasFee}, ${memo}) <- ${resultToString(transferResult)}`;
         // All good!
         if (transferResult.isOk) {
             if (compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_2)) {
                 // substracting value `t`
-                const underflow = gas.sub(tryAsGas(transferGasFee));
+                const underflow = gas.sub(gas_tryAsGas(transferGasFee));
                 if (underflow) {
                     return PvmExecution.OOG;
                 }
@@ -22083,11 +22623,11 @@ class Upgrade {
         const codeHash = bytes_Bytes.zero(hash_HASH_SIZE);
         const memoryReadResult = memory.loadInto(codeHash.raw, codeHashStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace `UPGRADE(${codeHash}, ${gas}, ${allowance}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] UPGRADE(${codeHash}, ${gas}, ${allowance}) <- PANIC`;
             return PvmExecution.Panic;
         }
         this.partialState.upgradeService(codeHash.asOpaque(), gas, allowance);
-        logger_logger.trace `UPGRADE(${codeHash}, ${gas}, ${allowance})`;
+        logger_logger.trace `[${this.currentServiceId}] UPGRADE(${codeHash}, ${gas}, ${allowance})`;
         regs.set(upgrade_IN_OUT_REG, HostCallResult.OK);
     }
 }
@@ -22121,11 +22661,11 @@ class Yield {
         const hash = bytes_Bytes.zero(hash_HASH_SIZE);
         const memoryReadResult = memory.loadInto(hash.raw, hashStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace `YIELD() <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] YIELD() <- PANIC`;
             return PvmExecution.Panic;
         }
         this.partialState.yield(hash);
-        logger_logger.trace `YIELD(${hash})`;
+        logger_logger.trace `[${this.currentServiceId}] YIELD(${hash})`;
         regs.set(yield_IN_OUT_REG, HostCallResult.OK);
     }
 }
@@ -22168,10 +22708,10 @@ class Fetch {
         const chunk = value === null ? new Uint8Array() : value.raw.subarray(Number(offset), Number(offset + length));
         const storeResult = memory.storeFrom(output, chunk);
         if (storeResult.isError) {
-            logger_logger.trace `FETCH(${kind}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] FETCH(${kind}) <- PANIC`;
             return PvmExecution.Panic;
         }
-        logger_logger.trace `FETCH(${kind}) <- ${value?.toStringTruncated()}`;
+        logger_logger.trace `[${this.currentServiceId}] FETCH(${kind}) <- ${value?.toStringTruncated()}`;
         // write result
         regs.set(fetch_IN_OUT_REG, value === null ? HostCallResult.NONE : valueLength);
     }
@@ -22321,7 +22861,7 @@ class LogHostCall {
         }
         memory.loadInto(message, msgStart);
         const level = clampU64ToU32(lvl);
-        logger_logger.trace `LOG(${this.currentServiceId}, ${level < Levels.UNKNOWN ? Levels[level] : Levels[Levels.UNKNOWN]}(${lvl}), ${decoder.decode(target)}, ${decoder.decode(message)})`;
+        logger_logger.trace `[${this.currentServiceId}] LOG(${this.currentServiceId}, ${level < Levels.UNKNOWN ? Levels[level] : Levels[Levels.UNKNOWN]}(${lvl}), ${decoder.decode(target)}, ${decoder.decode(message)})`;
         return Promise.resolve(undefined);
     }
 }
@@ -22362,12 +22902,12 @@ class Lookup {
         const preImageHash = bytes_Bytes.zero(hash_HASH_SIZE);
         const memoryReadResult = memory.loadInto(preImageHash.raw, hashAddress);
         if (memoryReadResult.isError) {
-            logger_logger.trace `LOOKUP(${serviceId}, ${preImageHash}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] LOOKUP(${serviceId}, ${preImageHash}) <- PANIC`;
             return PvmExecution.Panic;
         }
         // v
         const preImage = this.account.lookup(serviceId, preImageHash);
-        logger_logger.trace `LOOKUP(${serviceId}, ${preImageHash}) <- ${preImage?.toStringTruncated() ?? "<missing>"}...`;
+        logger_logger.trace `[${this.currentServiceId}] LOOKUP(${serviceId}, ${preImageHash}) <- ${preImage?.toStringTruncated() ?? "<missing>"}...`;
         const preImageLength = preImage === null ? numbers_tryAsU64(0) : numbers_tryAsU64(preImage.raw.length);
         const preimageBlobOffset = regs.get(10);
         const lengthToWrite = regs.get(11);
@@ -22464,20 +23004,20 @@ class Read {
         const chunk = value === null ? safe_alloc_uint8array_safeAllocUint8Array(0) : value.raw.subarray(Number(offset), Number(offset + blobLength));
         const memoryWriteResult = memory.storeFrom(destinationAddress, chunk);
         if (memoryWriteResult.isError) {
-            logger_logger.trace `READ(${serviceId}, ${rawKey}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] READ(${serviceId}, ${rawKey}) <- PANIC`;
             return PvmExecution.Panic;
         }
         if (value === null) {
-            logger_logger.trace `READ(${serviceId}, ${rawKey}) <- NONE`;
+            logger_logger.trace `[${this.currentServiceId}] READ(${serviceId}, ${rawKey}) <- NONE`;
             regs.set(read_IN_OUT_REG, HostCallResult.NONE);
             return;
         }
         if (chunk.length > 0) {
-            logger_logger.trace `READ(${serviceId}, ${rawKey}) <- ${bytes_BytesBlob.blobFrom(chunk).toStringTruncated()}`;
+            logger_logger.trace `[${this.currentServiceId}] READ(${serviceId}, ${rawKey}) <- ${bytes_BytesBlob.blobFrom(chunk).toStringTruncated()}`;
         }
         else {
             // just a query for length of stored data
-            logger_logger.trace `READ(${serviceId}, ${rawKey}) <- (${valueLength} ${valueLength === 1n ? "byte" : "bytes"})`;
+            logger_logger.trace `[${this.currentServiceId}] READ(${serviceId}, ${rawKey}) <- (${valueLength} ${valueLength === 1n ? "byte" : "bytes"})`;
         }
         regs.set(read_IN_OUT_REG, valueLength);
     }
@@ -22521,7 +23061,7 @@ class Write {
         const rawStorageKey = safe_alloc_uint8array_safeAllocUint8Array(storageKeyLengthClamped);
         const keyLoadingResult = memory.loadInto(rawStorageKey, storageKeyStartAddress);
         if (keyLoadingResult.isError) {
-            logger_logger.trace `WRITE() <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] WRITE() <- PANIC`;
             return PvmExecution.Panic;
         }
         // k
@@ -22531,14 +23071,14 @@ class Write {
         const valueLoadingResult = memory.loadInto(value, valueStart);
         // Note [MaSo] this is ok to return bcs if valueLength is 0, then this panic won't happen
         if (valueLoadingResult.isError) {
-            logger_logger.trace `WRITE(${storageKey}) <- PANIC`;
+            logger_logger.trace `[${this.currentServiceId}] WRITE(${storageKey}) <- PANIC`;
             return PvmExecution.Panic;
         }
         /** https://graypaper.fluffylabs.dev/#/9a08063/33af0133b201?v=0.6.6 */
         const maybeValue = valueLength === 0n ? null : bytes_BytesBlob.blobFrom(value);
         // a
         const result = this.account.write(storageKey, maybeValue);
-        logger_logger.trace `WRITE(${storageKey}, ${maybeValue?.toStringTruncated() ?? "remove"}) <- ${resultToString(result)}`;
+        logger_logger.trace `[${this.currentServiceId}] WRITE(${storageKey}, ${maybeValue?.toStringTruncated() ?? "remove"}) <- ${resultToString(result)}`;
         if (result.isError) {
             regs.set(write_IN_OUT_REG, HostCallResult.FULL);
             return;
@@ -22767,7 +23307,7 @@ class Accumulate {
             serviceId,
             argsLength: numbers_tryAsU32(transfers.length + operands.length),
         });
-        const result = await executor.run(invocationArgs, tryAsGas(gas));
+        const result = await executor.run(invocationArgs, gas_tryAsGas(gas));
         const [newState, checkpoint] = partialState.getStateUpdates();
         /**
          * PVM invocation returned and error so we return the checkpoint
@@ -22968,19 +23508,19 @@ class Accumulate {
         for (let serviceIndex = 0; serviceIndex < serviceIdsLength; serviceIndex += 1) {
             const serviceId = serviceIds[serviceIndex];
             const checkpoint = AccumulationStateUpdate.copyFrom(inputStateUpdate);
-            const promise = this.accumulateSingleService(serviceId, accumulateData.getTransfers(serviceId), accumulateData.getOperands(serviceId), accumulateData.getGasLimit(serviceId), slot, entropy, AccumulationStateUpdate.copyFrom(inputStateUpdate)).then(({ consumedGas, stateUpdate }) => ({
-                consumedGas,
-                stateUpdate: stateUpdate === null ? checkpoint : stateUpdate,
-            }));
+            const promise = this.accumulateSingleService(serviceId, accumulateData.getTransfers(serviceId), accumulateData.getOperands(serviceId), accumulateData.getGasLimit(serviceId), slot, entropy, AccumulationStateUpdate.copyFrom(inputStateUpdate)).then(({ consumedGas, stateUpdate }) => {
+                const resultEntry = [
+                    serviceId,
+                    {
+                        consumedGas,
+                        stateUpdate: stateUpdate === null ? checkpoint : stateUpdate,
+                    },
+                ];
+                return resultEntry;
+            });
             resultPromises[serviceIndex] = promise;
         }
-        return Promise.all(resultPromises).then((results) => {
-            const map = new Map();
-            for (let serviceIndex = 0; serviceIndex < serviceIdsLength; serviceIndex += 1) {
-                map.set(serviceIds[serviceIndex], results[serviceIndex]);
-            }
-            return map;
-        });
+        return Promise.all(resultPromises).then((results) => new Map(results));
     }
     /**
      * A method that updates `recentlyAccumulated`, `accumulationQueue` and `timeslot` in state
@@ -23069,9 +23609,10 @@ class Accumulate {
         const _gasCost = gasCost;
         assertEmpty(rest);
         const accumulated = accumulatableReports.subview(0, accumulatedReports);
-        const { yieldedRoot, services, transfers: _transfers, validatorsData, privilegedServices, authorizationQueues, ...stateUpdateRest } = state;
+        const { yieldedRoot, services, transfers, validatorsData, privilegedServices, authorizationQueues, ...stateUpdateRest } = state;
         assertEmpty(stateUpdateRest);
-        // yielded root is retrieved after each pvm invocation so we can ignore it here
+        // transfers and yielded root are retrieved after each pvm invocation so we can ignore it here
+        const _transfers = transfers;
         const _yieldedRoot = yieldedRoot;
         if (this.hasDuplicatedServiceIdCreated(services.created)) {
             accumulate_logger.trace `Duplicated Service creation detected. Block is invalid.`;
@@ -23170,7 +23711,7 @@ class DeferredTransfers {
             partiallyUpdatedState.updateServiceInfo(serviceId, newInfo);
             const partialState = new AccumulateExternalities(this.chainSpec, this.blake2b, partiallyUpdatedState, serviceId, serviceId, timeslot);
             const fetchExternalities = FetchExternalities.createForOnTransfer({ entropy, transfers }, this.chainSpec);
-            let consumedGas = tryAsGas(0);
+            let consumedGas = gas_tryAsGas(0);
             const hasTransfers = transfers.length > 0;
             const isCodeCorrect = code !== null && code.length <= W_C;
             if (!hasTransfers || !isCodeCorrect) {
@@ -23188,7 +23729,7 @@ class DeferredTransfers {
                 const executor = await PvmExecutor.createOnTransferExecutor(serviceId, code, { partialState, fetchExternalities }, this.pvm);
                 const args = encoder_Encoder.encodeObject(deferred_transfers_ARGS_CODEC, { timeslot, serviceId, transfersLength: numbers_tryAsU32(transfers.length) }, this.chainSpec);
                 const gas = transfers.reduce((acc, item) => acc + item.gas, 0n);
-                consumedGas = (await executor.run(args, tryAsGas(gas))).consumedGas;
+                consumedGas = (await executor.run(args, gas_tryAsGas(gas))).consumedGas;
             }
             transferStatistics.set(serviceId, { count: numbers_tryAsU32(transfers.length), gasUsed: tryAsServiceGas(consumedGas) });
             const [updatedState] = partialState.getStateUpdates();
@@ -25002,7 +25543,7 @@ async function createImporter(config) {
     const interpreter = config.workerParams.pvm;
     const blocks = db.getBlocksDb();
     const states = db.getStatesDb();
-    const hasher = new TransitionHasher(chainSpec, await keccakHasher, await blake2b);
+    const hasher = new TransitionHasher(await keccakHasher, await blake2b);
     const importer = new Importer(chainSpec, interpreter, hasher, main_logger, blocks, states);
     return {
         importer,