@typeberry/convert 0.2.0-5746fdc → 0.2.0-79dc2d4

package/index.js

@@ -4245,44 +4245,40 @@ var compatibility_GpVersion;
     GpVersion["V0_6_7"] = "0.6.7";
     GpVersion["V0_7_0"] = "0.7.0";
     GpVersion["V0_7_1"] = "0.7.1";
-    GpVersion["V0_7_2"] = "0.7.2-preview";
+    GpVersion["V0_7_2"] = "0.7.2";
 })(compatibility_GpVersion || (compatibility_GpVersion = {}));
-var TestSuite;
+var compatibility_TestSuite;
 (function (TestSuite) {
     TestSuite["W3F_DAVXY"] = "w3f-davxy";
     TestSuite["JAMDUNA"] = "jamduna";
-})(TestSuite || (TestSuite = {}));
-const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
-const DEFAULT_VERSION = compatibility_GpVersion.V0_7_1;
+})(compatibility_TestSuite || (compatibility_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 = compatibility_TestSuite.W3F_DAVXY;
+const DEFAULT_VERSION = compatibility_GpVersion.V0_7_2;
 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;
-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];
 function parseCurrentVersion(env) {
     if (env === undefined) {
         return undefined;
     }
-    switch (env) {
-        case compatibility_GpVersion.V0_6_7:
-        case compatibility_GpVersion.V0_7_0:
-        case compatibility_GpVersion.V0_7_1:
-        case compatibility_GpVersion.V0_7_2:
-            return env;
-        default:
-            throw new Error(`Configured environment variable GP_VERSION is unknown: '${env}'. Use one of: ${ALL_VERSIONS_IN_ORDER}`);
+    for (const v of Object.values(compatibility_GpVersion)) {
+        if (env === v) {
+            return v;
+        }
     }
+    throw new Error(`Configured environment variable GP_VERSION is unknown: '${env}'. Use one of: ${ALL_VERSIONS_IN_ORDER}`);
 }
 function parseCurrentSuite(env) {
     if (env === undefined) {
         return undefined;
     }
-    switch (env) {
-        case TestSuite.W3F_DAVXY:
-        case TestSuite.JAMDUNA:
-            return env;
-        default:
-            throw new Error(`Configured environment variable TEST_SUITE is unknown: '${env}'. Use one of: ${Object.values(TestSuite)}`);
+    for (const s of Object.values(compatibility_TestSuite)) {
+        if (env === s) {
+            return s;
+        }
     }
+    throw new Error(`Configured environment variable TEST_SUITE is unknown: '${env}'. Use one of: ${Object.values(compatibility_TestSuite)}`);
 }
 class compatibility_Compatibility {
     static override(version) {
@@ -4443,6 +4439,13 @@ class WithDebug {
         return debug_inspect(this);
     }
 }
+function lazyInspect(obj) {
+    return {
+        toString() {
+            return debug_inspect(obj);
+        },
+    };
+}
 
 ;// CONCATENATED MODULE: ./packages/core/utils/dev.ts
 const dev_env = typeof process === "undefined" ? {} : process.env;
@@ -5227,7 +5230,7 @@ const asTypedNumber = (v) => v;
 const MAX_VALUE_U8 = 0xff;
 const MAX_VALUE_U16 = 0xffff;
 const MAX_VALUE_U32 = 0xffff_ffff;
-const MAX_VALUE_U64 = 0xffffffffffffffffn;
+const numbers_MAX_VALUE_U64 = 0xffffffffffffffffn;
 /** Attempt to cast an input number into U8. */
 const tryAsU8 = (v) => {
     debug_check `${isU8(v)} input must have one-byte representation, got ${v}`;
@@ -5256,7 +5259,7 @@ const numbers_tryAsU64 = (x) => {
     return asTypedNumber(v);
 };
 /** Check if given number is a valid U64 number. */
-const numbers_isU64 = (v) => (v & MAX_VALUE_U64) === v;
+const numbers_isU64 = (v) => (v & numbers_MAX_VALUE_U64) === v;
 /** Collate two U32 parts into one U64. */
 const u64FromParts = ({ lower, upper }) => {
     const val = (BigInt(upper) << 32n) + BigInt(lower);
@@ -10785,7 +10788,7 @@ const DEV_CONFIG = "dev";
 const DEFAULT_CONFIG = "default";
 const NODE_DEFAULTS = {
     name: isBrowser() ? "browser" : external_node_os_default().hostname(),
-    config: DEFAULT_CONFIG,
+    config: [DEFAULT_CONFIG],
     pvm: pvm_backend_PvmBackend.BuiltIn,
 };
 /** Chain spec chooser. */
@@ -10838,25 +10841,137 @@ class NodeConfiguration {
         this.authorship = authorship;
     }
 }
-function loadConfig(configPath) {
-    if (configPath === DEFAULT_CONFIG) {
-        node_config_logger.log `🔧 Loading DEFAULT config`;
-        return parseFromJson(configs.default, NodeConfiguration.fromJson);
-    }
-    if (configPath === DEV_CONFIG) {
-        node_config_logger.log `🔧 Loading DEV config`;
-        return parseFromJson(configs.dev, NodeConfiguration.fromJson);
+function loadConfig(config, withRelPath) {
+    node_config_logger.log `🔧 Loading config`;
+    let mergedJson = {};
+    for (const entry of config) {
+        node_config_logger.log `🔧 Applying '${entry}'`;
+        if (entry === DEV_CONFIG) {
+            mergedJson = structuredClone(configs.dev); // clone to avoid mutating the original config. not doing a merge since dev and default should theoretically replace all properties.
+            continue;
+        }
+        if (entry === DEFAULT_CONFIG) {
+            mergedJson = structuredClone(configs.default);
+            continue;
+        }
+        // try to parse as JSON
+        try {
+            const parsed = JSON.parse(entry);
+            deepMerge(mergedJson, parsed);
+            continue;
+        }
+        catch { }
+        // if not, try to load as file
+        if (entry.indexOf("=") === -1 && entry.endsWith(".json")) {
+            try {
+                const configFile = fs.readFileSync(withRelPath(entry), "utf8");
+                const parsed = JSON.parse(configFile);
+                deepMerge(mergedJson, parsed);
+            }
+            catch (e) {
+                throw new Error(`Unable to load config from ${entry}: ${e}`);
+            }
+        }
+        else {
+            // finally try to process as a pseudo-jq query
+            try {
+                processQuery(mergedJson, entry, withRelPath);
+            }
+            catch (e) {
+                throw new Error(`Error while processing '${entry}': ${e}`);
+            }
+        }
     }
     try {
-        node_config_logger.log `🔧 Loading config from ${configPath}`;
-        const configFile = fs.readFileSync(configPath, "utf8");
-        const parsed = JSON.parse(configFile);
-        return parseFromJson(parsed, NodeConfiguration.fromJson);
+        const parsed = parseFromJson(mergedJson, NodeConfiguration.fromJson);
+        node_config_logger.log `🔧 Config ready`;
+        return parsed;
     }
     catch (e) {
-        throw new Error(`Unable to load config file from ${configPath}: ${e}`);
+        throw new Error(`Unable to parse config: ${e}`);
     }
 }
+function deepMerge(target, source) {
+    if (!isJsonObject(source)) {
+        throw new Error(`Expected object, got ${source}`);
+    }
+    for (const key in source) {
+        if (isJsonObject(source[key])) {
+            if (!isJsonObject(target[key])) {
+                target[key] = {};
+            }
+            deepMerge(target[key], source[key]);
+        }
+        else {
+            target[key] = source[key];
+        }
+    }
+}
+/**
+ * Caution: updates input directly.
+ * Processes a pseudo-jq query. Syntax:
+ * .path.to.value = { ... } - updates value with the specified object by replacement
+ * .path.to.value += { ... } - updates value with the specified object by merging
+ * .path.to.value = file.json - updates value with the contents of file.json
+ * .path.to.value += file.json - merges the contents of file.json onto value
+ */
+function processQuery(input, query, withRelPath) {
+    const queryParts = query.split("=");
+    if (queryParts.length === 2) {
+        let [path, value] = queryParts.map((part) => part.trim());
+        let merge = false;
+        // detect += syntax
+        if (path.endsWith("+")) {
+            merge = true;
+            path = path.slice(0, -1);
+        }
+        let parsedValue;
+        if (value.endsWith(".json")) {
+            try {
+                const configFile = fs.readFileSync(withRelPath(value), "utf8");
+                const parsed = JSON.parse(configFile);
+                parsedValue = parsed;
+            }
+            catch (e) {
+                throw new Error(`Unable to load config from ${value}: ${e}`);
+            }
+        }
+        else {
+            try {
+                parsedValue = JSON.parse(value);
+            }
+            catch (e) {
+                throw new Error(`Unrecognized syntax '${value}': ${e}`);
+            }
+        }
+        let pathParts = path.split(".");
+        // allow leading dot in path
+        if (pathParts[0] === "") {
+            pathParts = pathParts.slice(1);
+        }
+        let target = input;
+        for (let i = 0; i < pathParts.length; i++) {
+            const part = pathParts[i];
+            if (!isJsonObject(target[part])) {
+                target[part] = {};
+            }
+            if (i === pathParts.length - 1) {
+                if (merge) {
+                    deepMerge(target[part], parsedValue);
+                }
+                else {
+                    target[part] = parsedValue;
+                }
+                return;
+            }
+            target = target[part];
+        }
+    }
+    throw new Error("Unrecognized syntax.");
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 ;// CONCATENATED MODULE: ./packages/jam/config-node/index.ts
 
@@ -12144,7 +12259,7 @@ class service_LookupHistoryItem {
 
 
 
-const codecServiceId = compatibility_Compatibility.isSuite(TestSuite.W3F_DAVXY) || compatibility_Compatibility.isSuite(TestSuite.JAMDUNA, compatibility_GpVersion.V0_6_7)
+const codecServiceId = compatibility_Compatibility.isSuite(compatibility_TestSuite.W3F_DAVXY) || compatibility_Compatibility.isSuite(compatibility_TestSuite.JAMDUNA, compatibility_GpVersion.V0_6_7)
     ? descriptors_codec.u32.asOpaque()
     : descriptors_codec.varU32.convert((s) => numbers_tryAsU32(s), (i) => common_tryAsServiceId(i));
 /**
@@ -12483,26 +12598,6 @@ class InMemoryStateView {
 
 
 
-/** Dictionary entry of services that auto-accumulate every block. */
-class privileged_services_AutoAccumulate {
-    service;
-    gasLimit;
-    static Codec = descriptors_codec.Class(privileged_services_AutoAccumulate, {
-        service: descriptors_codec.u32.asOpaque(),
-        gasLimit: descriptors_codec.u64.asOpaque(),
-    });
-    static create({ service, gasLimit }) {
-        return new privileged_services_AutoAccumulate(service, gasLimit);
-    }
-    constructor(
-    /** Service id that auto-accumulates. */
-    service, 
-    /** Gas limit for auto-accumulation. */
-    gasLimit) {
-        this.service = service;
-        this.gasLimit = gasLimit;
-    }
-}
 /**
  * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
  */
@@ -12520,7 +12615,9 @@ class privileged_services_PrivilegedServices {
         registrar: compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_1)
             ? descriptors_codec.u32.asOpaque()
             : ignoreValueWithDefault(common_tryAsServiceId(2 ** 32 - 1)),
-        autoAccumulateServices: readonlyArray(descriptors_codec.sequenceVarLen(privileged_services_AutoAccumulate.Codec)),
+        autoAccumulateServices: descriptors_codec.dictionary(descriptors_codec.u32.asOpaque(), descriptors_codec.u64.asOpaque(), {
+            sortKeys: (a, b) => a - b,
+        }),
     });
     static create(a) {
         return new privileged_services_PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
@@ -13153,7 +13250,7 @@ class in_memory_state_InMemoryState extends WithDebug {
                 assigners: common_tryAsPerCore(new Array(spec.coresCount).fill(common_tryAsServiceId(0)), spec),
                 delegator: common_tryAsServiceId(0),
                 registrar: common_tryAsServiceId(math_consts_MAX_VALUE),
-                autoAccumulateServices: [],
+                autoAccumulateServices: new Map(),
             }),
             accumulationOutputLog: sorted_array_SortedArray.fromArray(accumulation_output_accumulationOutputComparator, []),
             services: new Map(),
@@ -13625,10 +13722,7 @@ const fullStateDumpFromJson = (spec) => json.object({
         chi_a: json.array("number"),
         chi_v: "number",
         chi_r: json.optional("number"),
-        chi_g: json.nullable(json.array({
-            service: "number",
-            gasLimit: json.fromNumber((v) => common_tryAsServiceGas(v)),
-        })),
+        chi_g: json.nullable(json.map("number", json.fromNumber((v) => common_tryAsServiceGas(v)))),
     },
     pi: JsonStatisticsData.fromJson,
     omega: json.array(json.array(notYetAccumulatedFromJson)),
@@ -13669,7 +13763,7 @@ const fullStateDumpFromJson = (spec) => json.object({
             assigners: chi.chi_a,
             delegator: chi.chi_v,
             registrar: chi.chi_r ?? common_tryAsServiceId(2 ** 32 - 1),
-            autoAccumulateServices: chi.chi_g ?? [],
+            autoAccumulateServices: chi.chi_g ?? new Map(),
         }),
         statistics: JsonStatisticsData.toStatisticsData(spec, pi),
         accumulationQueue: omega,
@@ -17700,7 +17794,7 @@ class accumulate_externalities_AccumulateExternalities {
     updatedState;
     currentServiceId;
     currentTimeslot;
-    checkpointedState = null;
+    checkpointedState;
     /** `x_i`: next service id we are going to create. */
     nextNewServiceId;
     constructor(chainSpec, blake2b, updatedState, 
@@ -17711,13 +17805,14 @@ class accumulate_externalities_AccumulateExternalities {
         this.updatedState = updatedState;
         this.currentServiceId = currentServiceId;
         this.currentTimeslot = currentTimeslot;
+        this.checkpointedState = AccumulationStateUpdate.copyFrom(updatedState.stateUpdate);
         this.nextNewServiceId = this.getNextAvailableServiceId(nextNewServiceIdCandidate);
         const service = this.updatedState.getServiceInfo(this.currentServiceId);
         if (service === null) {
             throw new Error(`Invalid state initialization. Service info missing for ${this.currentServiceId}.`);
         }
     }
-    /** Return the underlying state update and checkpointed state (if any). */
+    /** Return the underlying state update and checkpointed state. */
     getStateUpdates() {
         return [this.updatedState.stateUpdate, this.checkpointedState];
     }
@@ -18084,7 +18179,7 @@ class accumulate_externalities_AccumulateExternalities {
                 assigners: authorizers,
                 delegator: delegator,
                 registrar: registrar ?? tryAsServiceId(0),
-                autoAccumulateServices: autoAccumulate.map(([service, gasLimit]) => AutoAccumulate.create({ service, gasLimit })),
+                autoAccumulateServices: autoAccumulate,
             });
             return Result.ok(OK);
         }
@@ -18108,9 +18203,7 @@ class accumulate_externalities_AccumulateExternalities {
             isAlreadyChanged: currentAssigner !== original.assigners[index],
         }));
         const newManager = isManager ? manager : current.manager;
-        const newAutoAccumulateServices = isManager
-            ? autoAccumulate.map(([service, gasLimit]) => AutoAccumulate.create({ service, gasLimit }))
-            : current.autoAccumulateServices;
+        const newAutoAccumulateServices = isManager ? autoAccumulate : current.autoAccumulateServices;
         // finally update the privileges
         this.updatedState.stateUpdate.privilegedServices = PrivilegedServices.create({
             manager: newManager,
@@ -18254,7 +18347,7 @@ function bumpServiceId(serviceId) {
  */
 class operand_Operand extends WithDebug {
     // JamDuna uses a different order of operands.
-    static Codec = descriptors_codec.Class(operand_Operand, compatibility_Compatibility.isSuite(TestSuite.JAMDUNA)
+    static Codec = descriptors_codec.Class(operand_Operand, compatibility_Compatibility.isSuite(compatibility_TestSuite.JAMDUNA)
         ? {
             hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
             exportsRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
@@ -18738,17 +18831,16 @@ class fetch_externalities_FetchExternalities {
 
 
 
+
 class AccumulateDataItem {
     operands;
     reportsLength;
-    gasCost;
-    constructor(operands, reportsLength, gasCost) {
+    constructor(operands, reportsLength) {
         this.operands = operands;
         this.reportsLength = reportsLength;
-        this.gasCost = gasCost;
     }
     static empty() {
-        return new AccumulateDataItem([], tryAsU32(0), tryAsServiceGas(0n));
+        return new AccumulateDataItem([], tryAsU32(0));
     }
 }
 /**
@@ -18758,23 +18850,43 @@ class AccumulateDataItem {
  * - gas cost and reports length for each service (statistics)
  */
 class accumulate_data_AccumulateData {
+    autoAccumulateServicesByServiceId;
     reportsDataByServiceId;
     transfersByServiceId;
-    autoAccumulateServicesByServiceId;
     serviceIds;
-    constructor(reports, transfers, autoAccumulateServices) {
-        const { autoAccumulateServicesByServiceId, serviceIds: serviceIdsFromAutoAccumulate } = this.transformAutoAccumulateServices(autoAccumulateServices);
+    gasLimitByServiceId;
+    constructor(reports, transfers, autoAccumulateServicesByServiceId) {
         this.autoAccumulateServicesByServiceId = autoAccumulateServicesByServiceId;
-        const { reportsDataByServiceId, serviceIds: serviceIdsFromReports } = this.transformReports(reports);
+        const serviceIdsFromAutoAccumulate = new Set(autoAccumulateServicesByServiceId.keys());
+        const { reportsDataByServiceId, serviceIds: serviceIdsFromReports, gasLimitByServiceId: reportsGasLimitByServiceId, } = this.transformReports(reports);
         this.reportsDataByServiceId = reportsDataByServiceId;
-        const { transfersByServiceId, serviceIds: serviceIdsFromTransfers } = this.transformTransfers(transfers);
+        const { transfersByServiceId, serviceIds: serviceIdsFromTransfers, gasLimitByServiceId: transfersGasLimitByServiceId, } = this.transformTransfers(transfers);
         this.transfersByServiceId = transfersByServiceId;
         /**
          * Merge service ids from reports, auto-accumulate services and transfers.
          *
-         * https://graypaper.fluffylabs.dev/#/68eaa1f/175f01175f01?v=0.6.4
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/173803174b03?v=0.7.2
          */
         this.serviceIds = this.mergeServiceIds(serviceIdsFromReports, serviceIdsFromAutoAccumulate, serviceIdsFromTransfers);
+        /**
+         * Merge gas limits from reports, auto-accumulate services and transfers.
+         *
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/182001183701?v=0.7.2
+         */
+        this.gasLimitByServiceId = this.mergeGasLimitByServiceId(this.serviceIds, autoAccumulateServicesByServiceId, reportsGasLimitByServiceId, transfersGasLimitByServiceId);
+    }
+    /**
+     * Calculate the gas limit implied by the selected deferred-transfers, work-reports and gas-privileges.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/182001183701?v=0.7.2
+     */
+    mergeGasLimitByServiceId(serviceIds, ...gasLimitByServiceIdMaps) {
+        const gasByServiceId = new Map();
+        for (const serviceId of serviceIds) {
+            const { overflow, value } = sumU64(...gasLimitByServiceIdMaps.map((map) => map.get(serviceId) ?? tryAsServiceGas(0)));
+            gasByServiceId.set(serviceId, tryAsServiceGas(overflow ? MAX_VALUE_U64 : value));
+        }
+        return gasByServiceId;
     }
     /** Merge two sets of service ids */
     mergeServiceIds(...sources) {
@@ -18786,50 +18898,60 @@ class accumulate_data_AccumulateData {
         }
         return Array.from(merged);
     }
+    /**
+     * Transform the list of pending transfers into:
+     * - map: transfers by service id
+     * - map: gas limit by service id
+     * - set: service ids
+     */
     transformTransfers(transfersToTransform) {
         const transfersByServiceId = new Map();
         const serviceIds = new Set();
+        const gasLimitByServiceId = new Map();
         for (const transfer of transfersToTransform) {
             const serviceId = transfer.destination;
             const transfers = transfersByServiceId.get(serviceId) ?? [];
+            const gas = gasLimitByServiceId.get(serviceId) ?? tryAsServiceGas(0n);
+            const { value, overflow } = sumU64(gas, transfer.gas);
+            gasLimitByServiceId.set(serviceId, tryAsServiceGas(overflow ? MAX_VALUE_U64 : value));
             transfers.push(transfer);
             transfersByServiceId.set(serviceId, transfers);
             serviceIds.add(serviceId);
         }
-        return { transfersByServiceId, serviceIds };
-    }
-    /** Transform the list of auto-accumulate services into a map by service id. */
-    transformAutoAccumulateServices(autoAccumulateServices) {
-        const serviceIds = new Set();
-        const autoAccumulateServicesByServiceId = new Map();
-        for (const autoAccumulate of autoAccumulateServices) {
-            autoAccumulateServicesByServiceId.set(autoAccumulate.service, autoAccumulate);
-            serviceIds.add(autoAccumulate.service);
-        }
-        return { autoAccumulateServicesByServiceId, serviceIds };
+        return { transfersByServiceId, serviceIds, gasLimitByServiceId };
     }
     /**
      * A function that transform reports into a list of operands and data needed for statistics (gas cost and reports length).
      */
+    /**
+     * Transform the list of reports into:
+     * - map: AccumulateDataItem by service id
+     * - map: gas limit by service id
+     * - set: service ids
+     */
     transformReports(reports) {
         const reportsDataByServiceId = new Map();
+        const gasLimitByServiceId = new Map();
         const serviceIds = new Set();
         for (const report of reports) {
             for (const result of report.results) {
                 const serviceId = result.serviceId;
                 serviceIds.add(serviceId);
                 const item = reportsDataByServiceId.get(serviceId) ?? AccumulateDataItem.empty();
+                const gas = gasLimitByServiceId.get(serviceId) ?? tryAsServiceGas(0n);
+                const { value, overflow } = sumU64(gas, result.gas);
+                const newGas = tryAsServiceGas(overflow ? MAX_VALUE_U64 : value);
+                gasLimitByServiceId.set(serviceId, newGas);
                 /**
                  * We count the report results and gas cost for each service to update service statistics.
                  *
-                 * https://graypaper.fluffylabs.dev/#/68eaa1f/171e04174a04?v=0.6.4
+                 * https://graypaper.fluffylabs.dev/#/ab2cdbd/180504182604?v=0.7.2
                  */
                 item.reportsLength = tryAsU32(item.reportsLength + 1);
-                item.gasCost = tryAsServiceGas(item.gasCost + result.gas);
                 /**
                  * Transform report into an operand
                  *
-                 * https://graypaper.fluffylabs.dev/#/68eaa1f/17bf02176f03?v=0.6.4
+                 * https://graypaper.fluffylabs.dev/#/ab2cdbd/185901181402?v=0.7.2
                  */
                 item.operands.push(Operand.new({
                     gas: result.gas, // g
@@ -18843,19 +18965,7 @@ class accumulate_data_AccumulateData {
                 reportsDataByServiceId.set(serviceId, item);
             }
         }
-        /**
-         * Add initial gas cost - it is `U(f_s, 0)` from this formula:
-         *
-         * https://graypaper.fluffylabs.dev/#/68eaa1f/17b00217b002?v=0.6.4
-         */
-        for (const serviceId of serviceIds) {
-            const item = reportsDataByServiceId.get(serviceId) ?? null;
-            const autoAccumulateService = this.autoAccumulateServicesByServiceId.get(serviceId) ?? null;
-            if (item !== null && autoAccumulateService !== null) {
-                item.gasCost = tryAsServiceGas(item.gasCost + autoAccumulateService.gasLimit);
-            }
-        }
-        return { reportsDataByServiceId, serviceIds };
+        return { reportsDataByServiceId, serviceIds, gasLimitByServiceId };
     }
     /** Returns the list of operands for a given service id */
     getOperands(serviceId) {
@@ -18869,14 +18979,14 @@ class accumulate_data_AccumulateData {
     getReportsLength(serviceId) {
         return this.reportsDataByServiceId.get(serviceId)?.reportsLength ?? tryAsU32(0);
     }
-    /** Returns the gas cost for a given service id */
-    getGasCost(serviceId) {
-        return this.reportsDataByServiceId.get(serviceId)?.gasCost ?? tryAsServiceGas(0n);
+    /** Returns the gas limit for a given service id */
+    getGasLimit(serviceId) {
+        return this.gasLimitByServiceId.get(serviceId) ?? tryAsServiceGas(0n);
     }
     /**
      * Returns a list of service ids that should be accumulated.
      *
-     * https://graypaper.fluffylabs.dev/#/68eaa1f/175f01175f01?v=0.6.4
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/173803174a03?v=0.7.2
      */
     getServiceIds() {
         return this.serviceIds;
@@ -23252,7 +23362,7 @@ class Bless {
          * `z`: array of key-value pairs serviceId -> gas that auto-accumulate every block
          * https://graypaper.fluffylabs.dev/#/7e6ff6a/368100368100?v=0.6.7
          */
-        const autoAccumulateEntries = [];
+        const autoAccumulate = new Map();
         const result = safe_alloc_uint8array_safeAllocUint8Array(tryAsExactBytes(serviceIdAndGasCodec.sizeHint));
         const decoder = decoder_Decoder.fromBlob(result);
         let memIndex = sourceStart;
@@ -23265,7 +23375,7 @@ class Bless {
                 return host_call_handler_PvmExecution.Panic;
             }
             const { serviceId, gas } = decoder.object(serviceIdAndGasCodec);
-            autoAccumulateEntries.push([serviceId, gas]);
+            autoAccumulate.set(serviceId, gas);
             // we allow the index to go beyond `MEMORY_SIZE` (i.e. 2**32) and have the next `loadInto` fail with page fault.
             memIndex = numbers_tryAsU64(memIndex + numbers_tryAsU64(decoder.bytesRead()));
         }
@@ -23274,26 +23384,26 @@ class Bless {
         const authorizersDecoder = decoder_Decoder.fromBlob(res);
         const memoryReadResult = memory.loadInto(res, authorization);
         if (memoryReadResult.isError) {
-            logger_logger.trace `BLESS(${manager}, ${delegator}, ${registrar}, ${autoAccumulateEntries}) <- PANIC`;
+            logger_logger.trace `BLESS(${manager}, ${delegator}, ${registrar}, ${lazyInspect(autoAccumulate)}) <- PANIC`;
             return host_call_handler_PvmExecution.Panic;
         }
         // `a`
         const authorizers = common_tryAsPerCore(authorizersDecoder.sequenceFixLen(descriptors_codec.u32.asOpaque(), this.chainSpec.coresCount), this.chainSpec);
-        const updateResult = this.partialState.updatePrivilegedServices(manager, authorizers, delegator, registrar, autoAccumulateEntries);
+        const updateResult = this.partialState.updatePrivilegedServices(manager, authorizers, delegator, registrar, autoAccumulate);
         if (updateResult.isOk) {
-            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${delegator}, ${registrar}, ${autoAccumulateEntries}) <- OK`;
+            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${delegator}, ${registrar}, ${lazyInspect(autoAccumulate)}) <- OK`;
             regs.set(bless_IN_OUT_REG, results_HostCallResult.OK);
             return;
         }
         const e = updateResult.error;
         // NOTE: `UpdatePrivilegesError.UnprivilegedService` won't happen in 0.7.1+
         if (e === partial_state_UpdatePrivilegesError.UnprivilegedService) {
-            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${delegator}, ${registrar}, ${autoAccumulateEntries}) <- HUH`;
+            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${delegator}, ${registrar}, ${lazyInspect(autoAccumulate)}) <- HUH`;
             regs.set(bless_IN_OUT_REG, results_HostCallResult.HUH);
             return;
         }
         if (e === partial_state_UpdatePrivilegesError.InvalidServiceId) {
-            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${delegator}, ${registrar}, ${autoAccumulateEntries}) <- WHO`;
+            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${delegator}, ${registrar}, ${lazyInspect(autoAccumulate)}) <- WHO`;
             regs.set(bless_IN_OUT_REG, results_HostCallResult.WHO);
             return;
         }
@@ -24117,8 +24227,8 @@ var FetchKind;
 
 
 const info_IN_OUT_REG = 7;
-const OFFSET_REG = compatibility_Compatibility.isSuite(TestSuite.W3F_DAVXY) || compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_2) ? 9 : 11;
-const LEN_REG = compatibility_Compatibility.isSuite(TestSuite.W3F_DAVXY) || compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_2) ? 10 : 12;
+const OFFSET_REG = compatibility_Compatibility.isSuite(compatibility_TestSuite.W3F_DAVXY) || compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_2) ? 9 : 11;
+const LEN_REG = compatibility_Compatibility.isSuite(compatibility_TestSuite.W3F_DAVXY) || compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_2) ? 10 : 12;
 /**
  * Return info about some account.
  *
@@ -24593,6 +24703,7 @@ class pvm_executor_PvmExecutor {
 
 
 
+
 const ACCUMULATION_ERROR = "duplicate service created";
 var PvmInvocationError;
 (function (PvmInvocationError) {
@@ -24761,7 +24872,7 @@ class accumulate_Accumulate {
         const { gasCost, state: stateAfterParallelAcc, ...rest } = await this.accumulateInParallel(accumulateData, slot, entropy, statistics, stateUpdate);
         assertEmpty(rest);
         // NOTE [ToDr] recursive invocation
-        const { accumulatedReports, gasCost: seqGasCost, state, ...seqRest } = await this.accumulateSequentiallyLegacy(tryAsServiceGas(gasLimit - gasCost), reportsToAccumulateSequentially, slot, entropy, statistics, stateAfterParallelAcc, []);
+        const { accumulatedReports, gasCost: seqGasCost, state, ...seqRest } = await this.accumulateSequentiallyLegacy(tryAsServiceGas(gasLimit - gasCost), reportsToAccumulateSequentially, slot, entropy, statistics, stateAfterParallelAcc, new Map());
         assertEmpty(seqRest);
         return {
             accumulatedReports: tryAsU32(i + accumulatedReports),
@@ -24793,8 +24904,15 @@ class accumulate_Accumulate {
         const { gasCost, state: stateAfterParallelAcc, ...rest } = await this.accumulateInParallel(accumulateData, slot, entropy, statistics, stateUpdate);
         const newTransfers = stateAfterParallelAcc.takeTransfers();
         assertEmpty(rest);
+        /**
+         * Gas limit from transfers is added to the next round of accumulation
+         *
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/172b02172b02?v=0.7.2
+         */
+        const transfersGas = transfers.map((t) => t.gas);
+        const { value: newGasLimit, overflow } = sumU64(tryAsServiceGas(gasLimit - gasCost), ...transfersGas);
         // NOTE [ToDr] recursive invocation
-        const { accumulatedReports, gasCost: seqGasCost, state, ...seqRest } = await this.accumulateSequentially(tryAsServiceGas(gasLimit - gasCost), reportsToAccumulateSequentially, newTransfers, slot, entropy, statistics, stateAfterParallelAcc, []);
+        const { accumulatedReports, gasCost: seqGasCost, state, ...seqRest } = await this.accumulateSequentially(tryAsServiceGas(overflow ? MAX_VALUE_U64 : newGasLimit), reportsToAccumulateSequentially, newTransfers, slot, entropy, statistics, stateAfterParallelAcc, new Map());
         assertEmpty(seqRest);
         return {
             accumulatedReports: tryAsU32(i + accumulatedReports),
@@ -24820,14 +24938,16 @@ class accumulate_Accumulate {
         for (const serviceId of serviceIds) {
             const checkpoint = AccumulationStateUpdate.copyFrom(currentState);
             const operands = accumulateData.getOperands(serviceId);
-            const { consumedGas, stateUpdate } = await this.accumulateSingleService(serviceId, accumulateData.getTransfers(serviceId), operands, accumulateData.getGasCost(serviceId), slot, entropy, currentState);
+            const { consumedGas, stateUpdate } = await this.accumulateSingleService(serviceId, accumulateData.getTransfers(serviceId), operands, accumulateData.getGasLimit(serviceId), slot, entropy, currentState);
             gasCost = tryAsServiceGas(gasCost + consumedGas);
             // https://graypaper.fluffylabs.dev/#/ab2cdbd/193b05193b05?v=0.7.2
             const serviceStatistics = statistics.get(serviceId) ?? { count: tryAsU32(0), gasUsed: tryAsServiceGas(0) };
             const count = accumulateData.getReportsLength(serviceId);
             // [0.7.1]: do not update statistics, if the service only had incoming transfers
             if ((Compatibility.isLessThan(GpVersion.V0_7_2) && count > 0) ||
-                (Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) && (count > 0 || consumedGas > 0n))) {
+                ((Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ||
+                    (Compatibility.isSuite(TestSuite.W3F_DAVXY) && Compatibility.is(GpVersion.V0_7_1))) &&
+                    (count > 0 || consumedGas > 0n))) {
                 serviceStatistics.count = tryAsU32(serviceStatistics.count + count);
                 serviceStatistics.gasUsed = tryAsServiceGas(serviceStatistics.gasUsed + consumedGas);
                 statistics.set(serviceId, serviceStatistics);
@@ -24840,7 +24960,7 @@ class accumulate_Accumulate {
                     // Since serviceIds already contains newV, this service gets accumulated twice.
                     // To avoid double-counting, we skip stats and gas cost tracking here.
                     // We need this accumulation to get the correct `delegator`
-                    const { stateUpdate } = await this.accumulateSingleService(newV, [], accumulateData.getOperands(newV), accumulateData.getGasCost(newV), slot, entropy, checkpoint);
+                    const { stateUpdate } = await this.accumulateSingleService(newV, [], accumulateData.getOperands(newV), accumulateData.getGasLimit(newV), slot, entropy, checkpoint);
                     const correctV = stateUpdate?.privilegedServices?.delegator ?? this.state.privilegedServices.delegator;
                     currentState.privilegedServices = PrivilegedServices.create({
                         ...currentState.privilegedServices,
@@ -24906,7 +25026,7 @@ class accumulate_Accumulate {
      */
     getGasLimit() {
         const calculatedGasLimit = GAS_TO_INVOKE_WORK_REPORT * BigInt(this.chainSpec.coresCount) +
-            this.state.privilegedServices.autoAccumulateServices.reduce((acc, { gasLimit }) => acc + gasLimit, 0n);
+            Array.from(this.state.privilegedServices.autoAccumulateServices.values()).reduce((acc, gasLimit) => acc + gasLimit, 0n);
         const gasLimit = tryAsServiceGas(this.chainSpec.maxBlockGas > calculatedGasLimit ? this.chainSpec.maxBlockGas : calculatedGasLimit);
         return tryAsServiceGas(gasLimit);
     }
@@ -25059,9 +25179,8 @@ class deferred_transfers_DeferredTransfers {
                 consumedGas = (await executor.run(args, tryAsGas(gas))).consumedGas;
             }
             transferStatistics.set(serviceId, { count: tryAsU32(transfers.length), gasUsed: tryAsServiceGas(consumedGas) });
-            const [updatedState, checkpointedState] = partialState.getStateUpdates();
+            const [updatedState] = partialState.getStateUpdates();
             currentStateUpdate = updatedState;
-            check `${checkpointedState === null} On transfer cannot invoke checkpoint.`;
         }
         return Result.ok({
             // NOTE: we return only services, since it's impossible to update
@@ -26378,7 +26497,6 @@ class statistics_Statistics {
 
 
 
-
 class DbHeaderChain {
     blocks;
     constructor(blocks) {
@@ -26449,7 +26567,7 @@ class chain_stf_OnChain {
     // chapter 13: https://graypaper.fluffylabs.dev/#/68eaa1f/18b60118b601?v=0.6.4
     statistics;
     isReadyForNextEpoch = Promise.resolve(false);
-    constructor(chainSpec, state, blocks, hasher, pvm = PvmBackend.BuiltIn) {
+    constructor(chainSpec, state, blocks, hasher, pvm) {
         this.chainSpec = chainSpec;
         this.state = state;
         this.hasher = hasher;
@@ -26743,7 +26861,6 @@ function state_loader_loadState(spec, blake2b, keyvals) {
 
 
 
-
 class StateTransitionGenesis {
     static fromJson = {
         header: headerFromJson,
@@ -26773,7 +26890,7 @@ class StateTransition {
 }
 const keccakHasher = keccak_KeccakHasher.create();
 const cachedBlocks = new Map();
-function loadBlocks(testPath) {
+function loadBlocks(testPath, spec) {
     const dir = path.dirname(testPath);
     const fromCache = cachedBlocks.get(dir);
     if (fromCache !== undefined) {
@@ -26781,20 +26898,19 @@ function loadBlocks(testPath) {
     }
     const blocks = [];
     for (const file of fs.readdirSync(dir)) {
-        if (!file.endsWith(".json")) {
+        if (!file.endsWith(".bin")) {
             continue;
         }
-        const data = fs.readFileSync(path.join(dir, file), "utf8");
-        const parsed = JSON.parse(data);
+        const data = fs.readFileSync(path.join(dir, file));
         try {
-            if (file.endsWith("genesis.json")) {
-                const content = parseFromJson(parsed, StateTransitionGenesis.fromJson);
-                const genesisBlock = Block.create({ header: content.header, extrinsic: emptyBlock().extrinsic });
+            if (file.endsWith("genesis.bin")) {
+                const genesis = Decoder.decodeObject(StateTransitionGenesis.Codec, data, spec);
+                const genesisBlock = Block.create({ header: genesis.header, extrinsic: emptyBlock().extrinsic });
                 blocks.push(genesisBlock);
             }
             else {
-                const content = parseFromJson(parsed, StateTransition.fromJson);
-                blocks.push(content.block);
+                const test = Decoder.decodeObject(StateTransition.Codec, data, spec);
+                blocks.push(test.block);
             }
         }
         catch {
@@ -26816,20 +26932,20 @@ const jamConformance070V0Spec = new ChainSpec({
     ...chain_spec_tinyChainSpec,
     maxLookupAnchorAge: numbers_tryAsU32(14_400),
 });
-async function runStateTransition(testContent, testPath, t) {
+async function runStateTransition(testContent, testPath, t, chainSpec) {
     const blake2b = await Blake2b.createHasher();
     // a bit of a hack, but the new value for `maxLookupAnchorAge` was proposed with V1
     // version of the fuzzer, yet these tests were still depending on the older value.
     // To simplify the chain spec, we just special case this one vector here.
     const spec = testPath.includes("fuzz-reports/0.7.0/traces/1756548916/00000082.json")
         ? jamConformance070V0Spec
-        : tinyChainSpec;
+        : chainSpec;
     const preState = loadState(spec, blake2b, testContent.pre_state.keyvals);
     const postState = loadState(spec, blake2b, testContent.post_state.keyvals);
     const preStateRoot = preState.backend.getRootHash(blake2b);
     const postStateRoot = postState.backend.getRootHash(blake2b);
     const blockView = blockAsView(spec, testContent.block);
-    const allBlocks = loadBlocks(testPath);
+    const allBlocks = loadBlocks(testPath, spec);
     const myBlockIndex = allBlocks.findIndex(({ header }) => header.timeSlotIndex === testContent.block.header.timeSlotIndex);
     const previousBlocks = allBlocks.slice(0, myBlockIndex);
     const hasher = new TransitionHasher(spec, await keccakHasher, blake2b);
@@ -26838,7 +26954,7 @@ async function runStateTransition(testContent, testPath, t) {
         const headerHash = hasher.header(blockView.header.view());
         return new WithHash(headerHash.hash, blockView);
     }));
-    const stf = new OnChain(spec, preState, blocksDb, hasher);
+    const stf = new OnChain(spec, preState, blocksDb, hasher, PvmBackend.BuiltIn);
     // verify that we compute the state root exactly the same.
     assert.deepStrictEqual(testContent.pre_state.state_root.toString(), preStateRoot.toString());
     assert.deepStrictEqual(testContent.post_state.state_root.toString(), postStateRoot.toString());