@calimero-network/mero-js 24.1.0 → 24.1.1

package/dist/device-cert/device-cert.d.ts

@@ -46,11 +46,12 @@ export interface DeviceCertInput {
     deviceEpoch: number;
 }
 /**
- * Mint a device id: `H(DEVICE_ID_DOMAIN, account ‖ nonce)`.
+ * Mint a device id: `nonce ‖ H(DEVICE_ID_DOMAIN, account ‖ nonce)[..16]`.
  *
  * Derived from the account and a fresh nonce rather than from the device's keys,
- * so rotating a keypair keeps the replica identity — and with it the counter
- * slots and HLC lineage — intact.
+ * so rotating a keypair keeps the replica identity - and with it the counter
+ * slots and HLC lineage - intact. The hash half binds the id to its account:
+ * core refuses a certificate naming an id minted for another account.
  */
 export declare function mintDeviceId(account: string, nonce: Uint8Array): Promise<string>;
 /**

package/dist/device-cert/device-cert.js

@@ -34,18 +34,20 @@ export const ACCOUNT_GENESIS_VERSION = 2;
 /** Byte length of an `AccountProof<DeviceCert>` with an empty handoff chain. */
 const ACCOUNT_PROOF_BYTES = 237;
 /**
- * Mint a device id: `H(DEVICE_ID_DOMAIN, account ‖ nonce)`.
+ * Mint a device id: `nonce ‖ H(DEVICE_ID_DOMAIN, account ‖ nonce)[..16]`.
  *
  * Derived from the account and a fresh nonce rather than from the device's keys,
- * so rotating a keypair keeps the replica identity — and with it the counter
- * slots and HLC lineage — intact.
+ * so rotating a keypair keeps the replica identity - and with it the counter
+ * slots and HLC lineage - intact. The hash half binds the id to its account:
+ * core refuses a certificate naming an id minted for another account.
  */
 export async function mintDeviceId(account, nonce) {
     if (nonce.length !== 16) {
         throw new Error(`nonce must be 16 bytes, got ${nonce.length}`);
     }
     const accountBytes = fromHex(account, 'account', 32);
-    return hex(await domainHash(DEVICE_ID_DOMAIN, [accountBytes, nonce]));
+    const binding = await domainHash(DEVICE_ID_DOMAIN, [accountBytes, nonce]);
+    return hex(concat(nonce, binding.subarray(0, 16)));
 }
 /**
  * The 32 bytes a root signs to certify a device.

package/dist/events/sse.d.ts

@@ -1,4 +1,6 @@
 import type { GroupMembershipEventData, GroupMigrationEventData } from './group.js';
+/** How long a subscription POST may take before it counts as failed. */
+export declare const SUBSCRIPTION_TIMEOUT_MS = 10000;
 export type { GroupMembershipEventData, GroupMigrationEventData };
 export interface SseEventData {
     contextId: string;
@@ -109,6 +111,8 @@ export declare class SseClient {
         groupIds?: string[];
     }): Promise<void>;
     private sendSubscription;
+    /** Sends one subscription change and returns why it failed, or `null`. */
+    private postSubscription;
     private forceReconnect;
     private scheduleReconnect;
     close(): void;

package/dist/events/sse.js

@@ -17,6 +17,8 @@ const TERMINAL_AUTH_ERRORS = new Set(['token_reuse', 'token_revoked']);
  * `HTTPError(403)` and reconnected on a timer forever.
  */
 const TERMINAL_AUTH_STATUSES = new Set([401, 403]);
+/** How long a subscription POST may take before it counts as failed. */
+export const SUBSCRIPTION_TIMEOUT_MS = 10000;
 /**
  * Whether a failed response means the whole token family is gone, so the caller
  * must re-authenticate and the client must stop reconnecting.
@@ -233,18 +235,27 @@ export class SseClient {
             const msg = JSON.parse(jsonStr);
             // Connection message
             if (msg.type === 'connect' && msg.session_id) {
-                this.sessionId = msg.session_id;
-                this.emit('connect', msg.session_id);
+                const sessionId = msg.session_id;
+                this.sessionId = sessionId;
                 // A new connection gets a new replay when it re-subscribes; what the
                 // old one said may name authors who have since gone.
                 this.presence.clear();
-                // Re-subscribe after reconnect
-                if (this.subscribedContextIds.size > 0 || this.subscribedGroupIds.size > 0) {
-                    this.sendSubscription('subscribe', {
-                        contextIds: [...this.subscribedContextIds],
-                        groupIds: [...this.subscribedGroupIds],
-                    });
+                if (this.subscribedContextIds.size === 0 && this.subscribedGroupIds.size === 0) {
+                    this.emit('connect', sessionId);
+                    return;
                 }
+                // A new session starts subscribed to nothing, so announce it once the re-subscribe
+                // lands; a failed one still announces, then reports the error, as consumers saw before.
+                void this.postSubscription('subscribe', {
+                    contextIds: [...this.subscribedContextIds],
+                    groupIds: [...this.subscribedGroupIds],
+                }).then((failure) => {
+                    if (this.closed || this.sessionId !== sessionId)
+                        return;
+                    this.emit('connect', sessionId);
+                    if (failure)
+                        this.emit('error', failure);
+                });
                 return;
             }
             if (!msg.result)
@@ -348,6 +359,14 @@ export class SseClient {
         }
     }
     async sendSubscription(method, ids) {
+        const failure = await this.postSubscription(method, ids);
+        if (failure)
+            this.emit('error', failure);
+    }
+    /** Sends one subscription change and returns why it failed, or `null`. */
+    async postSubscription(method, ids) {
+        const timeout = new AbortController();
+        const timer = setTimeout(() => timeout.abort(new DOMException(`SSE ${method} timed out`, 'TimeoutError')), SUBSCRIPTION_TIMEOUT_MS);
         try {
             const params = {};
             if (ids.contextIds && ids.contextIds.length > 0)
@@ -367,6 +386,7 @@ export class SseClient {
                     'Content-Type': 'application/json',
                 },
                 body,
+                signal: timeout.signal,
             });
             if (!response.ok) {
                 // The subscribe path used to report only the status. On the one failure
@@ -377,13 +397,17 @@ export class SseClient {
                 // does carry a body.
                 const terminal = isTerminalAuthFailure(response);
                 const bodyText = await response.text().catch(() => undefined);
-                this.emit('error', terminal
+                return terminal
                     ? new AuthRevokedError(terminal, response.status, response.statusText, `${this.baseUrl}/sse/subscription`, response.headers, bodyText)
-                    : new HTTPError(response.status, response.statusText, `${this.baseUrl}/sse/subscription`, response.headers, bodyText));
+                    : new HTTPError(response.status, response.statusText, `${this.baseUrl}/sse/subscription`, response.headers, bodyText);
             }
+            return null;
         }
         catch (err) {
-            this.emit('error', err instanceof Error ? err : new Error(`SSE ${method} failed`));
+            return err instanceof Error ? err : new Error(`SSE ${method} failed`);
+        }
+        finally {
+            clearTimeout(timer);
         }
     }
     forceReconnect() {