@calimero-network/mero-js 19.16.0 → 19.18.0

package/dist/mero-js.d.ts

@@ -1,6 +1,7 @@
 import type { AuthApiClient } from './auth-api/index.js';
 import type { AdminApiClient } from './admin-api/index.js';
 import type { TokenStore } from './token-store/index.js';
+import type { ProofRequest, ProofSignerOptions } from './request/index.js';
 import type { AuthCallbackResult, AuthLoginOptions } from './auth/index.js';
 import { RpcClient } from './rpc/index.js';
 import { SseClient } from './events/sse.js';
@@ -20,6 +21,8 @@ export interface MeroJsConfig {
     timeoutMs?: number;
     /** Request credentials mode for fetch (omit, same-origin, include) */
     requestCredentials?: RequestCredentials;
+    /** Custom fetch for every HTTP request (`auth`, `admin`, `rpc`, `events`). Defaults to global `fetch`. */
+    fetch?: typeof fetch;
     /** Optional token store for persistence */
     tokenStore?: TokenStore;
     /**
@@ -44,6 +47,40 @@ export interface MeroJsConfig {
      * instead — it returns a connection that can write without one.
      */
     cloud?: CloudClientConfig;
+    /**
+     * Sign every request with a device key, instead of or alongside a session.
+     *
+     * A session is a bearer token: obtained once, presented many times. A
+     * request-carried proof commits to one method, one path and one body, so it
+     * is minted per call and cannot be lifted onto another request. It is what
+     * lets a client talk to a relay it has no account on — nothing was ever
+     * issued to it.
+     *
+     * Pass the keys and let the SDK mint each proof:
+     *
+     * ```ts
+     * new MeroJs({
+     *   baseUrl,
+     *   requestProof: { credential, session, signerSecret },
+     * });
+     * ```
+     *
+     * …or pass your own signer, when the key must not reach the SDK at all — a
+     * hardware token, or a worker that holds it:
+     *
+     * ```ts
+     * new MeroJs({ baseUrl, requestProof: (req) => myWorker.sign(req) });
+     * ```
+     *
+     * The node only honours this when it runs with `--delegated-access`; a node
+     * that does not answers `403`, which is distinct from the `401` a bad proof
+     * gets.
+     *
+     * Applies to the request/response API. `events` (SSE) and `ws` are long-lived
+     * connections rather than requests, so a per-request signature does not
+     * describe them — they still use the session.
+     */
+    requestProof?: ProofSignerOptions | ((request: ProofRequest) => Promise<string | undefined>);
 }
 export interface TokenData {
     access_token: string;

package/dist/mero-js.js

@@ -2,11 +2,24 @@ import { createBrowserHttpClient } from './http-client/index.js';
 import { createAuthApiClientFromHttpClient } from './auth-api/index.js';
 import { createAdminApiClientFromHttpClient } from './admin-api/index.js';
 import { parseAuthCallback, buildAuthLoginUrl } from './auth/index.js';
+import { createProofSigner } from './request/index.js';
 import { RpcClient } from './rpc/index.js';
 import { SseClient } from './events/sse.js';
 import { WsClient } from './events/ws.js';
 import { EphemeralClient } from './ephemeral/index.js';
 import { CloudClient } from './cloud/cloud-client.js';
+/**
+ * Accept either the keys or a ready signer.
+ *
+ * Taking a callback as well as an options object is not a convenience: it is
+ * how a caller keeps the signing key out of the SDK entirely when it lives
+ * somewhere the SDK cannot reach.
+ */
+function resolveProofSigner(config) {
+    if (!config)
+        return undefined;
+    return typeof config === 'function' ? config : createProofSigner(config);
+}
 /** Name of the Web Lock that serializes token refresh across tabs / webviews. */
 const REFRESH_LOCK_NAME = 'mero-js:token-refresh';
 /** Returns `navigator.locks` when the runtime supports the Web Locks API. */
@@ -58,8 +71,14 @@ export class MeroJs {
         // Create HTTP client with token management
         // For Tauri, explicitly set credentials to 'omit' to avoid network errors
         const isTauri = typeof window !== 'undefined' && '__TAURI_INTERNALS__' in window;
+        // One signer for the whole connection: `authClient` and `adminClient` are
+        // both built FROM this transport, so wiring it here covers every request
+        // either of them makes.
+        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 || '';
@@ -135,6 +154,7 @@ export class MeroJs {
         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 || '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calimero-network/mero-js",
-  "version": "19.16.0",
+  "version": "19.18.0",
   "description": "Pure JavaScript SDK for Calimero",
   "type": "module",
   "exports": {