@typeberry/jam 0.1.1-127cc86 → 0.1.1-4a6ffa9

package/importer/index.js

@@ -4436,6 +4436,34 @@ class WithDebug {
     }
 }
 
+;// CONCATENATED MODULE: ./packages/core/utils/dev.ts
+const dev_env = typeof process === "undefined" ? {} : process.env;
+/**
+ * The function will produce relative path resolver that is adjusted
+ * for package location within the workspace.
+ *
+ * Example:
+ * $ npm start -w @typeberry/jam
+ *
+ * The above command will run `./bin/jam/index.js`, however we would
+ * still want relative paths to be resolved according to top-level workspace
+ * directory.
+ *
+ * So the caller, passes the absolute workspace path as argument and get's
+ * a function that can properly resolve relative paths.
+ *
+ * NOTE: the translation happens only for development build! When
+ * we build a single library from our project, we no longer mangle the paths.
+ */
+const workspacePathFix = dev_env.NODE_ENV === "development"
+    ? (workspacePath) => (p) => {
+        if (p.startsWith("/")) {
+            return p;
+        }
+        return `${workspacePath}/${p}`;
+    }
+    : () => (p) => p;
+
 ;// CONCATENATED MODULE: ./packages/core/utils/opaque.ts
 /**
  * @fileoverview `Opaque<Type, Token>` constructs a unique type which is a subset of Type with a
@@ -4779,6 +4807,7 @@ function isResult(x) {
 
 
 
+
 ;// CONCATENATED MODULE: ./packages/core/bytes/bitvec.ts
 
 /**
@@ -23352,6 +23381,7 @@ class Accumulate {
         const serviceIds = accumulateData.getServiceIds();
         let gasCost = common_tryAsServiceGas(0);
         let currentState = inputStateUpdate;
+        const currentManager = (inputStateUpdate.privilegedServices ?? this.state.privilegedServices).manager;
         for (const serviceId of serviceIds) {
             const checkpoint = AccumulationStateUpdate.copyFrom(currentState);
             const { consumedGas, stateUpdate } = await this.accumulateSingleService(serviceId, accumulateData.getOperands(serviceId), accumulateData.getGasCost(serviceId), slot, entropy, currentState);
@@ -23361,6 +23391,21 @@ class Accumulate {
             serviceStatistics.gasUsed = common_tryAsServiceGas(serviceStatistics.gasUsed + consumedGas);
             statistics.set(serviceId, serviceStatistics);
             currentState = stateUpdate === null ? checkpoint : stateUpdate;
+            if (Compatibility.is(GpVersion.V0_7_0) && serviceId === currentManager) {
+                const newV = currentState.privilegedServices?.validatorsManager;
+                if (currentState.privilegedServices !== null && newV !== undefined && serviceIds.includes(newV)) {
+                    accumulate_logger.info("Entering completely incorrect code that probably reverts validatorsManager change. This is valid in 0.7.0 only and incorrect in 0.7.1+");
+                    // 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 `validatorsManager`
+                    const { stateUpdate } = await this.accumulateSingleService(newV, accumulateData.getOperands(newV), accumulateData.getGasCost(newV), slot, entropy, checkpoint);
+                    const correctV = stateUpdate?.privilegedServices?.validatorsManager ?? this.state.privilegedServices.validatorsManager;
+                    currentState.privilegedServices = PrivilegedServices.create({
+                        ...currentState.privilegedServices,
+                        validatorsManager: correctV,
+                    });
+                }
+            }
         }
         return {
             state: currentState,
@@ -23505,11 +23550,14 @@ class DeferredTransfers {
     async transition({ pendingTransfers, timeslot, servicesUpdate: inputServicesUpdate, entropy, }) {
         // https://graypaper.fluffylabs.dev/#/7e6ff6a/187a03187a03?v=0.6.7
         const transferStatistics = new Map();
-        const services = uniquePreserveOrder(pendingTransfers.flatMap((x) => [x.source, x.destination]));
+        const services = uniquePreserveOrder(pendingTransfers.map((x) => x.destination));
         let currentStateUpdate = AccumulationStateUpdate.new(inputServicesUpdate);
         for (const serviceId of services) {
             const partiallyUpdatedState = new PartiallyUpdatedState(this.state, currentStateUpdate);
-            const transfers = pendingTransfers.filter((pendingTransfer) => pendingTransfer.destination === serviceId);
+            // https://graypaper.fluffylabs.dev/#/38c4e62/18750318ae03?v=0.7.0
+            const transfers = pendingTransfers
+                .filter((pendingTransfer) => pendingTransfer.destination === serviceId)
+                .toSorted((a, b) => a.source - b.source);
             const info = partiallyUpdatedState.getServiceInfo(serviceId);
             if (info === null) {
                 return result_Result.error(DeferredTransfersErrorCode.ServiceInfoNotExist);