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

package/bootstrap-network.mjs

@@ -24333,7 +24333,7 @@ function result_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 = {
@@ -24347,7 +24347,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,
@@ -24466,7 +24466,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
@@ -33228,7 +33228,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 === state_update_UpdateStorageKind.Set) {
                     const { key, value } = update.action.storage;
@@ -33256,14 +33256,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 === state_update_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) {
@@ -33314,7 +33314,7 @@ class in_memory_state_InMemoryState extends WithDebug {
             if (kind === state_update_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,
@@ -33326,7 +33326,7 @@ class in_memory_state_InMemoryState extends WithDebug {
             else if (kind === state_update_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;
             }
@@ -34956,13 +34956,13 @@ class leaf_db_LeafDb {
      */
     static fromLeavesBlob(blob, db) {
         if (blob.length % TRIE_NODE_BYTES !== 0) {
-            return Result.error(LeafDbError.InvalidLeafData, `${blob.length} is not a multiply of ${TRIE_NODE_BYTES}: ${blob}`);
+            return 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.error(LeafDbError.InvalidLeafData, `Branch node detected: ${nodeData}`);
+                return Result.error(LeafDbError.InvalidLeafData, () => `Branch node detected: ${nodeData}`);
             }
             leaves.insert(node.asLeafNode());
         }
@@ -35355,7 +35355,7 @@ class LmdbStates {
         }
         catch (e) {
             states_logger.error `${e}`;
-            return Result.error(StateUpdateError.Commit);
+            return Result.error(StateUpdateError.Commit, () => `Failed to commit state update: ${e}`);
         }
         return Result.ok(OK);
     }
@@ -36622,20 +36622,20 @@ async function verifyCertificate(certs) {
     // Must present exactly one cert
     if (certs.length !== 1) {
         certificate_logger.log `Rejecting peer: expected exactly one certificate, got: ${certs.length}`;
-        return result_Result.error(VerifyCertError.NoCertificate);
+        return result_Result.error(VerifyCertError.NoCertificate, () => `Certificate validation failed: expected exactly one certificate, got ${certs.length}`);
     }
     // Parse with Node's X509Certificate (accepts PEM or DER)
     const xc = new (external_node_crypto_default()).X509Certificate(certs[0]);
     // Must be Ed25519 key
     if (xc.publicKey.asymmetricKeyType !== CURVE_NAME.toLowerCase()) {
         certificate_logger.log `Rejecting peer using non-ed25519 certificate: ${xc.publicKey.asymmetricKeyType}`;
-        return result_Result.error(VerifyCertError.NotEd25519);
+        return result_Result.error(VerifyCertError.NotEd25519, () => `Certificate validation failed: expected Ed25519 key, got ${xc.publicKey.asymmetricKeyType}`);
     }
     // Extract raw public key via JWK export
     const jwk = xc.publicKey.export({ format: "jwk" });
     if (jwk.kty !== KEY_TYPE || jwk.crv !== CURVE_NAME) {
         certificate_logger.log `Public key type mismatch: ${jwk.kty}, ${jwk.crv}`;
-        return result_Result.error(VerifyCertError.PublicKeyTypeMismatch);
+        return result_Result.error(VerifyCertError.PublicKeyTypeMismatch, () => `Certificate validation failed: public key type mismatch (kty: ${jwk.kty}, crv: ${jwk.crv})`);
     }
     // SAN must be exactly 'e'+base32(rawPub)
     const expectedSan = altNameJwk(jwk);
@@ -36643,11 +36643,11 @@ async function verifyCertificate(certs) {
     const m = sanField.match(/DNS:([^,]+)/);
     if (m === null || m[1] !== expectedSan) {
         certificate_logger.log `AltName mismatch. Expected: '${expectedSan}', got: '${m?.[1]}'`;
-        return result_Result.error(VerifyCertError.AltNameMismatch);
+        return result_Result.error(VerifyCertError.AltNameMismatch, () => `Certificate validation failed: altName mismatch (expected: ${expectedSan}, got: ${m?.[1] ?? "none"})`);
     }
     const key = Buffer.from(jwk.x ?? "", "base64url");
     if (!xc.verify(xc.publicKey)) {
-        return result_Result.error(VerifyCertError.IncorrectSignature);
+        return result_Result.error(VerifyCertError.IncorrectSignature, () => "Certificate validation failed: incorrect signature");
     }
     const publicKey = bytes_Bytes.fromBlob(new Uint8Array(key), ED25519_KEY_BYTES);
     return result_Result.ok({
@@ -37681,7 +37681,7 @@ function handleGetBlockSequence(chainSpec, blocks, startHash, direction, limit)
     };
     const startBlock = getBlockView(startHash);
     if (startBlock === null) {
-        return result_Result.error(BlockSequenceError.NoStartBlock);
+        return result_Result.error(BlockSequenceError.NoStartBlock, () => `Block sequence error: start block ${startHash} not found`);
     }
     if (direction === Direction.AscExcl) {
         // Since we don't have an index of all blocks, we need to start from
@@ -37693,7 +37693,7 @@ function handleGetBlockSequence(chainSpec, blocks, startHash, direction, limit)
             const currentHeader = blocks.getHeader(currentHash);
             // some errornuous situation, we didn't really reach the block?
             if (currentHeader === null || currentHeader.timeSlotIndex.materialize() < startIndex) {
-                return result_Result.error(BlockSequenceError.BlockOnFork);
+                return result_Result.error(BlockSequenceError.BlockOnFork, () => `Block sequence error: start block ${startHash} appears to be on a fork`);
             }
             // we have everything we need, let's return it now
             if (startHash.isEqualTo(currentHash)) {