@droponair/sdk-js 0.31.0 → 0.32.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.32.0
+
+### Added
+
+- **Run a second identity alongside the first.** `initialize` now takes a name, and
+  each named instance gets its own connection, its own token, and its own key
+  storage. The identities are not linkable to each other by anyone observing
+  them, which a single instance could not offer: every message carries the
+  publisher's user id to its recipients, so one identity meant one visible
+  identity everywhere the app spoke.
+
+  Use it when an app needs a long-lived identity for the user's own
+  conversations plus a short-lived or anonymous one for an ephemeral context.
+  
+  ```ts
+  const mine = await initialize({ ...opts });
+  const anon = await initialize({ ...opts, instanceName: 'nearby' });
+  ```
+
+  A `storage` adapter you supply yourself is used exactly as given, so give each
+  instance its own; only the default storage is namespaced for you.
+
+  Existing code is unaffected. Calls without a name use the instance named
+  `default`, which keeps the key storage an app already has, so upgrading does
+  not change the identity a device has been using.
+
+
 ## 0.31.0
 
 ### Fixed

package/README.md

@@ -681,6 +681,34 @@ client.onGroupCallEvent((evt) => {
 - Mute is intentionally a signaling hint: WebRTC media tracks can't be muted from outside the producing client. Remove is server-enforced - the target SDK receives `GROUP_CALL_PARTICIPANT_REMOVED` and the others receive `PARTICIPANT_LEFT`.
 - Availability depends on your plan. See the [pricing page](https://www.droponair.com/pricing) and your dashboard Subscription page for what's enabled on your app.
 
+## Two identities at once
+
+Every message carries the publisher's user id to whoever receives it, so a single
+identity is a single visible identity everywhere the app speaks. When that is not
+what you want, name a second instance. Each named instance has its own
+connection, its own token, and its own key storage, so nobody observing them can
+tell the two identities belong to one device.
+
+The usual shape is a long-lived identity for the user's own conversations plus a
+short-lived or anonymous one for an ephemeral context, running side by side.
+
+```ts
+const mine = await initialize({ ...options });
+const anon = await initialize({ ...options, instanceName: 'nearby' });
+
+await anon.publishBroadcast(channelId, 'hello');
+```
+
+| Option | Description |
+|---|---|
+| `instanceName` | Names this instance. Defaults to `'default'`. |
+
+Only the default key storage is namespaced for you. A `storage` adapter you
+supply yourself is used exactly as given, so give each instance its own.
+
+Calls without a name use the instance named `default`, which keeps the key
+storage an app already has. Upgrading changes nothing for existing code.
+
 ## Security
 
 - **X25519 ECDH** key agreement for shared secrets

package/dist/core/types.d.ts

@@ -381,6 +381,19 @@ export interface InitializeOptions {
      */
     defaultPushPayload?: PushPayload;
     fetchFn?: typeof fetch;
+    /**
+     * Names this instance, so an app can run a second identity alongside the first.
+     *
+     * Each named instance gets key storage of its own, so the two identities are
+     * not linkable to each other by anyone observing them. A typical use is a
+     * long-lived identity for the user's own conversations plus a short-lived one
+     * for an anonymous or ephemeral context. Only the default key storage is
+     * namespaced for you; a `storage` adapter you supply yourself is used exactly
+     * as given, so give each instance its own.
+     *
+     * Defaults to `'default'`, which keeps the storage an existing app already has.
+     */
+    instanceName?: string;
     storage?: KeyStorageAdapter;
     /**
      * Owns the identity keypair instead of {@link storage}, when the consumer wants

package/dist/index.js

@@ -12,11 +12,13 @@ var version_1 = require("./version");
 Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return version_1.SDK_VERSION; } });
 Object.defineProperty(exports, "PROTOCOL_VERSION", { enumerable: true, get: function () { return version_1.PROTOCOL_VERSION; } });
 Object.defineProperty(exports, "PAYLOAD_FORMAT_VERSION", { enumerable: true, get: function () { return version_1.PAYLOAD_FORMAT_VERSION; } });
-function resolveStorage(adapter) {
+function resolveStorage(adapter, instanceName) {
     if (adapter) {
+        // A supplied adapter is used exactly as given: namespacing it here would
+        // silently move the caller's own keys somewhere they did not ask for.
         return adapter;
     }
-    return new indexeddb_key_storage_1.IndexedDbKeyStorage();
+    return new indexeddb_key_storage_1.IndexedDbKeyStorage(instanceName);
 }
 /**
  * An identity whose private key script cannot read, or `null` where the platform
@@ -48,7 +50,7 @@ async function createSecureIdentity(store) {
     return new webcrypto_identity_provider_1.WebCryptoIdentityProvider(recordStore);
 }
 async function initialize(options) {
-    const storage = resolveStorage(options.storage);
+    const storage = resolveStorage(options.storage, options.instanceName);
     const sessionManager = new session_manager_1.SessionManager();
     // An explicitly supplied identity provider owns the key agreement; otherwise
     // the storage adapter does, exactly as in every previous release.

package/dist/storage/indexeddb-key-storage.d.ts

@@ -1,6 +1,26 @@
 import { KeyStorageAdapter } from '../core/types';
+export declare const DEFAULT_INSTANCE = "default";
+/**
+ * The database backing an instance's keys.
+ *
+ * Exported so the rule can be tested directly: if two instances ever resolve to
+ * one database they share a keypair, publish the same public key under both user
+ * ids, and become linkable, with nothing visible to say so.
+ */
+export declare function dbNameFor(instanceName?: string): string;
 export declare class IndexedDbKeyStorage implements KeyStorageAdapter {
     private readonly fallback;
+    private readonly dbName;
+    /**
+     * Each named instance gets a database of its own. Two identities sharing one
+     * database would share one messaging keypair, which publishes the same public
+     * key under both user ids and links them to anyone who looks, defeating the
+     * point of running a second identity at all.
+     *
+     * The default instance keeps the original database name, so an app upgrading
+     * to a version with named instances keeps the identity it already had.
+     */
+    constructor(instanceName?: string);
     get(key: string): Promise<string | null>;
     set(key: string, value: string): Promise<void>;
     remove(key: string): Promise<void>;

package/dist/storage/indexeddb-key-storage.js

@@ -1,13 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexedDbKeyStorage = void 0;
+exports.IndexedDbKeyStorage = exports.DEFAULT_INSTANCE = void 0;
+exports.dbNameFor = dbNameFor;
 const memory_key_storage_1 = require("./memory-key-storage");
 const DB_NAME = 'droponair_sdk';
 const STORE_NAME = 'secure_keys';
 const DB_VERSION = 1;
+exports.DEFAULT_INSTANCE = 'default';
+/**
+ * The database backing an instance's keys.
+ *
+ * Exported so the rule can be tested directly: if two instances ever resolve to
+ * one database they share a keypair, publish the same public key under both user
+ * ids, and become linkable, with nothing visible to say so.
+ */
+function dbNameFor(instanceName = exports.DEFAULT_INSTANCE) {
+    return instanceName === exports.DEFAULT_INSTANCE ? DB_NAME : `${DB_NAME}_${instanceName}`;
+}
 class IndexedDbKeyStorage {
-    constructor() {
+    /**
+     * Each named instance gets a database of its own. Two identities sharing one
+     * database would share one messaging keypair, which publishes the same public
+     * key under both user ids and links them to anyone who looks, defeating the
+     * point of running a second identity at all.
+     *
+     * The default instance keeps the original database name, so an app upgrading
+     * to a version with named instances keeps the identity it already had.
+     */
+    constructor(instanceName = exports.DEFAULT_INSTANCE) {
         this.fallback = new memory_key_storage_1.MemoryKeyStorage();
+        this.dbName = dbNameFor(instanceName);
     }
     async get(key) {
         if (!this.isIndexedDbAvailable()) {
@@ -55,7 +77,7 @@ class IndexedDbKeyStorage {
     }
     async openDb() {
         return new Promise((resolve, reject) => {
-            const request = indexedDB.open(DB_NAME, DB_VERSION);
+            const request = indexedDB.open(this.dbName, DB_VERSION);
             request.onupgradeneeded = () => {
                 const db = request.result;
                 if (!db.objectStoreNames.contains(STORE_NAME)) {

package/dist/version.d.ts

@@ -7,7 +7,7 @@
  *   MINOR, additive feature (e.g. multi-device payloads, new call event type)
  *   PATCH, bug-fix / perf improvement with no wire or API change
  */
-export declare const SDK_VERSION = "0.31.0";
+export declare const SDK_VERSION = "0.32.0";
 /**
  * Binary encrypted-payload format version.
  * Included as the first byte of every encrypted payload so receivers can

package/dist/version.js

@@ -10,7 +10,7 @@ exports.PROTOCOL_VERSION = exports.PAYLOAD_FORMAT_VERSION = exports.SDK_VERSION
  *   MINOR, additive feature (e.g. multi-device payloads, new call event type)
  *   PATCH, bug-fix / perf improvement with no wire or API change
  */
-exports.SDK_VERSION = '0.31.0';
+exports.SDK_VERSION = '0.32.0';
 /**
  * Binary encrypted-payload format version.
  * Included as the first byte of every encrypted payload so receivers can

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@droponair/sdk-js",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "description": "End-to-end encrypted messaging, voice and video calling SDK. The relay never sees your keys or message content.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",