@oxyhq/core 3.10.1 → 3.11.0

package/dist/esm/AuthManager.js

@@ -336,8 +336,15 @@ export class AuthManager {
      * Get default storage based on environment.
      */
     getDefaultStorage() {
-        if (typeof window !== 'undefined' && window.localStorage) {
-            return new LocalStorageAdapter();
+        try {
+            if (typeof window !== 'undefined' && window.localStorage) {
+                return new LocalStorageAdapter();
+            }
+        }
+        catch {
+            // Accessing window.localStorage can throw in opaque-origin/sandboxed
+            // browser contexts or when storage is disabled. Fall back to memory so
+            // AuthManager construction remains safe during provider render.
         }
         return new MemoryStorage();
     }

package/dist/esm/HttpService.js

@@ -348,13 +348,13 @@ export class HttpService {
                 // use fetch on every platform.
                 const useXhrForUpload = isFormData && isReactNative() && typeof XMLHttpRequest !== 'undefined';
                 const response = useXhrForUpload
-                    ? await this.uploadViaXHR(fullUrl, method, headers, bodyValue, controller.signal, timeout)
+                    ? await this.uploadViaXHR(fullUrl, method, headers, bodyValue, controller.signal, timeout, this.shouldSendCredentials(fullUrl))
                     : await fetch(fullUrl, {
                         method,
                         headers,
                         body: bodyValue,
                         signal: controller.signal,
-                        credentials: 'include', // Include cookies for cross-origin requests (CSRF, session)
+                        credentials: this.getCredentialsMode(fullUrl),
                     });
                 if (timeoutId)
                     clearTimeout(timeoutId);
@@ -380,7 +380,7 @@ export class HttpService {
                             const errBody = await clonedResponse.json();
                             if (errBody?.code === 'CSRF_TOKEN_INVALID' || errBody?.code === 'CSRF_TOKEN_MISSING') {
                                 this.tokenStore.clearCsrfToken();
-                                return this.request({ ...config, _isCsrfRetry: true, retry: false });
+                                return this.request({ ...config, _isCsrfRetry: true, retry: false, deduplicate: false });
                             }
                         }
                         catch {
@@ -414,7 +414,10 @@ export class HttpService {
                 // Handle different response types (optimized - read response once)
                 const contentType = response.headers.get('content-type');
                 let responseData;
-                if (contentType && contentType.includes('application/json')) {
+                if (config.responseType === 'blob') {
+                    responseData = await response.blob();
+                }
+                else if (contentType && contentType.includes('application/json')) {
                     // Use response.json() directly for better performance
                     try {
                         responseData = await response.json();
@@ -525,13 +528,14 @@ export class HttpService {
      * (status checks, 401/403 retries, JSON/blob/text parsing) is identical
      * to the fetch path.
      */
-    uploadViaXHR(url, method, headers, body, abortSignal, timeout) {
+    uploadViaXHR(url, method, headers, body, abortSignal, timeout, withCredentials) {
         return new Promise((resolve, reject) => {
             const xhr = new XMLHttpRequest();
             xhr.open(method, url, true);
-            // withCredentials mirrors fetch's `credentials: 'include'` so the
-            // session cookie and CSRF cookie continue to flow.
-            xhr.withCredentials = true;
+            // Only send ambient cookies to the configured API origin. Absolute
+            // caller-supplied URLs can target arbitrary origins, so they must not
+            // receive credential-bearing requests by default.
+            xhr.withCredentials = withCredentials;
             // Forward headers but skip Content-Type — XHR sets the multipart
             // boundary automatically and overriding it breaks the upload.
             for (const [key, value] of Object.entries(headers)) {
@@ -684,6 +688,17 @@ export class HttpService {
         const queryString = searchParams.toString();
         return queryString ? `${base}${base.includes('?') ? '&' : '?'}${queryString}` : base;
     }
+    getCredentialsMode(url) {
+        return this.shouldSendCredentials(url) ? 'include' : 'omit';
+    }
+    shouldSendCredentials(url) {
+        try {
+            return new URL(url).origin === new URL(this.baseURL).origin;
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Fetch CSRF token from server (with deduplication)
      * Required for state-changing requests (POST, PUT, PATCH, DELETE)
@@ -718,8 +733,11 @@ export class HttpService {
                     this.logger.debug('CSRF fetch response:', response.status, response.ok);
                     if (response.ok) {
                         const data = await response.json();
-                        this.logger.debug('CSRF response data:', data);
                         const token = data.csrfToken || null;
+                        this.logger.debug('CSRF response data:', {
+                            hasCsrfToken: typeof token === 'string' && token.length > 0,
+                            csrfTokenLength: token?.length,
+                        });
                         this.tokenStore.setCsrfToken(token);
                         this.logger.debug('CSRF token fetched');
                         return token;

package/dist/esm/OxyServices.base.js

@@ -229,8 +229,9 @@ export class OxyServicesBase {
         }
         try {
             const decoded = jwtDecode(accessToken);
-            this._cachedUserId = decoded.userId || decoded.id || null;
-            return this._cachedUserId;
+            const userId = decoded.userId || decoded.id || null;
+            this._cachedUserId = userId;
+            return userId;
         }
         catch {
             this._cachedUserId = null;

package/dist/esm/crypto/canonicalJson.js

@@ -0,0 +1,104 @@
+/**
+ * Canonical JSON (RFC 8785 / JCS-style) serialization.
+ *
+ * `canonicalize(value)` produces a deterministic string for any JSON-compatible
+ * value so that a client which SIGNS a record and a server which VERIFIES it
+ * agree byte-for-byte on the signing input — regardless of the order in which
+ * object keys happen to be written, how the value was deserialized, or which
+ * runtime built it.
+ *
+ * This is the load-bearing primitive for the self-sovereign identity layer's
+ * signed records (`SignatureService.signRecord` + the API's record-verify path):
+ * both sides import THIS function from `@oxyhq/core`, so cross-implementation
+ * number/string formatting differences cannot cause a verify mismatch.
+ *
+ * Rules (the JSON Canonicalization Scheme subset we need):
+ *  - Objects: keys are sorted (ascending, by UTF-16 code unit — the default
+ *    `Array.prototype.sort` order) and serialized recursively. Properties whose
+ *    value is `undefined`, a function, or a symbol are OMITTED (matching
+ *    `JSON.stringify` object semantics).
+ *  - Arrays: element order is PRESERVED; `undefined`/function/symbol elements
+ *    serialize to `null` (matching `JSON.stringify` array semantics).
+ *  - `null`, booleans, strings, and finite numbers serialize via the standard
+ *    JSON representation.
+ *  - Values exposing a `toJSON()` method (e.g. `Date`) are replaced by its
+ *    result first, then serialized — so a `Date` and its ISO-string equivalent
+ *    canonicalize identically (the wire always carries the string form).
+ *  - Non-finite numbers (`NaN`, `Infinity`) and `bigint` are not part of the
+ *    JSON data model and throw, rather than silently producing `null`.
+ *
+ * Platform-agnostic — zero dependencies, no `require()`, no react/react-native/
+ * expo. Safe in the dual CJS + ESM build.
+ */
+function hasToJSON(value) {
+    return typeof value.toJSON === 'function';
+}
+/**
+ * Serialize a single value into its canonical JSON fragment. Recursive; called
+ * on each nested member. Object keys are sorted at every level.
+ */
+function serialize(value) {
+    if (value === null) {
+        return 'null';
+    }
+    const valueType = typeof value;
+    if (valueType === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new Error('canonicalize: non-finite numbers cannot be serialized');
+        }
+        return JSON.stringify(value);
+    }
+    if (valueType === 'string' || valueType === 'boolean') {
+        return JSON.stringify(value);
+    }
+    if (valueType === 'bigint') {
+        throw new Error('canonicalize: bigint values cannot be serialized');
+    }
+    if (Array.isArray(value)) {
+        const items = value.map((item) => {
+            const itemType = typeof item;
+            // JSON array semantics: undefined / function / symbol become null so the
+            // element positions (and therefore the array length) are preserved.
+            if (item === undefined || itemType === 'function' || itemType === 'symbol') {
+                return 'null';
+            }
+            return serialize(item);
+        });
+        return `[${items.join(',')}]`;
+    }
+    if (valueType === 'object') {
+        const obj = value;
+        if (hasToJSON(obj)) {
+            return serialize(obj.toJSON());
+        }
+        const record = obj;
+        const parts = [];
+        for (const key of Object.keys(record).sort()) {
+            const member = record[key];
+            const memberType = typeof member;
+            // JSON object semantics: properties with undefined / function / symbol
+            // values are omitted entirely.
+            if (member === undefined || memberType === 'function' || memberType === 'symbol') {
+                continue;
+            }
+            parts.push(`${JSON.stringify(key)}:${serialize(member)}`);
+        }
+        return `{${parts.join(',')}}`;
+    }
+    // undefined / function / symbol at the top level have no JSON representation.
+    throw new Error(`canonicalize: cannot serialize a value of type ${valueType}`);
+}
+/**
+ * Produce the canonical JSON string for `value`.
+ *
+ * Deterministic: two structurally-equal values yield identical strings even if
+ * their object keys were written in different orders. Use this — never an
+ * ad-hoc `JSON.stringify` of a hand-sorted object — as the signing input for
+ * signed records, so client signing and server verification cannot drift.
+ *
+ * @throws if `value` (or any nested member used as the top-level/primitive)
+ *   contains a non-finite number or a `bigint`, which have no JSON form.
+ */
+export function canonicalize(value) {
+    return serialize(value);
+}

package/dist/esm/crypto/keyManager.js

@@ -57,9 +57,9 @@ const STORAGE_KEYS = {
 /**
  * iOS Keychain Access Group for sharing identities across Oxy apps
  * All Oxy apps must have this access group enabled in their entitlements
- * Format: [Team ID].com.oxy.shared or group.com.oxy.shared
+ * Format: [Team ID].so.oxy.shared or group.so.oxy.shared
  */
-const IOS_KEYCHAIN_GROUP = 'group.com.oxy.shared';
+const IOS_KEYCHAIN_GROUP = 'group.so.oxy.shared';
 /**
  * Android Account Manager type for shared authentication
  * Used with sharedUserId to share sessions across apps
@@ -691,11 +691,25 @@ export class KeyManager {
             throw new IdentityPersistError('Stored identity failed crypto self-test', error);
         }
         // Step 3: The new primary is durable and functional. NOW it is safe to
-        // refresh the backup to the new key. If this final backup write fails the
-        // user still has a fully working primary, and the backup still holds the
-        // PREVIOUS good identity — so we log and continue rather than failing the
-        // whole operation (failing here would be strictly worse: a working
-        // primary would be reported as an error to the caller).
+        // refresh the backup to the new key. This is part of the successful write
+        // contract: returning success while the backup still belongs to the
+        // previous identity would allow a later restore with an absent primary to
+        // silently switch the device back to the previous account. Snapshot the
+        // backup first so a partial backup refresh can be rolled back along with
+        // the primary before surfacing the failure.
+        let priorBackupPrivate;
+        let priorBackupPublic;
+        let priorBackupTimestamp;
+        try {
+            priorBackupPrivate = await store.getItemAsync(STORAGE_KEYS.BACKUP_PRIVATE_KEY);
+            priorBackupPublic = await store.getItemAsync(STORAGE_KEYS.BACKUP_PUBLIC_KEY);
+            priorBackupTimestamp = await store.getItemAsync(STORAGE_KEYS.BACKUP_TIMESTAMP);
+        }
+        catch (error) {
+            logger.error('Failed to snapshot identity backup before refresh', error, { component: 'KeyManager' });
+            await KeyManager._rollbackPrimary(store, priorPrivate, priorPublic);
+            throw new IdentityPersistError('Failed to snapshot identity backup before refresh', error);
+        }
         try {
             await store.setItemAsync(STORAGE_KEYS.BACKUP_PRIVATE_KEY, canonicalPrivate, {
                 keychainAccessible: store.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
@@ -704,12 +718,57 @@ export class KeyManager {
             await store.setItemAsync(STORAGE_KEYS.BACKUP_TIMESTAMP, Date.now().toString());
         }
         catch (error) {
-            logger.warn('Primary identity persisted successfully but refreshing the backup failed; primary is usable, backup may be stale', { component: 'KeyManager' }, error);
+            logger.error('Failed to refresh identity backup after primary write', error, { component: 'KeyManager' });
+            await KeyManager._rollbackBackup(store, priorBackupPrivate, priorBackupPublic, priorBackupTimestamp);
+            await KeyManager._rollbackPrimary(store, priorPrivate, priorPublic);
+            throw new IdentityPersistError('Failed to refresh identity backup after primary write', error);
         }
         // Update cache only after we are certain the identity is durable.
         KeyManager.cachedPublicKey = canonicalPublic;
         KeyManager.cachedHasIdentity = true;
     }
+    /**
+     * Restore the backup slot to a previously-snapshotted state. Best-effort so
+     * the original persistence error remains the one surfaced to the caller.
+     *
+     * @internal
+     */
+    static async _rollbackBackup(store, priorBackupPrivate, priorBackupPublic, priorBackupTimestamp) {
+        try {
+            if (priorBackupPrivate) {
+                await store.setItemAsync(STORAGE_KEYS.BACKUP_PRIVATE_KEY, priorBackupPrivate, {
+                    keychainAccessible: store.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
+                });
+            }
+            else {
+                try {
+                    await store.deleteItemAsync(STORAGE_KEYS.BACKUP_PRIVATE_KEY);
+                }
+                catch { /* best effort */ }
+            }
+            if (priorBackupPublic) {
+                await store.setItemAsync(STORAGE_KEYS.BACKUP_PUBLIC_KEY, priorBackupPublic);
+            }
+            else {
+                try {
+                    await store.deleteItemAsync(STORAGE_KEYS.BACKUP_PUBLIC_KEY);
+                }
+                catch { /* best effort */ }
+            }
+            if (priorBackupTimestamp) {
+                await store.setItemAsync(STORAGE_KEYS.BACKUP_TIMESTAMP, priorBackupTimestamp);
+            }
+            else {
+                try {
+                    await store.deleteItemAsync(STORAGE_KEYS.BACKUP_TIMESTAMP);
+                }
+                catch { /* best effort */ }
+            }
+        }
+        catch (rollbackError) {
+            logger.error('Failed to roll back identity backup after a failed refresh', rollbackError, { component: 'KeyManager' });
+        }
+    }
     /**
      * Restore the primary slot to a previously-snapshotted (privA, pubA) pair,
      * or delete it entirely if there was no prior identity. Best-effort: every

package/dist/esm/crypto/signatureService.js

@@ -7,11 +7,24 @@
 import _cjs_elliptic from 'elliptic';
 const { ec: EC } = _cjs_elliptic;
 import { KeyManager } from './keyManager.js';
+import { canonicalize } from './canonicalJson.js';
 import { isReactNative, isNodeJS } from '../utils/platform.js';
 import { loadExpoCrypto, loadNodeCrypto } from '../utils/platformCrypto.js';
 import { logger } from '../utils/loggerUtils.js';
 import { isDev } from '../shared/utils/debugUtils.js';
 const ec = new EC('secp256k1');
+/**
+ * Compute the canonical signing input for a signed-record envelope.
+ *
+ * This is the single definition of "what the signature covers": the canonical
+ * JSON of `{version, type, subject, issuer, record, issuedAt}`. `@oxyhq/core`
+ * (client signing) and `@oxyhq/api` (server verification) both call this, so a
+ * record signed by a client and verified by the server cannot drift.
+ */
+export function signedRecordSigningInput(fields) {
+    const { version, type, subject, issuer, record, issuedAt } = fields;
+    return canonicalize({ version, type, subject, issuer, record, issuedAt });
+}
 /**
  * Compute SHA-256 hash of a string
  */
@@ -199,6 +212,36 @@ export class SignatureService {
             timestamp,
         };
     }
+    /**
+     * Create a signed authentication challenge response using the SHARED identity
+     * key (the cross-app `group.so.oxy.shared` keychain key), not the primary
+     * device key.
+     *
+     * Mirrors {@link signChallenge} exactly — same message format
+     * (`auth:${publicKey}:${challenge}:${timestamp}`) so the server verification
+     * path is unchanged — but sources the shared public/private key from
+     * `KeyManager` and signs with `signWithKey`. Used by "Sign in with Oxy"
+     * same-device shared-keychain SSO (Mechanism A): a sibling native app proves
+     * control of the shared identity to mint its own session.
+     *
+     * Throws if no shared identity exists (native-only; the shared keychain is
+     * unavailable on web).
+     */
+    static async signChallengeWithSharedKey(challenge) {
+        const publicKey = await KeyManager.getSharedPublicKey();
+        const privateKey = await KeyManager.getSharedPrivateKey();
+        if (!publicKey || !privateKey) {
+            throw new Error('No shared identity found. Cannot sign with the shared key.');
+        }
+        const timestamp = Date.now();
+        const message = `auth:${publicKey}:${challenge}:${timestamp}`;
+        const signature = await SignatureService.signWithKey(message, privateKey);
+        return {
+            challenge: signature,
+            publicKey,
+            timestamp,
+        };
+    }
     /**
      * Verify a challenge response
      */
@@ -253,5 +296,64 @@ export class SignatureService {
             timestamp,
         };
     }
+    /**
+     * Build a signed-record envelope for a self-issued identity/profile record.
+     *
+     * The envelope is self-issued: `issuer` equals `subject` (the signer's DID).
+     * The signature covers the canonical JSON of every field EXCEPT `publicKey`
+     * and `signature` (see {@link signedRecordSigningInput}); `alg` is
+     * `ES256K-DER-SHA256` (secp256k1 over the SHA-256 of the canonical bytes,
+     * DER-encoded), the same scheme this service uses everywhere else.
+     *
+     * Requires a stored identity (native secure storage); throws if none exists.
+     *
+     * @param type - The record category (`'identity'` or `'profile'`).
+     * @param subject - The subject DID the record is about (also the issuer).
+     * @param record - The arbitrary record payload to attest to.
+     */
+    static async signRecord(type, subject, record) {
+        const publicKey = await KeyManager.getPublicKey();
+        if (!publicKey) {
+            throw new Error('No identity found. Please create or import an identity first.');
+        }
+        const version = 1;
+        const issuer = subject;
+        const issuedAt = Date.now();
+        const signingInput = signedRecordSigningInput({
+            version,
+            type,
+            subject,
+            issuer,
+            record,
+            issuedAt,
+        });
+        const signature = await SignatureService.sign(signingInput);
+        return {
+            version,
+            type,
+            subject,
+            issuer,
+            record,
+            issuedAt,
+            publicKey,
+            alg: 'ES256K-DER-SHA256',
+            signature,
+        };
+    }
+    /**
+     * Verify a signed-record envelope: recompute the canonical signing input from
+     * the envelope's own fields and check the signature against the envelope's
+     * `publicKey`.
+     *
+     * Note: this confirms the signature is internally consistent with the
+     * embedded `publicKey`. It does NOT establish that `publicKey` is an
+     * authorized verification method for `subject` — that authorization check is
+     * the server's responsibility (it asserts the key is a current verification
+     * method on the subject's DID).
+     */
+    static async verifyRecord(envelope) {
+        const signingInput = signedRecordSigningInput(envelope);
+        return SignatureService.verify(signingInput, envelope.signature, envelope.publicKey);
+    }
 }
 export default SignatureService;

package/dist/esm/index.js

@@ -36,6 +36,13 @@ export { OxyAppDataIdentifierError } from './mixins/OxyServices.appData.js';
 export { getNormalizedUserId, normalizeUserIdentity, normalizeUserIdentityOrNull, } from './utils/userIdentity.js';
 export { getCanonicalUserHandle, getNormalizedUserHandle, } from './utils/userHandle.js';
 // ---------------------------------------------------------------------------
+// Self-sovereign identity (DID, signed records, auth-method ↔ VM mapping,
+// verified domains). Wire shapes (DidDocument, SignedRecordEnvelope,
+// AuthMethodsResponse, VerifiedDomain, DomainVerificationInstructions,
+// ExportBundle) live in `@oxyhq/contracts` — import them directly from there.
+// ---------------------------------------------------------------------------
+export { buildUserDid } from './mixins/OxyServices.identity.js';
+// ---------------------------------------------------------------------------
 // Auth helpers (token refresh, error normalisation, retry policies)
 // ---------------------------------------------------------------------------
 export { SessionSyncRequiredError, AuthenticationFailedError, ensureValidToken, isAuthenticationError, withAuthErrorHandling, authenticatedApiCall, } from './utils/authHelpers.js';
@@ -47,7 +54,8 @@ export { mergeSessions, normalizeAndSortSessions, sessionsArraysEqual, } from '.
 // Crypto / identity
 // ---------------------------------------------------------------------------
 export { KeyManager, IdentityAlreadyExistsError, IdentityPersistError, } from './crypto/keyManager.js';
-export { SignatureService } from './crypto/signatureService.js';
+export { SignatureService, signedRecordSigningInput } from './crypto/signatureService.js';
+export { canonicalize } from './crypto/canonicalJson.js';
 export { RecoveryPhraseService } from './crypto/recoveryPhrase.js';
 // ---------------------------------------------------------------------------
 // Devices

package/dist/esm/mixins/OxyServices.assets.js

@@ -438,7 +438,9 @@ export function OxyServicesAssetsMixin(Base) {
             return urlRes?.url || null;
         }
         async fetchAssetContent(url, type) {
-            const response = await fetch(url, { credentials: 'include' });
+            const response = await fetch(url, {
+                credentials: shouldSendAssetCredentials(url, this.getBaseURL()) ? 'include' : 'omit',
+            });
             if (!response?.ok) {
                 throw new Error(`Failed to fetch asset content (status ${response?.status})`);
             }
@@ -446,3 +448,16 @@ export function OxyServicesAssetsMixin(Base) {
         }
     };
 }
+/**
+ * Only send ambient credentials (cookies) when the asset URL is same-origin with
+ * the configured API base. Caller-supplied cross-origin asset URLs must not leak
+ * the user's cookies to arbitrary hosts.
+ */
+function shouldSendAssetCredentials(url, baseURL) {
+    try {
+        return new URL(url).origin === new URL(baseURL).origin;
+    }
+    catch {
+        return false;
+    }
+}