@typeberry/jam 0.4.0 → 0.4.1-9e565b9

package/index.js

@@ -24314,7 +24314,11 @@ var TestSuite;
 })(TestSuite || (TestSuite = {}));
 const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
 const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
-const DEFAULT_VERSION = 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 = 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;
@@ -24373,8 +24377,8 @@ class 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, }) {
@@ -24537,7 +24541,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.
@@ -31185,7 +31189,7 @@ function jip_chain_spec_parseBootnode(v) {
     if (name === "" || ip === "" || port === "") {
         throw new Error(`Invalid bootnode format, expected: <name>@<ip>:<port>, got: "${v}"`);
     }
-    const portNumber = Number.parseInt(port);
+    const portNumber = Number.parseInt(port, 10);
     if (!isU16(portNumber)) {
         throw new Error(`Invalid port number: "${port}"`);
     }
@@ -34210,11 +34214,32 @@ const ENTROPY_ENTRIES = 4;
 
 var 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";
 })(UpdatePreimageKind || (UpdatePreimageKind = {}));
 /**
@@ -34222,7 +34247,7 @@ var 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 {
@@ -35445,7 +35470,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() {
@@ -35456,7 +35480,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() {
@@ -35466,7 +35489,6 @@ class LeafNode {
     /**
      * Returns contained value hash.
      *
-     * @remark
      * Note that for embedded value this is going to be full 0-padded 32 bytes.
      */
     getValueHash() {
@@ -37588,11 +37610,9 @@ class JamConfig {
 
 /** Helper function to create most used hashes in the block */
 class hasher_TransitionHasher {
-    context;
     keccakHasher;
     blake2b;
-    constructor(context, keccakHasher, blake2b) {
-        this.context = context;
+    constructor(keccakHasher, blake2b) {
         this.keccakHasher = keccakHasher;
         this.blake2b = blake2b;
     }
@@ -39016,7 +39036,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 */
@@ -39053,12 +39077,7 @@ class PartiallyUpdatedState {
                 return new LookupHistoryItem(hash, updatedPreimage.length, tryAsLookupHistorySlots([currentTimeslot]));
             }
             case 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, tryAsLookupHistorySlots([...state.slots, currentTimeslot]));
+                return null;
             }
             case UpdatePreimageKind.UpdateOrAdd: {
                 return action.item;
@@ -39151,7 +39170,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
 
@@ -39434,7 +39453,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;
@@ -39453,7 +39472,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;
@@ -39767,49 +39786,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);
 };
@@ -39823,25 +39803,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. */
@@ -39869,17 +39849,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
@@ -39901,7 +39881,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);
     }
@@ -39980,9 +39960,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 */
@@ -40025,7 +40005,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
 
@@ -40063,7 +40043,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);
         }
@@ -40127,8 +40107,8 @@ class ReadablePage extends MemoryPage {
     }
     loadInto(result, startIndex, length) {
         const endIndex = startIndex + length;
-        if (endIndex > PAGE_SIZE) {
-            return result_Result.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE), () => `Page fault: read beyond page boundary at ${this.start + PAGE_SIZE}`);
+        if (endIndex > memory_consts_PAGE_SIZE) {
+            return result_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`.
@@ -40161,8 +40141,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);
@@ -40170,8 +40150,8 @@ class WriteablePage extends MemoryPage {
     }
     loadInto(result, startIndex, length) {
         const endIndex = startIndex + length;
-        if (endIndex > PAGE_SIZE) {
-            return result_Result.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE), () => `Page fault: read beyond page boundary at ${this.start + PAGE_SIZE}`);
+        if (endIndex > memory_consts_PAGE_SIZE) {
+            return result_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`.
@@ -40180,16 +40160,16 @@ class WriteablePage extends MemoryPage {
         return result_Result.ok(result_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_Result.ok(result_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);
@@ -40240,10 +40220,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);
@@ -40270,8 +40250,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);
@@ -40320,8 +40300,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);
@@ -40348,7 +40328,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);
@@ -40403,8 +40383,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);
@@ -40413,7 +40393,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);
         }
@@ -40431,8 +40411,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);
@@ -40441,7 +40421,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);
         }
@@ -40453,8 +40433,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);
@@ -40645,27 +40625,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);
     }
@@ -41680,6 +41660,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
 
 
@@ -42256,7 +42275,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 = pvm_interpreter_result_Result.FAULT_ACCESS;
@@ -42272,7 +42291,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 = pvm_interpreter_result_Result.FAULT_ACCESS;
@@ -42694,7 +42713,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;
         }
@@ -42703,7 +42722,7 @@ class StoreOps {
         }
         else {
             this.instructionResult.status = pvm_interpreter_result_Result.FAULT;
-            this.instructionResult.exitParam = getStartPageIndex(tryAsMemoryIndex(storeResult.error.address));
+            this.instructionResult.exitParam = getStartPageIndex(memory_index_tryAsMemoryIndex(storeResult.error.address));
         }
     }
 }
@@ -43502,11 +43521,11 @@ class ProgramDecoder {
 
 
 const interpreter_logger = 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;
@@ -43640,8 +43659,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;
@@ -43736,12 +43755,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 = {
@@ -44195,12 +44290,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));
@@ -44305,7 +44400,7 @@ class InterpreterInstanceManager {
         const instances = [];
         switch (interpreter) {
             case PvmBackend.BuiltIn:
-                instances.push(new Interpreter({
+                instances.push(new interpreter_Interpreter({
                     useSbrkGas: false,
                 }));
                 break;
@@ -44479,10 +44574,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;
@@ -44706,7 +44801,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) {
@@ -44719,7 +44814,7 @@ class AccumulateExternalities {
             return result_Result.ok(result_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) {
@@ -44735,14 +44830,14 @@ class AccumulateExternalities {
             }
             return result_Result.error(ForgetPreimageError.NotExpired, () => `Preimage not expired: y=${y}, timeslot=${t}, period=${this.chainSpec.preimageExpungePeriod}`);
         }
-        // https://graypaper.fluffylabs.dev/#/9a08063/38c80138c801?v=0.6.6
+        // 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, tryAsLookupHistorySlots([s.data[0], t])),
             }));
             return result_Result.ok(result_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) {
@@ -45578,13 +45673,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;
@@ -45904,12 +45997,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;
@@ -45927,28 +46020,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 }]) {
@@ -46093,7 +46193,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) {
@@ -46108,18 +46208,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;
         }
         debug_assertNever(e);
@@ -46190,7 +46290,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);
@@ -46203,26 +46303,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;
         }
@@ -46252,7 +46352,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);
     }
@@ -46284,7 +46384,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;
     }
 }
@@ -46324,18 +46424,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);
         }
     }
@@ -46376,29 +46476,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 ${result_resultToString(result)}`;
+            logger_logger.trace `[${this.currentServiceId}] EJECT(${serviceId}, ${previousCodeHash}) <- WHO ${result_resultToString(result)}`;
             regs.set(eject_IN_OUT_REG, HostCallResult.WHO);
         }
         else if (e === EjectError.InvalidPreimage) {
-            logger_logger.trace `EJECT(${serviceId}, ${previousCodeHash}) <- HUH ${result_resultToString(result)}`;
+            logger_logger.trace `[${this.currentServiceId}] EJECT(${serviceId}, ${previousCodeHash}) <- HUH ${result_resultToString(result)}`;
             regs.set(eject_IN_OUT_REG, HostCallResult.HUH);
         }
         else {
@@ -46417,9 +46517,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;
@@ -46440,11 +46540,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}) <- ${result_resultToString(result)}`;
+        logger_logger.trace `[${this.currentServiceId}] FORGET(${hash}, ${length}) <- ${result_resultToString(result)}`;
         if (result.isOk) {
             regs.set(forget_IN_OUT_REG, HostCallResult.OK);
         }
@@ -46501,11 +46601,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}) <- ${result_resultToString(assignedId)}`;
+        logger_logger.trace `[${this.currentServiceId}] NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}, ${requestedServiceId}) <- ${result_resultToString(assignedId)}`;
         if (assignedId.isOk) {
             regs.set(new_IN_OUT_REG, numbers_tryAsU64(assignedId.ok));
             return;
@@ -46565,11 +46665,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()}) <- ${result_resultToString(result)}`;
+        logger_logger.trace `[${this.currentServiceId}] PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- ${result_resultToString(result)}`;
         if (result.isOk) {
             regs.set(provide_IN_OUT_REG, HostCallResult.OK);
             return;
@@ -46625,35 +46725,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;
@@ -46694,11 +46794,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}) <- ${result_resultToString(result)}`;
+        logger_logger.trace `[${this.currentServiceId}] SOLICIT(${hash}, ${length}) <- ${result_resultToString(result)}`;
         if (result.isOk) {
             regs.set(solicit_IN_OUT_REG, HostCallResult.OK);
             return;
@@ -46756,7 +46856,7 @@ class Transfer {
      */
     basicGasCost = Compatibility.isGreaterOrEqual(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;
@@ -46775,16 +46875,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}) <- ${result_resultToString(transferResult)}`;
+        logger_logger.trace `[${this.currentServiceId}] TRANSFER(${destination}, ${amount}, ${transferGasFee}, ${memo}) <- ${result_resultToString(transferResult)}`;
         // All good!
         if (transferResult.isOk) {
             if (Compatibility.isGreaterOrEqual(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;
                 }
@@ -46845,11 +46945,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);
     }
 }
@@ -46883,11 +46983,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);
     }
 }
@@ -46930,10 +47030,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);
     }
@@ -47083,7 +47183,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);
     }
 }
@@ -47124,12 +47224,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);
@@ -47226,20 +47326,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);
     }
@@ -47283,7 +47383,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
@@ -47293,14 +47393,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"}) <- ${result_resultToString(result)}`;
+        logger_logger.trace `[${this.currentServiceId}] WRITE(${storageKey}, ${maybeValue?.toStringTruncated() ?? "remove"}) <- ${result_resultToString(result)}`;
         if (result.isError) {
             regs.set(write_IN_OUT_REG, HostCallResult.FULL);
             return;
@@ -47529,7 +47629,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
@@ -47730,19 +47830,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
@@ -47831,9 +47931,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.`;
@@ -47932,7 +48033,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) {
@@ -47950,7 +48051,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();
@@ -49764,7 +49865,7 @@ async function createImporter(config) {
     const interpreter = config.workerParams.pvm;
     const blocks = db.getBlocksDb();
     const states = db.getStatesDb();
-    const hasher = new hasher_TransitionHasher(chainSpec, await keccakHasher, await blake2b);
+    const hasher = new hasher_TransitionHasher(await keccakHasher, await blake2b);
     const importer = new Importer(chainSpec, interpreter, hasher, main_logger, blocks, states);
     return {
         importer,
@@ -52421,7 +52522,7 @@ function initializeExtensions(api) {
 }
 
 ;// CONCATENATED MODULE: ./packages/jam/node/package.json
-const package_namespaceObject = {"rE":"0.4.0"};
+const package_namespaceObject = {"rE":"0.4.1"};
 ;// CONCATENATED MODULE: ./packages/workers/block-generator/generator.ts
 
 
@@ -52488,7 +52589,7 @@ class generator_Generator {
         // select validator for block
         const validatorId = tryAsValidatorIndex(newTimeSlot % 6);
         // retriev data from previous block
-        const hasher = new TransitionHasher(this.chainSpec, this.keccakHasher, this.blake2b);
+        const hasher = new TransitionHasher(this.keccakHasher, this.blake2b);
         const parentHeaderHash = this.lastHeaderHash;
         const stateRoot = this.states.getStateRoot(this.lastState);
         // create extrinsic
@@ -53055,7 +53156,7 @@ function readJsonBlock(file, chainSpec) {
 var minimist = __nccwpck_require__(8595);
 var minimist_default = /*#__PURE__*/__nccwpck_require__.n(minimist);
 ;// CONCATENATED MODULE: ./bin/jam/package.json
-const jam_package_namespaceObject = {"rE":"0.4.0"};
+const jam_package_namespaceObject = {"rE":"0.4.1"};
 ;// CONCATENATED MODULE: ./bin/jam/args.ts