@calimero-network/mero-js 19.15.0 → 19.17.0

package/dist/index.d.ts

@@ -24,7 +24,8 @@ export type { DeviceCertInput } from "./device-cert/index.js";
 export { signMemberJoinOp, encodeSignedInvitation, SIGNED_NAMESPACE_OP_SCHEMA_VERSION, } from "./namespace-op/index.js";
 export type { SignMemberJoinInput } from "./namespace-op/index.js";
 export type { WarrantInput } from "./warrant/index.js";
-export { requestBodyHash, signRequest } from "./request/index.js";
+export { requestBodyHash, signRequest, callerProof, createProofSigner, } from "./request/index.js";
+export type { CallerProofInput, ProofRequest, ProofSignerOptions, } from "./request/index.js";
 export type { RequestSigInput } from "./request/index.js";
 export { signLoginStatement } from "./login/index.js";
 export type { Audience, LoginStatementInput } from "./login/index.js";

package/dist/index.js

@@ -29,7 +29,7 @@ export { generateAccountRoot, accountRootFromPhrase, accountRootFromSecret, sign
 export { signDeviceCert, mintDeviceId, deviceCertPayload, accountForRoot, } from "./device-cert/index.js";
 export { signMemberJoinOp, encodeSignedInvitation, SIGNED_NAMESPACE_OP_SCHEMA_VERSION, } from "./namespace-op/index.js";
 // Login-statement signing — the device's half of a password-free session
-export { requestBodyHash, signRequest } from "./request/index.js";
+export { requestBodyHash, signRequest, callerProof, createProofSigner, } from "./request/index.js";
 export { signLoginStatement } from "./login/index.js";
 export { login, generateSessionKey } from "./login/index.js";
 // Member capability bitmask constants & helpers

package/dist/index.mjs

@@ -85,6 +85,14 @@ function headersToRecord(headers) {
   });
   return record;
 }
+function pathForProof(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    const query = url.indexOf("?");
+    return query === -1 ? url : url.slice(0, query);
+  }
+}
 var WebHttpClient = class {
   constructor(transport) {
     this.transport = transport;
@@ -211,6 +219,16 @@ var WebHttpClient = class {
     if (init?.keepalive !== void 0) {
       requestInit.keepalive = init.keepalive;
     }
+    if (this.transport.getProof) {
+      const proof = await this.transport.getProof({
+        method: requestInit.method ?? "GET",
+        path: pathForProof(url),
+        body: requestInit.body
+      });
+      if (proof) {
+        headersObj["X-Calimero-Proof"] = proof;
+      }
+    }
     try {
       const response = await this.transport.fetch(url, requestInit);
       if (!response.ok) {
@@ -407,6 +425,7 @@ function createBrowserHttpClient(options) {
     fetch: (url, init) => globalThis.fetch(url, init),
     baseUrl: options.baseUrl,
     getAuthToken: options.getAuthToken,
+    getProof: options.getProof,
     onTokenRefresh: options.onTokenRefresh,
     refreshToken: options.refreshToken,
     onAuthRevoked: options.onAuthRevoked,
@@ -433,6 +452,7 @@ function createNodeHttpClient(options) {
     fetch: isDefaultFetch ? (url, init) => globalThis.fetch(url, init) : (url, init) => fetchImpl(url, init),
     baseUrl: options.baseUrl,
     getAuthToken: options.getAuthToken,
+    getProof: options.getProof,
     onTokenRefresh: options.onTokenRefresh,
     refreshToken: options.refreshToken,
     onAuthRevoked: options.onAuthRevoked,
@@ -1893,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) {
@@ -2532,105 +2742,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 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");
@@ -5628,6 +5739,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;
@@ -5666,8 +5781,10 @@ 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,
+      getProof,
       getAuthToken: async () => {
         const token = await this.getValidToken();
         return token?.access_token || "";
@@ -6021,7 +6138,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);
@@ -6046,7 +6163,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,
@@ -6365,7 +6482,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);
 }
@@ -6389,7 +6506,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
@@ -6397,7 +6514,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
@@ -6442,45 +6559,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/login/login.ts
 var SIGN_DOMAIN3 = new TextEncoder().encode("calimero.auth.login.v1");
 var AUDIENCE_TAG = {
@@ -6722,6 +6800,7 @@ export {
   accountRootFromPhrase,
   accountRootFromSecret,
   buildAuthLoginUrl,
+  callerProof,
   combineSignals,
   compareSemver,
   connectCloud,
@@ -6739,6 +6818,7 @@ export {
   createNodeAdminApiClient,
   createNodeAuthApiClient,
   createNodeHttpClient,
+  createProofSigner,
   createRetryableMethod,
   createTimeoutSignal,
   createUniversalHttpClient,