@typeberry/jam 0.2.0-74f246e → 0.2.0-8017bfd

package/bootstrap-generator.mjs

@@ -9044,6 +9044,7 @@ function accumulationOutputComparator(a, b) {
 
 ;// CONCATENATED MODULE: ./packages/jam/block/gp-constants.ts
 
+
 /**
  * This file lists all of the constants defined in the GrayPaper appendix.
  *
@@ -9054,7 +9055,7 @@ function accumulationOutputComparator(a, b) {
  * here are only temporarily for convenience. When we figure out better names
  * and places for these this file will be eradicated.
  *
- * https://graypaper.fluffylabs.dev/#/579bd12/413000413000
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/442300442300?v=0.7.2
  */
 /** `G_I`: The gas allocated to invoke a work-package’s Is-Authorized logic. */
 const G_I = 50_000_000;
@@ -9070,8 +9071,8 @@ const S = 1024;
 const T = 128;
 /** `W_A`: The maximum size of is-authorized code in octets. */
 const W_A = 64_000;
-/** `W_B`: The maximum size of an encoded work-package with extrinsic data and imports. */
-const W_B = 13_794_305;
+/** `W_B`: The maximum size of the concatenated variable-size blobs, extrinsics and imported segments of a work-package, in octets */
+const W_B = Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? 13_791_360 : 13_794_305;
 /** `W_C`: The maximum size of service code in octets. */
 const W_C = 4_000_000;
 /** `W_M`: The maximum number of imports in a work-package. */
@@ -10170,31 +10171,29 @@ var UpdatePreimageKind;
  * 3. Update `LookupHistory` with given value.
  */
 class state_update_UpdatePreimage {
-    serviceId;
     action;
-    constructor(serviceId, action) {
-        this.serviceId = serviceId;
+    constructor(action) {
         this.action = action;
     }
     /** A preimage is provided. We should update the lookuphistory and add the preimage to db. */
-    static provide({ serviceId, preimage, slot, }) {
-        return new state_update_UpdatePreimage(serviceId, {
+    static provide({ preimage, slot }) {
+        return new state_update_UpdatePreimage({
             kind: UpdatePreimageKind.Provide,
             preimage,
             slot,
         });
     }
     /** The preimage should be removed completely from the database. */
-    static remove({ serviceId, hash, length }) {
-        return new state_update_UpdatePreimage(serviceId, {
+    static remove({ hash, length }) {
+        return new state_update_UpdatePreimage({
             kind: UpdatePreimageKind.Remove,
             hash,
             length,
         });
     }
     /** Update the lookup history of some preimage or add a new one (request). */
-    static updateOrAdd({ serviceId, lookupHistory }) {
-        return new state_update_UpdatePreimage(serviceId, {
+    static updateOrAdd({ lookupHistory }) {
+        return new state_update_UpdatePreimage({
             kind: UpdatePreimageKind.UpdateOrAdd,
             item: lookupHistory,
         });
@@ -10231,23 +10230,21 @@ var UpdateServiceKind;
     UpdateServiceKind[UpdateServiceKind["Create"] = 1] = "Create";
 })(UpdateServiceKind || (UpdateServiceKind = {}));
 /**
- * Update service info of a particular `ServiceId` or create a new one.
+ * Update service info or create a new one.
  */
 class UpdateService {
-    serviceId;
     action;
-    constructor(serviceId, action) {
-        this.serviceId = serviceId;
+    constructor(action) {
         this.action = action;
     }
-    static update({ serviceId, serviceInfo }) {
-        return new UpdateService(serviceId, {
+    static update({ serviceInfo }) {
+        return new UpdateService({
             kind: UpdateServiceKind.Update,
             account: serviceInfo,
         });
     }
-    static create({ serviceId, serviceInfo, lookupHistory, }) {
-        return new UpdateService(serviceId, {
+    static create({ serviceInfo, lookupHistory, }) {
+        return new UpdateService({
             kind: UpdateServiceKind.Create,
             account: serviceInfo,
             lookupHistory,
@@ -10268,17 +10265,15 @@ var UpdateStorageKind;
  * Can either create/modify an entry or remove it.
  */
 class UpdateStorage {
-    serviceId;
     action;
-    constructor(serviceId, action) {
-        this.serviceId = serviceId;
+    constructor(action) {
         this.action = action;
     }
-    static set({ serviceId, storage }) {
-        return new UpdateStorage(serviceId, { kind: UpdateStorageKind.Set, storage });
+    static set({ storage }) {
+        return new UpdateStorage({ kind: UpdateStorageKind.Set, storage });
     }
-    static remove({ serviceId, key }) {
-        return new UpdateStorage(serviceId, { kind: UpdateStorageKind.Remove, key });
+    static remove({ key }) {
+        return new UpdateStorage({ kind: UpdateStorageKind.Remove, key });
     }
     get key() {
         if (this.action.kind === UpdateStorageKind.Remove) {
@@ -10487,12 +10482,12 @@ class in_memory_state_InMemoryState extends WithDebug {
      * Modify the state and apply a single state update.
      */
     applyUpdate(update) {
-        const { servicesRemoved, servicesUpdates, preimages, storage, ...rest } = update;
+        const { removed, created: _, updated, preimages, storage, ...rest } = update;
         // just assign all other variables
         Object.assign(this, rest);
         // and update the services state
         let result;
-        result = this.updateServices(servicesUpdates);
+        result = this.updateServices(updated);
         if (result.isError) {
             return result;
         }
@@ -10504,7 +10499,7 @@ class in_memory_state_InMemoryState extends WithDebug {
         if (result.isError) {
             return result;
         }
-        this.removeServices(servicesRemoved);
+        this.removeServices(removed);
         return result_Result.ok(result_OK);
     }
     removeServices(servicesRemoved) {
@@ -10513,87 +10508,100 @@ class in_memory_state_InMemoryState extends WithDebug {
             this.services.delete(serviceId);
         }
     }
-    updateStorage(storage) {
-        for (const { serviceId, action } of storage ?? []) {
-            const { kind } = action;
-            const service = this.services.get(serviceId);
-            if (service === undefined) {
-                return result_Result.error(in_memory_state_UpdateError.NoService, `Attempting to update storage of non-existing service: ${serviceId}`);
-            }
-            if (kind === UpdateStorageKind.Set) {
-                const { key, value } = action.storage;
-                service.data.storage.set(key.toString(), StorageItem.create({ key, value }));
-            }
-            else if (kind === UpdateStorageKind.Remove) {
-                const { key } = action;
-                debug_check `
+    updateStorage(storageUpdates) {
+        if (storageUpdates === undefined) {
+            return result_Result.ok(result_OK);
+        }
+        for (const [serviceId, updates] of storageUpdates.entries()) {
+            for (const update of updates) {
+                const { kind } = update.action;
+                const service = this.services.get(serviceId);
+                if (service === undefined) {
+                    return result_Result.error(in_memory_state_UpdateError.NoService, `Attempting to update storage of non-existing service: ${serviceId}`);
+                }
+                if (kind === UpdateStorageKind.Set) {
+                    const { key, value } = update.action.storage;
+                    service.data.storage.set(key.toString(), StorageItem.create({ key, value }));
+                }
+                else if (kind === UpdateStorageKind.Remove) {
+                    const { key } = update.action;
+                    debug_check `
           ${service.data.storage.has(key.toString())}
-          Attempting to remove non-existing storage item at ${serviceId}: ${action.key}
+          Attempting to remove non-existing storage item at ${serviceId}: ${update.action.key}
         `;
-                service.data.storage.delete(key.toString());
-            }
-            else {
-                debug_assertNever(kind);
+                    service.data.storage.delete(key.toString());
+                }
+                else {
+                    debug_assertNever(kind);
+                }
             }
         }
         return result_Result.ok(result_OK);
     }
-    updatePreimages(preimages) {
-        for (const { serviceId, action } of preimages ?? []) {
+    updatePreimages(preimagesUpdates) {
+        if (preimagesUpdates === undefined) {
+            return result_Result.ok(result_OK);
+        }
+        for (const [serviceId, updates] of preimagesUpdates.entries()) {
             const service = this.services.get(serviceId);
             if (service === undefined) {
                 return result_Result.error(in_memory_state_UpdateError.NoService, `Attempting to update preimage of non-existing service: ${serviceId}`);
             }
-            const { kind } = action;
-            if (kind === UpdatePreimageKind.Provide) {
-                const { preimage, slot } = action;
-                if (service.data.preimages.has(preimage.hash)) {
-                    return result_Result.error(in_memory_state_UpdateError.PreimageExists, `Overwriting existing preimage at ${serviceId}: ${preimage}`);
-                }
-                service.data.preimages.set(preimage.hash, preimage);
-                if (slot !== null) {
-                    const lookupHistory = service.data.lookupHistory.get(preimage.hash);
-                    const length = numbers_tryAsU32(preimage.blob.length);
-                    const lookup = new service_LookupHistoryItem(preimage.hash, length, tryAsLookupHistorySlots([slot]));
-                    if (lookupHistory === undefined) {
-                        // no lookup history for that preimage at all (edge case, should be requested)
-                        service.data.lookupHistory.set(preimage.hash, [lookup]);
+            for (const update of updates) {
+                const { kind } = update.action;
+                if (kind === UpdatePreimageKind.Provide) {
+                    const { preimage, slot } = update.action;
+                    if (service.data.preimages.has(preimage.hash)) {
+                        return result_Result.error(in_memory_state_UpdateError.PreimageExists, `Overwriting existing preimage at ${serviceId}: ${preimage}`);
                     }
-                    else {
-                        // insert or replace exiting entry
-                        const index = lookupHistory.map((x) => x.length).indexOf(length);
-                        lookupHistory.splice(index, index === -1 ? 0 : 1, lookup);
+                    service.data.preimages.set(preimage.hash, preimage);
+                    if (slot !== null) {
+                        const lookupHistory = service.data.lookupHistory.get(preimage.hash);
+                        const length = numbers_tryAsU32(preimage.blob.length);
+                        const lookup = new service_LookupHistoryItem(preimage.hash, length, tryAsLookupHistorySlots([slot]));
+                        if (lookupHistory === undefined) {
+                            // no lookup history for that preimage at all (edge case, should be requested)
+                            service.data.lookupHistory.set(preimage.hash, [lookup]);
+                        }
+                        else {
+                            // insert or replace exiting entry
+                            const index = lookupHistory.map((x) => x.length).indexOf(length);
+                            lookupHistory.splice(index, index === -1 ? 0 : 1, lookup);
+                        }
                     }
                 }
-            }
-            else if (kind === UpdatePreimageKind.Remove) {
-                const { hash, length } = action;
-                service.data.preimages.delete(hash);
-                const history = service.data.lookupHistory.get(hash) ?? [];
-                const idx = history.map((x) => x.length).indexOf(length);
-                if (idx !== -1) {
-                    history.splice(idx, 1);
+                else if (kind === UpdatePreimageKind.Remove) {
+                    const { hash, length } = update.action;
+                    service.data.preimages.delete(hash);
+                    const history = service.data.lookupHistory.get(hash) ?? [];
+                    const idx = history.map((x) => x.length).indexOf(length);
+                    if (idx !== -1) {
+                        history.splice(idx, 1);
+                    }
+                }
+                else if (kind === UpdatePreimageKind.UpdateOrAdd) {
+                    const { item } = update.action;
+                    const history = service.data.lookupHistory.get(item.hash) ?? [];
+                    const existingIdx = history.map((x) => x.length).indexOf(item.length);
+                    const removeCount = existingIdx === -1 ? 0 : 1;
+                    history.splice(existingIdx, removeCount, item);
+                    service.data.lookupHistory.set(item.hash, history);
+                }
+                else {
+                    debug_assertNever(kind);
                 }
-            }
-            else if (kind === UpdatePreimageKind.UpdateOrAdd) {
-                const { item } = action;
-                const history = service.data.lookupHistory.get(item.hash) ?? [];
-                const existingIdx = history.map((x) => x.length).indexOf(item.length);
-                const removeCount = existingIdx === -1 ? 0 : 1;
-                history.splice(existingIdx, removeCount, item);
-                service.data.lookupHistory.set(item.hash, history);
-            }
-            else {
-                debug_assertNever(kind);
             }
         }
         return result_Result.ok(result_OK);
     }
     updateServices(servicesUpdates) {
-        for (const { serviceId, action } of servicesUpdates ?? []) {
-            const { kind, account } = action;
+        if (servicesUpdates === undefined) {
+            return result_Result.ok(result_OK);
+        }
+        for (const [serviceId, update] of servicesUpdates.entries()) {
+            const { kind, account } = update.action;
             if (kind === UpdateServiceKind.Create) {
-                const { lookupHistory } = action;
+                const { lookupHistory } = update.action;
                 if (this.services.has(serviceId)) {
                     return result_Result.error(in_memory_state_UpdateError.DuplicateService, `${serviceId} already exists!`);
                 }
@@ -11854,7 +11862,6 @@ function getKeccakTrieHasher(hasher) {
 
 
 
-
 /** What should be done with that key? */
 var StateEntryUpdateAction;
 (function (StateEntryUpdateAction) {
@@ -11870,76 +11877,88 @@ function* serializeStateUpdate(spec, blake2b, update) {
     yield* serializeBasicKeys(spec, update);
     const encode = (codec, val) => encoder_Encoder.encodeObject(codec, val, spec);
     // then let's proceed with service updates
-    yield* serializeServiceUpdates(update.servicesUpdates, encode, blake2b);
+    yield* serializeServiceUpdates(update.updated, encode, blake2b);
     yield* serializePreimages(update.preimages, encode, blake2b);
     yield* serializeStorage(update.storage, blake2b);
-    yield* serializeRemovedServices(update.servicesRemoved);
+    yield* serializeRemovedServices(update.removed);
 }
 function* serializeRemovedServices(servicesRemoved) {
-    for (const serviceId of servicesRemoved ?? []) {
+    if (servicesRemoved === undefined) {
+        return;
+    }
+    for (const serviceId of servicesRemoved) {
         // TODO [ToDr] what about all data associated with a service?
         const codec = serialize_serialize.serviceData(serviceId);
         yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
     }
 }
-function* serializeStorage(storage, blake2b) {
-    for (const { action, serviceId } of storage ?? []) {
-        switch (action.kind) {
-            case UpdateStorageKind.Set: {
-                const key = action.storage.key;
-                const codec = serialize_serialize.serviceStorage(blake2b, serviceId, key);
-                yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
-                break;
-            }
-            case UpdateStorageKind.Remove: {
-                const key = action.key;
-                const codec = serialize_serialize.serviceStorage(blake2b, serviceId, key);
-                yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
-                break;
+function* serializeStorage(storageUpdates, blake2b) {
+    if (storageUpdates === undefined) {
+        return;
+    }
+    for (const [serviceId, updates] of storageUpdates.entries()) {
+        for (const { action } of updates) {
+            switch (action.kind) {
+                case UpdateStorageKind.Set: {
+                    const key = action.storage.key;
+                    const codec = serialize_serialize.serviceStorage(blake2b, serviceId, key);
+                    yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
+                    break;
+                }
+                case UpdateStorageKind.Remove: {
+                    const key = action.key;
+                    const codec = serialize_serialize.serviceStorage(blake2b, serviceId, key);
+                    yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
+                    break;
+                }
             }
-            default:
-                debug_assertNever(action);
         }
     }
 }
-function* serializePreimages(preimages, encode, blake2b) {
-    for (const { action, serviceId } of preimages ?? []) {
-        switch (action.kind) {
-            case UpdatePreimageKind.Provide: {
-                const { hash, blob } = action.preimage;
-                const codec = serialize_serialize.servicePreimages(blake2b, serviceId, hash);
-                yield [StateEntryUpdateAction.Insert, codec.key, blob];
-                if (action.slot !== null) {
-                    const codec2 = serialize_serialize.serviceLookupHistory(blake2b, serviceId, hash, numbers_tryAsU32(blob.length));
-                    yield [
-                        StateEntryUpdateAction.Insert,
-                        codec2.key,
-                        encode(codec2.Codec, tryAsLookupHistorySlots([action.slot])),
-                    ];
+function* serializePreimages(preimagesUpdates, encode, blake2b) {
+    if (preimagesUpdates === undefined) {
+        return;
+    }
+    for (const [serviceId, updates] of preimagesUpdates.entries()) {
+        for (const { action } of updates) {
+            switch (action.kind) {
+                case UpdatePreimageKind.Provide: {
+                    const { hash, blob } = action.preimage;
+                    const codec = serialize_serialize.servicePreimages(blake2b, serviceId, hash);
+                    yield [StateEntryUpdateAction.Insert, codec.key, blob];
+                    if (action.slot !== null) {
+                        const codec2 = serialize_serialize.serviceLookupHistory(blake2b, serviceId, hash, numbers_tryAsU32(blob.length));
+                        yield [
+                            StateEntryUpdateAction.Insert,
+                            codec2.key,
+                            encode(codec2.Codec, tryAsLookupHistorySlots([action.slot])),
+                        ];
+                    }
+                    break;
+                }
+                case UpdatePreimageKind.UpdateOrAdd: {
+                    const { hash, length, slots } = action.item;
+                    const codec = serialize_serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
+                    yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, slots)];
+                    break;
+                }
+                case UpdatePreimageKind.Remove: {
+                    const { hash, length } = action;
+                    const codec = serialize_serialize.servicePreimages(blake2b, serviceId, hash);
+                    yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
+                    const codec2 = serialize_serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
+                    yield [StateEntryUpdateAction.Remove, codec2.key, EMPTY_BLOB];
+                    break;
                 }
-                break;
-            }
-            case UpdatePreimageKind.UpdateOrAdd: {
-                const { hash, length, slots } = action.item;
-                const codec = serialize_serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
-                yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, slots)];
-                break;
-            }
-            case UpdatePreimageKind.Remove: {
-                const { hash, length } = action;
-                const codec = serialize_serialize.servicePreimages(blake2b, serviceId, hash);
-                yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
-                const codec2 = serialize_serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
-                yield [StateEntryUpdateAction.Remove, codec2.key, EMPTY_BLOB];
-                break;
             }
-            default:
-                debug_assertNever(action);
         }
     }
 }
 function* serializeServiceUpdates(servicesUpdates, encode, blake2b) {
-    for (const { action, serviceId } of servicesUpdates ?? []) {
+    if (servicesUpdates === undefined) {
+        return;
+    }
+    for (const [serviceId, { action }] of servicesUpdates.entries()) {
         // new service being created or updated
         const codec = serialize_serialize.serviceData(serviceId);
         yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, action.account)];
@@ -13754,7 +13773,7 @@ class Preimages {
             }
         }
         const { preimages, slot } = input;
-        const pendingChanges = [];
+        const pendingChanges = new Map();
         // select preimages for integration
         for (const preimage of preimages) {
             const { requester, blob } = preimage;
@@ -13771,11 +13790,12 @@ class Preimages {
                 return Result.error(PreimagesErrorCode.PreimageUnneeded);
             }
             // https://graypaper.fluffylabs.dev/#/5f542d7/18c00018f300
-            pendingChanges.push(UpdatePreimage.provide({
-                serviceId: requester,
+            const updates = pendingChanges.get(requester) ?? [];
+            updates.push(UpdatePreimage.provide({
                 preimage: PreimageItem.create({ hash, blob }),
                 slot,
             }));
+            pendingChanges.set(requester, updates);
         }
         return Result.ok({
             preimages: pendingChanges,