@typeberry/jam 0.2.0-8017bfd → 0.2.0-adde0dd

package/bootstrap-generator.mjs

@@ -3170,7 +3170,7 @@ function resultToString(res) {
     if (res.isOk) {
         return `OK: ${typeof res.ok === "symbol" ? res.ok.toString() : res.ok}`;
     }
-    return `${res.details}\nError: ${maybeTaggedErrorToString(res.error)}`;
+    return `${res.details()}\nError: ${maybeTaggedErrorToString(res.error)}`;
 }
 /** An indication of two possible outcomes returned from a function. */
 const result_Result = {
@@ -3184,7 +3184,7 @@ const result_Result = {
         };
     },
     /** Create new [`Result`] with `Error` status. */
-    error: (error, details = "") => {
+    error: (error, details) => {
         debug_check `${error !== undefined} 'Error' type cannot be undefined.`;
         return {
             isOk: false,
@@ -3303,7 +3303,7 @@ function deepEqual(actual, expected, { context = [], errorsCollector, ignore = [
         }
         if (actual.isError && expected.isError) {
             deepEqual(actual.error, expected.error, { context: ctx.concat(["error"]), errorsCollector: errors, ignore });
-            deepEqual(actual.details, expected.details, {
+            deepEqual(actual.details(), expected.details(), {
                 context: ctx.concat(["details"]),
                 errorsCollector: errors,
                 // display details when error does not match
@@ -10517,7 +10517,7 @@ class in_memory_state_InMemoryState extends WithDebug {
                 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}`);
+                    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;
@@ -10545,14 +10545,14 @@ class in_memory_state_InMemoryState extends WithDebug {
         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}`);
+                return result_Result.error(in_memory_state_UpdateError.NoService, () => `Attempting to update preimage of non-existing service: ${serviceId}`);
             }
             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}`);
+                        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) {
@@ -10603,7 +10603,7 @@ class in_memory_state_InMemoryState extends WithDebug {
             if (kind === UpdateServiceKind.Create) {
                 const { lookupHistory } = update.action;
                 if (this.services.has(serviceId)) {
-                    return result_Result.error(in_memory_state_UpdateError.DuplicateService, `${serviceId} already exists!`);
+                    return result_Result.error(in_memory_state_UpdateError.DuplicateService, () => `${serviceId} already exists!`);
                 }
                 this.services.set(serviceId, new InMemoryService(serviceId, {
                     info: account,
@@ -10615,7 +10615,7 @@ class in_memory_state_InMemoryState extends WithDebug {
             else if (kind === UpdateServiceKind.Update) {
                 const existingService = this.services.get(serviceId);
                 if (existingService === undefined) {
-                    return result_Result.error(in_memory_state_UpdateError.NoService, `Cannot update ${serviceId} because it does not exist.`);
+                    return result_Result.error(in_memory_state_UpdateError.NoService, () => `Cannot update ${serviceId} because it does not exist.`);
                 }
                 existingService.data.info = account;
             }
@@ -12245,13 +12245,13 @@ class LeafDb {
      */
     static fromLeavesBlob(blob, db) {
         if (blob.length % TRIE_NODE_BYTES !== 0) {
-            return result_Result.error(LeafDbError.InvalidLeafData, `${blob.length} is not a multiply of ${TRIE_NODE_BYTES}: ${blob}`);
+            return result_Result.error(LeafDbError.InvalidLeafData, () => `${blob.length} is not a multiply of ${TRIE_NODE_BYTES}: ${blob}`);
         }
         const leaves = SortedSet.fromArray(leafComparator, []);
         for (const nodeData of blob.chunks(TRIE_NODE_BYTES)) {
             const node = new TrieNode(nodeData.raw);
             if (node.getNodeType() === NodeType.Branch) {
-                return result_Result.error(LeafDbError.InvalidLeafData, `Branch node detected: ${nodeData}`);
+                return result_Result.error(LeafDbError.InvalidLeafData, () => `Branch node detected: ${nodeData}`);
             }
             leaves.insert(node.asLeafNode());
         }
@@ -12970,7 +12970,7 @@ class LmdbStates {
         }
         catch (e) {
             logger.error `${e}`;
-            return result_Result.error(StateUpdateError.Commit);
+            return result_Result.error(StateUpdateError.Commit, () => `Failed to commit state update: ${e}`);
         }
         return result_Result.ok(result_OK);
     }
@@ -13769,7 +13769,7 @@ class Preimages {
             }
             if (prevPreimage.requester > currPreimage.requester ||
                 currPreimage.blob.compare(prevPreimage.blob).isLessOrEqual()) {
-                return Result.error(PreimagesErrorCode.PreimagesNotSortedUnique);
+                return Result.error(PreimagesErrorCode.PreimagesNotSortedUnique, () => `Preimages not sorted/unique at index ${i}`);
             }
         }
         const { preimages, slot } = input;
@@ -13780,14 +13780,14 @@ class Preimages {
             const hash = this.blake2b.hashBytes(blob).asOpaque();
             const service = this.state.getService(requester);
             if (service === null) {
-                return Result.error(PreimagesErrorCode.AccountNotFound);
+                return Result.error(PreimagesErrorCode.AccountNotFound, () => `Service not found: ${requester}`);
             }
             const hasPreimage = service.hasPreimage(hash);
             const slots = service.getLookupHistory(hash, tryAsU32(blob.length));
             // https://graypaper.fluffylabs.dev/#/5f542d7/181800181900
             // https://graypaper.fluffylabs.dev/#/5f542d7/116f0011a500
             if (hasPreimage || slots === null || !LookupHistoryItem.isRequested(slots)) {
-                return Result.error(PreimagesErrorCode.PreimageUnneeded);
+                return Result.error(PreimagesErrorCode.PreimageUnneeded, () => `Preimage unneeded: requester=${requester}, hash=${hash}, hasPreimage=${hasPreimage}, isRequested=${slots !== null && LookupHistoryItem.isRequested(slots)}`);
             }
             // https://graypaper.fluffylabs.dev/#/5f542d7/18c00018f300
             const updates = pendingChanges.get(requester) ?? [];