@typeberry/jam 0.1.3-ca63b35 → 0.2.0-b6e3410

package/bootstrap-importer.mjs

@@ -3540,7 +3540,7 @@ var GpVersion;
 (function (GpVersion) {
     GpVersion["V0_6_7"] = "0.6.7";
     GpVersion["V0_7_0"] = "0.7.0";
-    GpVersion["V0_7_1"] = "0.7.1-preview";
+    GpVersion["V0_7_1"] = "0.7.1";
     GpVersion["V0_7_2"] = "0.7.2-preview";
 })(GpVersion || (GpVersion = {}));
 var TestSuite;
@@ -3549,11 +3549,11 @@ var TestSuite;
     TestSuite["JAMDUNA"] = "jamduna";
 })(TestSuite || (TestSuite = {}));
 const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
-const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
+const DEFAULT_VERSION = GpVersion.V0_7_1;
 const env = typeof process === "undefined" ? {} : process.env;
-const DEFAULT_VERSION = GpVersion.V0_7_0;
 let CURRENT_VERSION = parseCurrentVersion(env.GP_VERSION) ?? DEFAULT_VERSION;
 let CURRENT_SUITE = parseCurrentSuite(env.TEST_SUITE) ?? DEFAULT_SUITE;
+const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
 function parseCurrentVersion(env) {
     if (env === undefined) {
         return undefined;
@@ -10335,6 +10335,7 @@ class UpdateStorage {
 
 
 
+
 const codecServiceId = Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isSuite(TestSuite.JAMDUNA, GpVersion.V0_6_7)
     ? descriptors_codec.u32.asOpaque()
     : descriptors_codec.varU32.convert((s) => numbers_tryAsU32(s), (i) => tryAsServiceId(i));
@@ -10466,8 +10467,7 @@ class CoreStatistics {
  * Service statistics.
  * Updated per block, based on available work reports (`W`).
  *
- * https://graypaper.fluffylabs.dev/#/68eaa1f/185104185104?v=0.6.4
- * https://github.com/gavofyork/graypaper/blob/9bffb08f3ea7b67832019176754df4fb36b9557d/text/statistics.tex#L77
+ * https://graypaper.fluffylabs.dev/#/1c979cb/199802199802?v=0.7.1
  */
 class ServiceStatistics {
     providedCount;
@@ -10482,22 +10482,8 @@ class ServiceStatistics {
     accumulateGasUsed;
     onTransfersCount;
     onTransfersGasUsed;
-    static Codec = Compatibility.isGreaterOrEqual(GpVersion.V0_7_0)
-        ? descriptors_codec.Class(ServiceStatistics, {
-            providedCount: codecVarU16,
-            providedSize: descriptors_codec.varU32,
-            refinementCount: descriptors_codec.varU32,
-            refinementGasUsed: codecVarGas,
-            imports: codecVarU16,
-            extrinsicCount: codecVarU16,
-            extrinsicSize: descriptors_codec.varU32,
-            exports: codecVarU16,
-            accumulateCount: descriptors_codec.varU32,
-            accumulateGasUsed: codecVarGas,
-            onTransfersCount: descriptors_codec.varU32,
-            onTransfersGasUsed: codecVarGas,
-        })
-        : descriptors_codec.Class(ServiceStatistics, {
+    static Codec = Compatibility.selectIfGreaterOrEqual({
+        fallback: descriptors_codec.Class(ServiceStatistics, {
             providedCount: codecVarU16,
             providedSize: descriptors_codec.varU32,
             refinementCount: descriptors_codec.varU32,
@@ -10510,7 +10496,38 @@ class ServiceStatistics {
             accumulateGasUsed: codecVarGas,
             onTransfersCount: descriptors_codec.varU32,
             onTransfersGasUsed: codecVarGas,
-        });
+        }),
+        versions: {
+            [GpVersion.V0_7_0]: descriptors_codec.Class(ServiceStatistics, {
+                providedCount: codecVarU16,
+                providedSize: descriptors_codec.varU32,
+                refinementCount: descriptors_codec.varU32,
+                refinementGasUsed: codecVarGas,
+                imports: codecVarU16,
+                extrinsicCount: codecVarU16,
+                extrinsicSize: descriptors_codec.varU32,
+                exports: codecVarU16,
+                accumulateCount: descriptors_codec.varU32,
+                accumulateGasUsed: codecVarGas,
+                onTransfersCount: descriptors_codec.varU32,
+                onTransfersGasUsed: codecVarGas,
+            }),
+            [GpVersion.V0_7_1]: descriptors_codec.Class(ServiceStatistics, {
+                providedCount: codecVarU16,
+                providedSize: descriptors_codec.varU32,
+                refinementCount: descriptors_codec.varU32,
+                refinementGasUsed: codecVarGas,
+                imports: codecVarU16,
+                extrinsicCount: codecVarU16,
+                extrinsicSize: descriptors_codec.varU32,
+                exports: codecVarU16,
+                accumulateCount: descriptors_codec.varU32,
+                accumulateGasUsed: codecVarGas,
+                onTransfersCount: ignoreValueWithDefault(numbers_tryAsU32(0)),
+                onTransfersGasUsed: ignoreValueWithDefault(tryAsServiceGas(0)),
+            }),
+        },
+    });
     static create(v) {
         return new ServiceStatistics(v.providedCount, v.providedSize, v.refinementCount, v.refinementGasUsed, v.imports, v.exports, v.extrinsicSize, v.extrinsicCount, v.accumulateCount, v.accumulateGasUsed, v.onTransfersCount, v.onTransfersGasUsed);
     }
@@ -10535,9 +10552,9 @@ class ServiceStatistics {
     accumulateCount, 
     /** `a.1` */
     accumulateGasUsed, 
-    /** `t.0` */
+    /** `t.0` @deprecated since 0.7.1 */
     onTransfersCount, 
-    /** `t.1` */
+    /** `t.1` @deprecated since 0.7.1 */
     onTransfersGasUsed) {
         this.providedCount = providedCount;
         this.providedSize = providedSize;
@@ -15151,6 +15168,12 @@ class AccumulationStateUpdate {
         }
         return update;
     }
+    /** Retrieve and clear pending transfers. */
+    takeTransfers() {
+        const transfers = this.transfers;
+        this.transfers = [];
+        return transfers;
+    }
 }
 class PartiallyUpdatedState {
     state;
@@ -19190,6 +19213,24 @@ class Interpreter {
     getMemoryPage(pageNumber) {
         return this.memory.getPageDump(tryAsPageNumber(pageNumber));
     }
+    calculateBlockGasCost() {
+        const codeLength = this.code.length;
+        const blocks = new Map();
+        let currentBlock = "0";
+        let gasCost = 0;
+        const getNextIstructionIndex = (index) => index + 1 + this.mask.getNoOfBytesToNextInstruction(index + 1);
+        for (let index = 0; index < codeLength; index = getNextIstructionIndex(index)) {
+            const instruction = this.code[index];
+            if (this.basicBlocks.isBeginningOfBasicBlock(index)) {
+                blocks.set(currentBlock, gasCost);
+                currentBlock = index.toString();
+                gasCost = 0;
+            }
+            gasCost += instructionGasMap[instruction];
+        }
+        blocks.set(currentBlock, gasCost);
+        return blocks;
+    }
 }
 
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/index.ts
@@ -19895,24 +19936,78 @@ class AccumulateExternalities {
         this.updatedState.stateUpdate.authorizationQueues.set(coreIndex, authQueue);
         return result_Result.ok(result_OK);
     }
+    updatePrivilegedServiceId(
+    // The id that privileged service wants to be updated to
+    newId, 
+    // Current id of privileged service (updated state)
+    currentId, { 
+    // is current service id a manager (can update anything)
+    isManager, 
+    // is current service attempting to update itself (privileged are owned)
+    isSelf, 
+    // is the service id already changed in this block
+    isAlreadyChanged, }) {
+        if (isManager) {
+            return newId;
+        }
+        // current service can update itself, only if it was a privileged
+        // service at the start of the block. I.e. owned privileges cannot
+        // be transfered multiple times in a block.
+        if (isSelf && !isAlreadyChanged) {
+            return newId;
+        }
+        return currentId;
+    }
     updatePrivilegedServices(manager, authorizers, delegator, registrar, autoAccumulate) {
         /** https://graypaper.fluffylabs.dev/#/7e6ff6a/36d90036de00?v=0.6.7 */
-        const currentManager = this.updatedState.getPrivilegedServices().manager;
-        if (currentManager !== this.currentServiceId) {
-            return result_Result.error(UpdatePrivilegesError.UnprivilegedService);
-        }
-        if (manager === null || delegator === null) {
-            return result_Result.error(UpdatePrivilegesError.InvalidServiceId, "Either manager or delegator is not valid service id.");
+        const current = this.updatedState.getPrivilegedServices();
+        const isManager = current.manager === this.currentServiceId;
+        if (Compatibility.isLessThan(GpVersion.V0_7_1)) {
+            if (!isManager) {
+                return result_Result.error(UpdatePrivilegesError.UnprivilegedService);
+            }
+            if (manager === null || delegator === null) {
+                return result_Result.error(UpdatePrivilegesError.InvalidServiceId, "Either manager or delegator is not a valid service id.");
+            }
+            this.updatedState.stateUpdate.privilegedServices = PrivilegedServices.create({
+                manager,
+                assigners: authorizers,
+                delegator: delegator,
+                registrar: registrar ?? tryAsServiceId(0),
+                autoAccumulateServices: autoAccumulate.map(([service, gasLimit]) => AutoAccumulate.create({ service, gasLimit })),
+            });
+            return result_Result.ok(result_OK);
         }
-        if (Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) && registrar === null) {
-            return result_Result.error(UpdatePrivilegesError.InvalidServiceId, "Register manager is not valid service id.");
+        const original = this.updatedState.state.privilegedServices;
+        if (manager === null || delegator === null || registrar === null) {
+            return result_Result.error(UpdatePrivilegesError.InvalidServiceId, "Either manager or delegator or registrar is not a valid service id.");
         }
+        const newDelegator = this.updatePrivilegedServiceId(delegator, current.delegator, {
+            isManager,
+            isSelf: this.currentServiceId === current.delegator,
+            isAlreadyChanged: current.delegator !== original.delegator,
+        });
+        const newRegistrar = this.updatePrivilegedServiceId(registrar, current.registrar, {
+            isManager,
+            isSelf: this.currentServiceId === current.registrar,
+            isAlreadyChanged: current.registrar !== original.registrar,
+        });
+        const newAssigners = current.assigners.map((currentAssigner, index) => this.updatePrivilegedServiceId(authorizers[index], currentAssigner, {
+            isManager,
+            isSelf: this.currentServiceId === currentAssigner,
+            isAlreadyChanged: currentAssigner !== original.assigners[index],
+        }));
+        const newManager = isManager ? manager : current.manager;
+        const newAutoAccumulateServices = isManager
+            ? autoAccumulate.map(([service, gasLimit]) => AutoAccumulate.create({ service, gasLimit }))
+            : current.autoAccumulateServices;
+        // finally update the privileges
         this.updatedState.stateUpdate.privilegedServices = PrivilegedServices.create({
-            manager,
-            assigners: authorizers,
-            delegator,
-            registrar: registrar ?? tryAsServiceId(0), // introduced in 0.7.1
-            autoAccumulateServices: autoAccumulate.map(([service, gasLimit]) => AutoAccumulate.create({ service, gasLimit })),
+            manager: newManager,
+            assigners: tryAsPerCore(newAssigners, this.chainSpec),
+            delegator: newDelegator,
+            registrar: newRegistrar,
+            autoAccumulateServices: newAutoAccumulateServices,
         });
         return result_Result.ok(result_OK);
     }
@@ -21271,6 +21366,7 @@ class Bless {
             return;
         }
         const e = updateResult.error;
+        // NOTE: `UpdatePrivilegesError.UnprivilegedService` won't happen in 0.7.1+
         if (e === UpdatePrivilegesError.UnprivilegedService) {
             logger_logger.trace `BLESS(${manager}, ${authorizers}, ${delegator}, ${registrar}, ${autoAccumulateEntries}) <- HUH`;
             regs.set(bless_IN_OUT_REG, HostCallResult.HUH);
@@ -22265,7 +22361,7 @@ class Lookup {
         }
         // v
         const preImage = this.account.lookup(serviceId, preImageHash);
-        logger_logger.trace `LOOKUP(${serviceId}, ${preImageHash}) <- ${preImage?.toStringTruncated()}...`;
+        logger_logger.trace `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);
@@ -22815,15 +22911,15 @@ class Accumulate {
      *
      * https://graypaper.fluffylabs.dev/#/7e6ff6a/2fdb012fdb01?v=0.6.7
      */
-    async pvmAccumulateInvocation(slot, serviceId, transfers, operands, gas, entropy, inputStateUpdate) {
-        const service = this.state.getService(serviceId);
-        if (service === null) {
+    async pvmAccumulateInvocation(slot, serviceId, transfers, operands, gas, entropy, updatedState) {
+        const serviceInfo = updatedState.getServiceInfo(serviceId);
+        if (serviceInfo === null) {
             accumulate_logger.log `Service with id ${serviceId} not found.`;
             return result_Result.error(PvmInvocationError.NoService);
         }
-        const codeHash = service.getInfo().codeHash;
+        const codeHash = serviceInfo.codeHash;
         // TODO [ToDr] Should we check that the preimage is still available?
-        const code = service.getPreimage(codeHash.asOpaque());
+        const code = updatedState.getPreimage(serviceId, codeHash.asOpaque());
         if (code === null) {
             accumulate_logger.log `Code with hash ${codeHash} not found for service ${serviceId}.`;
             return result_Result.error(PvmInvocationError.NoPreimage);
@@ -22833,7 +22929,7 @@ class Accumulate {
             return result_Result.error(PvmInvocationError.PreimageTooLong);
         }
         const nextServiceId = generateNextServiceId({ serviceId, entropy, timeslot: slot }, this.chainSpec, this.blake2b);
-        const partialState = new AccumulateExternalities(this.chainSpec, this.blake2b, new PartiallyUpdatedState(this.state, inputStateUpdate), serviceId, nextServiceId, slot);
+        const partialState = new AccumulateExternalities(this.chainSpec, this.blake2b, updatedState, serviceId, nextServiceId, slot);
         const fetchExternalities = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
             ? FetchExternalities.createForAccumulate({ entropy, transfers, operands }, this.chainSpec)
             : FetchExternalities.createForPre071Accumulate({ entropy, operands }, this.chainSpec);
@@ -22887,11 +22983,28 @@ class Accumulate {
      */
     async accumulateSingleService(serviceId, transfers, operands, gasCost, slot, entropy, inputStateUpdate) {
         accumulate_logger.log `Accumulating service ${serviceId}, transfers: ${transfers.length} operands: ${operands.length} at slot: ${slot}.`;
-        const result = await this.pvmAccumulateInvocation(slot, serviceId, transfers, operands, gasCost, entropy, inputStateUpdate);
+        const updatedState = new PartiallyUpdatedState(this.state, inputStateUpdate);
+        // update service balance from incoming transfers
+        if (Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)) {
+            const serviceInfo = updatedState.getServiceInfo(serviceId);
+            if (serviceInfo !== null) {
+                // update the balance from incoming tranfsers
+                const newBalance = sumU64(serviceInfo.balance, ...transfers.map((item) => item.amount));
+                if (newBalance.overflow) {
+                    accumulate_logger.log `Accumulation failed because of overflowing balance ${serviceId}.`;
+                    return { stateUpdate: null, consumedGas: 0n };
+                }
+                const newInfo = ServiceAccountInfo.create({ ...serviceInfo, balance: newBalance.value });
+                updatedState.updateServiceInfo(serviceId, newInfo);
+            }
+        }
+        const result = await this.pvmAccumulateInvocation(slot, serviceId, transfers, operands, gasCost, entropy, updatedState);
         if (result.isError) {
             // https://graypaper.fluffylabs.dev/#/7e6ff6a/2fb6012fb601?v=0.6.7
             accumulate_logger.log `Accumulation failed for ${serviceId}.`;
-            return { stateUpdate: null, consumedGas: 0n };
+            // even though accumulation failed, we still need to make sure that
+            // incoming transfers updated the balance, hence we pass state update here
+            return { stateUpdate: updatedState.stateUpdate, consumedGas: 0n };
         }
         accumulate_logger.log `Accumulation successful for ${serviceId}. Consumed: ${result.ok.consumedGas}`;
         return result.ok;
@@ -22949,7 +23062,7 @@ class Accumulate {
         const accumulateData = new AccumulateData(reportsToAccumulateInParallel, transfers, autoAccumulateServices);
         const reportsToAccumulateSequentially = reports.subview(i);
         const { gasCost, state: stateAfterParallelAcc, ...rest } = await this.accumulateInParallel(accumulateData, slot, entropy, statistics, stateUpdate);
-        const newTransfers = stateAfterParallelAcc.transfers;
+        const newTransfers = stateAfterParallelAcc.takeTransfers();
         assertEmpty(rest);
         // NOTE [ToDr] recursive invocation
         const { accumulatedReports, gasCost: seqGasCost, state, ...seqRest } = await this.accumulateSequentially(tryAsServiceGas(gasLimit - gasCost), reportsToAccumulateSequentially, newTransfers, slot, entropy, statistics, stateAfterParallelAcc, []);
@@ -22977,12 +23090,17 @@ class Accumulate {
         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.getTransfers(serviceId), accumulateData.getOperands(serviceId), accumulateData.getGasCost(serviceId), slot, entropy, currentState);
+            const operands = accumulateData.getOperands(serviceId);
+            const { consumedGas, stateUpdate } = await this.accumulateSingleService(serviceId, accumulateData.getTransfers(serviceId), operands, accumulateData.getGasCost(serviceId), slot, entropy, currentState);
             gasCost = tryAsServiceGas(gasCost + consumedGas);
-            const serviceStatistics = statistics.get(serviceId) ?? { count: numbers_tryAsU32(0), gasUsed: tryAsServiceGas(0) };
-            serviceStatistics.count = numbers_tryAsU32(serviceStatistics.count + accumulateData.getReportsLength(serviceId));
-            serviceStatistics.gasUsed = tryAsServiceGas(serviceStatistics.gasUsed + consumedGas);
-            statistics.set(serviceId, serviceStatistics);
+            // https://graypaper.fluffylabs.dev/#/ab2cdbd/193b05193b05?v=0.7.2
+            // do not update statistics, if the service only had incoming transfers
+            if (operands.length > 0) {
+                const serviceStatistics = statistics.get(serviceId) ?? { count: numbers_tryAsU32(0), gasUsed: tryAsServiceGas(0) };
+                serviceStatistics.count = numbers_tryAsU32(serviceStatistics.count + accumulateData.getReportsLength(serviceId));
+                serviceStatistics.gasUsed = 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?.delegator;
@@ -23034,6 +23152,7 @@ class Accumulate {
             const info = partialStateUpdate.getServiceInfo(serviceId);
             if (info === null) {
                 // NOTE If there is no service, we dont update it.
+                accumulate_logger.log `Skipping update of ${serviceId}, because we have no service info.`;
                 continue;
             }
             // δ‡
@@ -24746,6 +24865,9 @@ class OnChain {
             servicesUpdate = servicesUpdateFromDeferredTransfers;
             assertEmpty(deferredTransfersRest);
         }
+        else {
+            debug_check `${pendingTransfers.length === 0} All transfers should be already accumulated.`;
+        }
         const accumulateRoot = await this.accumulateOutput.transition({ accumulationOutputLog });
         // recent history
         const recentHistoryUpdate = this.recentHistory.transition({