@calimero-network/mero-js 13.1.0 → 13.2.1

package/dist/index.cjs

@@ -60,6 +60,9 @@ __export(index_exports, {
   nodeEndpoint: () => nodeEndpoint,
   parseAuthCallback: () => parseAuthCallback,
   probeNodeHealth: () => probeNodeHealth,
+  sameAccount: () => sameAccount,
+  toAccountBase58: () => toAccountBase58,
+  toAccountHex: () => toAccountHex,
   withCap: () => withCap,
   withRetry: () => withRetry,
   withoutCap: () => withoutCap
@@ -1193,13 +1196,17 @@ var AdminApiClient = class {
     );
   }
   async joinNamespace(namespaceId, request) {
-    return unwrap(
+    const data = unwrap(
       await this.httpClient.post(
         `/admin-api/namespaces/${namespaceId}/join`,
         request,
         { timeoutMs: 65e3 }
       )
     );
+    if (data && data.namespaceId === void 0 && data.groupId !== void 0) {
+      return { ...data, namespaceId: data.groupId };
+    }
+    return data;
   }
   async createGroupInNamespace(namespaceId, request) {
     return unwrap(
@@ -1595,6 +1602,7 @@ function isGroupMigrationEvent(event) {
 }
 
 // src/events/sse.ts
+var TERMINAL_AUTH_ERRORS2 = /* @__PURE__ */ new Set(["token_reuse", "token_revoked"]);
 var SseClient = class {
   constructor(opts) {
     this.sessionId = null;
@@ -1672,7 +1680,8 @@ var SseClient = class {
     this.abortController = new AbortController();
     try {
       const token = await this.getAuthToken();
-      const response = await fetch(`${this.baseUrl}/sse`, {
+      const url = `${this.baseUrl}/sse`;
+      const response = await fetch(url, {
         headers: {
           "Authorization": `Bearer ${token}`,
           "Accept": "text/event-stream"
@@ -1680,7 +1689,25 @@ var SseClient = class {
         signal: this.abortController.signal
       });
       if (!response.ok) {
-        throw new Error(`SSE connection failed: ${response.status}`);
+        const authError = response.headers.get("x-auth-error");
+        const bodyText = await response.text().catch(() => void 0);
+        if (response.status === 401 && authError && TERMINAL_AUTH_ERRORS2.has(authError)) {
+          throw new AuthRevokedError(
+            authError,
+            response.status,
+            response.statusText,
+            url,
+            response.headers,
+            bodyText
+          );
+        }
+        throw new HTTPError(
+          response.status,
+          response.statusText,
+          url,
+          response.headers,
+          bodyText
+        );
       }
       if (!response.body) {
         throw new Error("SSE response has no body");
@@ -2446,6 +2473,93 @@ function createMeroJs(config) {
   return new MeroJs(config);
 }
 
+// src/account/index.ts
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var HEX_ACCOUNT = /^[0-9a-f]{64}$/i;
+function encodeBase58(bytes) {
+  if (bytes.length === 0) return "";
+  const digits = [0];
+  for (const byte of bytes) {
+    let carry = byte;
+    for (let i = 0; i < digits.length; i++) {
+      carry += digits[i] << 8;
+      digits[i] = carry % 58;
+      carry = carry / 58 | 0;
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = carry / 58 | 0;
+    }
+  }
+  let out = "";
+  for (const byte of bytes) {
+    if (byte !== 0) break;
+    out += BASE58_ALPHABET[0];
+  }
+  for (let i = digits.length - 1; i >= 0; i--) {
+    out += BASE58_ALPHABET[digits[i]];
+  }
+  return out;
+}
+function decodeBase58(value) {
+  if (value.length === 0) return null;
+  const bytes = [0];
+  for (const char of value) {
+    const index = BASE58_ALPHABET.indexOf(char);
+    if (index < 0) return null;
+    let carry = index;
+    for (let i = 0; i < bytes.length; i++) {
+      carry += bytes[i] * 58;
+      bytes[i] = carry & 255;
+      carry >>= 8;
+    }
+    while (carry > 0) {
+      bytes.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  let leadingZeros = 0;
+  for (const char of value) {
+    if (char !== BASE58_ALPHABET[0]) break;
+    leadingZeros++;
+  }
+  return Uint8Array.from([
+    ...new Array(leadingZeros).fill(0),
+    ...bytes.reverse()
+  ]);
+}
+function toHex(bytes) {
+  let out = "";
+  for (const byte of bytes) out += byte.toString(16).padStart(2, "0");
+  return out;
+}
+function fromHex(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function toAccountHex(id) {
+  const trimmed = (id ?? "").trim();
+  if (!trimmed) return "";
+  if (HEX_ACCOUNT.test(trimmed)) return trimmed.toLowerCase();
+  const decoded = decodeBase58(trimmed);
+  if (!decoded || decoded.length !== 32) return trimmed;
+  return toHex(decoded);
+}
+function toAccountBase58(id) {
+  const trimmed = (id ?? "").trim();
+  if (!trimmed) return "";
+  if (!HEX_ACCOUNT.test(trimmed)) return trimmed;
+  return encodeBase58(fromHex(trimmed));
+}
+function sameAccount(a, b) {
+  const left = toAccountHex(a);
+  const right = toAccountHex(b);
+  return HEX_ACCOUNT.test(left) && left === right;
+}
+
 // src/token-store/index.ts
 var MemoryTokenStore = class {
   constructor() {