@calimero-network/mero-js 19.16.0 → 19.18.0

package/dist/index.mjs

@@ -420,9 +420,9 @@ function createHttpClient(transport) {
 }
 function createBrowserHttpClient(options) {
   const transport = {
-    // Wrap fetch in arrow function to prevent "Illegal invocation" error
-    // This preserves the correct 'this' context when fetch is called
-    fetch: (url, init) => globalThis.fetch(url, init),
+    // globalThis.fetch must be called as a method on globalThis, not through a
+    // variable, or browsers throw "Illegal invocation".
+    fetch: (url, init) => options.fetch ? options.fetch(url, init) : globalThis.fetch(url, init),
     baseUrl: options.baseUrl,
     getAuthToken: options.getAuthToken,
     getProof: options.getProof,
@@ -1913,6 +1913,196 @@ function buildAuthLoginUrl(nodeUrl, opts) {
   return `${base}/auth/login?${params.toString()}`;
 }
 
+// src/crypto/internal.ts
+var PKCS8_ED25519_PREFIX = new Uint8Array([
+  48,
+  46,
+  2,
+  1,
+  0,
+  48,
+  5,
+  6,
+  3,
+  43,
+  101,
+  112,
+  4,
+  34,
+  4,
+  32
+]);
+function u32le(value) {
+  const out = new Uint8Array(4);
+  new DataView(out.buffer).setUint32(0, value, true);
+  return out;
+}
+function hex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function fromHex(value, label, expectedBytes) {
+  const clean = value.trim();
+  if (!/^[0-9a-fA-F]*$/.test(clean) || clean.length !== expectedBytes * 2) {
+    throw new Error(
+      `${label} must be ${expectedBytes * 2} hex characters, got ${clean.length}`
+    );
+  }
+  const bytes = new Uint8Array(expectedBytes);
+  for (let i = 0; i < expectedBytes; i += 1) {
+    bytes[i] = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function fromHexUnsized(value, label) {
+  const clean = value.trim();
+  if (!/^[0-9a-fA-F]*$/.test(clean) || clean.length % 2 !== 0) {
+    throw new Error(`${label} must be an even number of hex characters`);
+  }
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < bytes.length; i += 1) {
+    bytes[i] = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function u64le(value) {
+  const out = new Uint8Array(8);
+  new DataView(out.buffer).setBigUint64(0, BigInt(value), true);
+  return out;
+}
+function concat(...parts) {
+  const out = new Uint8Array(parts.reduce((total, p) => total + p.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+async function domainHash(domain, parts) {
+  const chunks = [u64le(domain.length), domain];
+  for (const part of parts) {
+    chunks.push(u64le(part.length), part);
+  }
+  return new Uint8Array(
+    await crypto.subtle.digest("SHA-256", concat(...chunks))
+  );
+}
+async function importSigningKey(secretHex) {
+  const seed = fromHex(secretHex, "deviceSecret", 32);
+  const pkcs8 = concat(PKCS8_ED25519_PREFIX, seed);
+  try {
+    return await crypto.subtle.importKey(
+      "pkcs8",
+      pkcs8,
+      { name: "Ed25519" },
+      false,
+      ["sign"]
+    );
+  } catch (cause) {
+    const detail = cause instanceof Error ? `: ${cause.message}` : "";
+    throw new Error(
+      "this runtime has no WebCrypto Ed25519, so a warrant cannot be signed here. Node 18.4+, Safari 17+, Firefox 129+ and Chrome 137+ have it; otherwise mint the warrant with `merod account warrant`" + detail
+    );
+  }
+}
+async function derivePublicKey(secretHex) {
+  const seed = fromHex(secretHex, "deviceSecret", 32);
+  const pkcs8 = concat(PKCS8_ED25519_PREFIX, seed);
+  const key = await crypto.subtle.importKey(
+    "pkcs8",
+    pkcs8,
+    { name: "Ed25519" },
+    true,
+    ["sign"]
+  );
+  const jwk = await crypto.subtle.exportKey("jwk", key);
+  const raw = jwk.x;
+  return Uint8Array.from(
+    atob(raw.replace(/-/g, "+").replace(/_/g, "/")),
+    (c) => c.charCodeAt(0)
+  );
+}
+
+// src/request/request-sig.ts
+var SIGN_DOMAIN = new TextEncoder().encode("calimero.auth.request.v1");
+var BODY_DOMAIN = new TextEncoder().encode("calimero.auth.request.body.v1");
+function borshString(value) {
+  const bytes = new TextEncoder().encode(value);
+  return concat(u32le(bytes.length), bytes);
+}
+async function requestBodyHash(body = new Uint8Array(0)) {
+  const bytes = typeof body === "string" ? new TextEncoder().encode(body) : body;
+  return domainHash(BODY_DOMAIN, [bytes]);
+}
+async function signRequest(input) {
+  const key = await importSigningKey(input.signerSecret);
+  const bodyHash = await requestBodyHash(input.body);
+  const issuedAt = u64le(input.issuedAt);
+  const expiresAt = u64le(input.expiresAt);
+  const encoder = new TextEncoder();
+  const preimage = await domainHash(SIGN_DOMAIN, [
+    encoder.encode(input.method),
+    encoder.encode(input.path),
+    bodyHash,
+    issuedAt,
+    expiresAt
+  ]);
+  const signature = new Uint8Array(
+    await crypto.subtle.sign({ name: "Ed25519" }, key, preimage)
+  );
+  return hex(
+    concat(
+      borshString(input.method),
+      borshString(input.path),
+      bodyHash,
+      issuedAt,
+      expiresAt,
+      signature
+    )
+  );
+}
+
+// src/request/caller-proof.ts
+function callerProof(input) {
+  const credential = fromHexUnsized(input.credential, "credential");
+  const request = fromHexUnsized(input.request, "request signature");
+  const session = input.session === void 0 ? new Uint8Array([0]) : concat(new Uint8Array([1]), fromHexUnsized(input.session, "session statement"));
+  return hex(concat(credential, session, request));
+}
+
+// src/request/proof-signer.ts
+function bodyBytes(body) {
+  if (body === void 0 || body === null) return new Uint8Array(0);
+  if (typeof body === "string") return body;
+  if (body instanceof Uint8Array) return body;
+  if (body instanceof ArrayBuffer) return new Uint8Array(body);
+  if (ArrayBuffer.isView(body)) {
+    return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+  }
+  throw new Error(
+    `a request-carried proof cannot commit to a ${body?.constructor?.name ?? typeof body} body: pass a string or bytes, or use a session for this call`
+  );
+}
+function createProofSigner(options) {
+  const ttl = options.ttlSeconds ?? 120;
+  const clock = options.now ?? (() => Math.floor(Date.now() / 1e3));
+  return async (request) => {
+    const issuedAt = clock();
+    return callerProof({
+      credential: options.credential,
+      session: options.session,
+      request: await signRequest({
+        method: request.method,
+        path: request.path,
+        body: bodyBytes(request.body),
+        issuedAt,
+        expiresAt: issuedAt + ttl,
+        signerSecret: options.signerSecret
+      })
+    });
+  };
+}
+
 // src/rpc/index.ts
 var RpcError = class extends Error {
   constructor(code, message, data, type) {
@@ -1998,6 +2188,7 @@ var SseClient = class {
     this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
     this.getAuthToken = opts.getAuthToken;
     this.reconnectDelayMs = opts.reconnectDelayMs ?? 3e3;
+    this.fetchImpl = (url, init) => opts.fetch ? opts.fetch(url, init) : globalThis.fetch(url, init);
   }
   on(event, handler) {
     const key = event;
@@ -2064,7 +2255,7 @@ var SseClient = class {
     try {
       const token = await this.getAuthToken();
       const url = `${this.baseUrl}/sse`;
-      const response = await fetch(url, {
+      const response = await this.fetchImpl(url, {
         headers: {
           "Authorization": `Bearer ${token}`,
           "Accept": "text/event-stream"
@@ -2223,7 +2414,7 @@ var SseClient = class {
       const params = {};
       if (ids.contextIds && ids.contextIds.length > 0) params.contextIds = ids.contextIds;
       if (ids.groupIds && ids.groupIds.length > 0) params.groupIds = ids.groupIds;
-      const response = await fetch(`${this.baseUrl}/sse/subscription`, {
+      const response = await this.fetchImpl(`${this.baseUrl}/sse/subscription`, {
         method: "POST",
         headers: {
           "Authorization": `Bearer ${token}`,
@@ -2552,116 +2743,6 @@ var EphemeralClient = class {
   }
 };
 
-// src/crypto/internal.ts
-var PKCS8_ED25519_PREFIX = new Uint8Array([
-  48,
-  46,
-  2,
-  1,
-  0,
-  48,
-  5,
-  6,
-  3,
-  43,
-  101,
-  112,
-  4,
-  34,
-  4,
-  32
-]);
-function u32le(value) {
-  const out = new Uint8Array(4);
-  new DataView(out.buffer).setUint32(0, value, true);
-  return out;
-}
-function hex(bytes) {
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-}
-function fromHex(value, label, expectedBytes) {
-  const clean = value.trim();
-  if (!/^[0-9a-fA-F]*$/.test(clean) || clean.length !== expectedBytes * 2) {
-    throw new Error(
-      `${label} must be ${expectedBytes * 2} hex characters, got ${clean.length}`
-    );
-  }
-  const bytes = new Uint8Array(expectedBytes);
-  for (let i = 0; i < expectedBytes; i += 1) {
-    bytes[i] = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-function fromHexUnsized(value, label) {
-  const clean = value.trim();
-  if (!/^[0-9a-fA-F]*$/.test(clean) || clean.length % 2 !== 0) {
-    throw new Error(`${label} must be an even number of hex characters`);
-  }
-  const bytes = new Uint8Array(clean.length / 2);
-  for (let i = 0; i < bytes.length; i += 1) {
-    bytes[i] = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-function u64le(value) {
-  const out = new Uint8Array(8);
-  new DataView(out.buffer).setBigUint64(0, BigInt(value), true);
-  return out;
-}
-function concat(...parts) {
-  const out = new Uint8Array(parts.reduce((total, p) => total + p.length, 0));
-  let offset = 0;
-  for (const part of parts) {
-    out.set(part, offset);
-    offset += part.length;
-  }
-  return out;
-}
-async function domainHash(domain, parts) {
-  const chunks = [u64le(domain.length), domain];
-  for (const part of parts) {
-    chunks.push(u64le(part.length), part);
-  }
-  return new Uint8Array(
-    await crypto.subtle.digest("SHA-256", concat(...chunks))
-  );
-}
-async function importSigningKey(secretHex) {
-  const seed = fromHex(secretHex, "deviceSecret", 32);
-  const pkcs8 = concat(PKCS8_ED25519_PREFIX, seed);
-  try {
-    return await crypto.subtle.importKey(
-      "pkcs8",
-      pkcs8,
-      { name: "Ed25519" },
-      false,
-      ["sign"]
-    );
-  } catch (cause) {
-    const detail = cause instanceof Error ? `: ${cause.message}` : "";
-    throw new Error(
-      "this runtime has no WebCrypto Ed25519, so a warrant cannot be signed here. Node 18.4+, Safari 17+, Firefox 129+ and Chrome 137+ have it; otherwise mint the warrant with `merod account warrant`" + detail
-    );
-  }
-}
-async function derivePublicKey(secretHex) {
-  const seed = fromHex(secretHex, "deviceSecret", 32);
-  const pkcs8 = concat(PKCS8_ED25519_PREFIX, seed);
-  const key = await crypto.subtle.importKey(
-    "pkcs8",
-    pkcs8,
-    { name: "Ed25519" },
-    true,
-    ["sign"]
-  );
-  const jwk = await crypto.subtle.exportKey("jwk", key);
-  const raw = jwk.x;
-  return Uint8Array.from(
-    atob(raw.replace(/-/g, "+").replace(/_/g, "/")),
-    (c) => c.charCodeAt(0)
-  );
-}
-
 // src/device-cert/device-cert.ts
 var CERT_DOMAIN = new TextEncoder().encode("calimero.device.cert.v1");
 var ACCOUNT_ID_DOMAIN = new TextEncoder().encode("calimero.account.genesis.v1");
@@ -5659,6 +5740,10 @@ var CloudClient = class {
 };
 
 // src/mero-js.ts
+function resolveProofSigner(config) {
+  if (!config) return void 0;
+  return typeof config === "function" ? config : createProofSigner(config);
+}
 var REFRESH_LOCK_NAME = "mero-js:token-refresh";
 function getLockManager() {
   const nav = globalThis.navigator;
@@ -5697,8 +5782,11 @@ var MeroJs = class {
       this.tokenData = this.tokenStore.getTokens();
     }
     const isTauri = typeof window !== "undefined" && "__TAURI_INTERNALS__" in window;
+    const getProof = resolveProofSigner(this.config.requestProof);
     this.httpClient = createBrowserHttpClient({
       baseUrl: this.config.baseUrl,
+      fetch: this.config.fetch,
+      getProof,
       getAuthToken: async () => {
         const token = await this.getValidToken();
         return token?.access_token || "";
@@ -5768,6 +5856,7 @@ var MeroJs = class {
     if (!this.sseClient) {
       this.sseClient = new SseClient({
         baseUrl: this.config.baseUrl,
+        fetch: this.config.fetch,
         getAuthToken: async () => {
           const token = await this.getValidToken();
           return token?.access_token || "";
@@ -6052,7 +6141,7 @@ var LocalStorageTokenStore = class {
 };
 
 // src/warrant/warrant.ts
-var SIGN_DOMAIN = new TextEncoder().encode("calimero.warrant.v2");
+var SIGN_DOMAIN2 = new TextEncoder().encode("calimero.warrant.v2");
 var INTENT_DOMAIN = new TextEncoder().encode("calimero.warrant.intent.v1");
 var MAX_CITED_HEADS = 64;
 var UNPINNED_APP = "00".repeat(32);
@@ -6077,7 +6166,7 @@ async function signWarrant(input) {
   const commitment = await intentHash(input.method, input.argsJson);
   const nonce = u64le(input.nonce);
   const notAfter = u64le(input.notAfter);
-  const preimage = await domainHash(SIGN_DOMAIN, [
+  const preimage = await domainHash(SIGN_DOMAIN2, [
     context,
     authorAccount,
     publicKey,
@@ -6396,7 +6485,7 @@ function optionalBytes32(value, label) {
   }
   return concat(new Uint8Array([1]), new Uint8Array(value));
 }
-function borshString(value) {
+function borshString2(value) {
   const bytes = new TextEncoder().encode(value);
   return concat(u32le(bytes.length), bytes);
 }
@@ -6420,7 +6509,7 @@ function encodeSignedInvitation(signed) {
     // ...then the enclosing SignedGroupOpenInvitation, in declaration order.
     // `inviter_account` sits between the signature and the addresses; putting it
     // anywhere else still encodes 32 bytes and still verifies as nothing.
-    borshString(signed.inviter_signature),
+    borshString2(signed.inviter_signature),
     signed.inviter_account ? concat(new Uint8Array([1]), fromHex(signed.inviter_account, "inviter_account", 32)) : new Uint8Array([0]),
     // A `Vec<String>`, so each entry is a bare borsh string. This carried an
     // enum until core dropped the URL variant, and an enum writes a
@@ -6428,7 +6517,7 @@ function encodeSignedInvitation(signed) {
     // every following byte and fail as `invalid invitation signature`, pointing
     // nowhere near this line.
     u32le(admitterAddrs.length),
-    ...admitterAddrs.map(borshString),
+    ...admitterAddrs.map(borshString2),
     optionalBytes32(signed.application_id, "application_id"),
     // Borsh order follows core's field order, where this is `bytecode_id`; the
     // JSON key is `app_key`, a rename covering both directions that core pins in
@@ -6473,86 +6562,6 @@ async function signMemberJoinOp(input) {
   return hex(concat(signable, signature, unendorsed));
 }
 
-// src/request/request-sig.ts
-var SIGN_DOMAIN2 = new TextEncoder().encode("calimero.auth.request.v1");
-var BODY_DOMAIN = new TextEncoder().encode("calimero.auth.request.body.v1");
-function borshString2(value) {
-  const bytes = new TextEncoder().encode(value);
-  return concat(u32le(bytes.length), bytes);
-}
-async function requestBodyHash(body = new Uint8Array(0)) {
-  const bytes = typeof body === "string" ? new TextEncoder().encode(body) : body;
-  return domainHash(BODY_DOMAIN, [bytes]);
-}
-async function signRequest(input) {
-  const key = await importSigningKey(input.signerSecret);
-  const bodyHash = await requestBodyHash(input.body);
-  const issuedAt = u64le(input.issuedAt);
-  const expiresAt = u64le(input.expiresAt);
-  const encoder = new TextEncoder();
-  const preimage = await domainHash(SIGN_DOMAIN2, [
-    encoder.encode(input.method),
-    encoder.encode(input.path),
-    bodyHash,
-    issuedAt,
-    expiresAt
-  ]);
-  const signature = new Uint8Array(
-    await crypto.subtle.sign({ name: "Ed25519" }, key, preimage)
-  );
-  return hex(
-    concat(
-      borshString2(input.method),
-      borshString2(input.path),
-      bodyHash,
-      issuedAt,
-      expiresAt,
-      signature
-    )
-  );
-}
-
-// src/request/caller-proof.ts
-function callerProof(input) {
-  const credential = fromHexUnsized(input.credential, "credential");
-  const request = fromHexUnsized(input.request, "request signature");
-  const session = input.session === void 0 ? new Uint8Array([0]) : concat(new Uint8Array([1]), fromHexUnsized(input.session, "session statement"));
-  return hex(concat(credential, session, request));
-}
-
-// src/request/proof-signer.ts
-function bodyBytes(body) {
-  if (body === void 0 || body === null) return new Uint8Array(0);
-  if (typeof body === "string") return body;
-  if (body instanceof Uint8Array) return body;
-  if (body instanceof ArrayBuffer) return new Uint8Array(body);
-  if (ArrayBuffer.isView(body)) {
-    return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
-  }
-  throw new Error(
-    `a request-carried proof cannot commit to a ${body?.constructor?.name ?? typeof body} body: pass a string or bytes, or use a session for this call`
-  );
-}
-function createProofSigner(options) {
-  const ttl = options.ttlSeconds ?? 120;
-  const clock = options.now ?? (() => Math.floor(Date.now() / 1e3));
-  return async (request) => {
-    const issuedAt = clock();
-    return callerProof({
-      credential: options.credential,
-      session: options.session,
-      request: await signRequest({
-        method: request.method,
-        path: request.path,
-        body: bodyBytes(request.body),
-        issuedAt,
-        expiresAt: issuedAt + ttl,
-        signerSecret: options.signerSecret
-      })
-    });
-  };
-}
-
 // src/login/login.ts
 var SIGN_DOMAIN3 = new TextEncoder().encode("calimero.auth.login.v1");
 var AUDIENCE_TAG = {