@typeberry/jam 0.1.3-0eba10b → 0.1.3-2fdafd6

package/bootstrap-importer.mjs

@@ -19901,24 +19901,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);
     }
@@ -21277,6 +21331,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);