@oxyhq/core 4.0.0 → 5.0.0

package/dist/cjs/HttpService.js

@@ -21,6 +21,7 @@ const asyncUtils_1 = require("./utils/asyncUtils");
 const errorUtils_1 = require("./utils/errorUtils");
 const jwt_decode_1 = require("jwt-decode");
 const platform_1 = require("./utils/platform");
+const protocol_1 = require("@oxyhq/protocol");
 const cacheKey_1 = require("./utils/cacheKey");
 /**
  * Check if we're running in a native app environment (React Native, not web)
@@ -149,8 +150,6 @@ class HttpService {
          * Each listener receives the resulting access token, or `null` when cleared.
          */
         this._tokenChangeListeners = new Set();
-        // Acting-as identity for managed accounts
-        this._actingAsUserId = null;
         // Performance monitoring
         this.requestMetrics = {
             totalRequests: 0,
@@ -324,10 +323,6 @@ class HttpService {
                         hasNativeAppHeader: headers['X-Native-App'] === 'true',
                     });
                 }
-                // Add X-Acting-As header for managed account identity delegation
-                if (this._actingAsUserId) {
-                    headers['X-Acting-As'] = this._actingAsUserId;
-                }
                 // Merge custom headers if provided
                 if (config.headers) {
                     Object.entries(config.headers).forEach(([key, value]) => {
@@ -349,7 +344,7 @@ class HttpService {
                 // RN's native XMLHttpRequest handles those descriptors correctly, so we
                 // route multipart uploads through XHR on RN only. JSON, text, etc. still
                 // use fetch on every platform.
-                const useXhrForUpload = isFormData && (0, platform_1.isReactNative)() && typeof XMLHttpRequest !== 'undefined';
+                const useXhrForUpload = isFormData && (0, protocol_1.isReactNative)() && typeof XMLHttpRequest !== 'undefined';
                 const response = useXhrForUpload
                     ? await this.uploadViaXHR(fullUrl, method, headers, bodyValue, controller.signal, timeout, this.shouldSendCredentials(fullUrl))
                     : await fetch(fullUrl, {
@@ -633,12 +628,12 @@ class HttpService {
      * Derive a stable, non-sensitive identity discriminator for cache scoping.
      *
      * Thin instance wrapper over the pure {@link computeIdentityTag} helper —
-     * binds it to this instance's live access token and acting-as id. See that
-     * function's docs for the full resolution contract (anon fallback, decoded
-     * `userId || id`, token-hash fallback for undecodable tokens).
+     * binds it to this instance's live access token. See that function's docs for
+     * the full resolution contract (anon fallback, decoded `userId || id`,
+     * token-hash fallback for undecodable tokens).
      */
     computeIdentityTag() {
-        return (0, cacheKey_1.computeIdentityTag)(this.tokenStore.getAccessToken(), this._actingAsUserId);
+        return (0, cacheKey_1.computeIdentityTag)(this.tokenStore.getAccessToken());
     }
     /**
      * Generate cache key efficiently
@@ -885,13 +880,6 @@ class HttpService {
     async delete(url, config) {
         return this.request({ method: 'DELETE', url, ...config });
     }
-    // Acting-as identity management (managed accounts)
-    setActingAs(userId) {
-        this._actingAsUserId = userId;
-    }
-    getActingAs() {
-        return this._actingAsUserId;
-    }
     // Token management
     setTokens(accessToken) {
         this.tokenStore.setTokens(accessToken);

package/dist/cjs/OxyServices.base.js

@@ -278,27 +278,6 @@ class OxyServicesBase {
             return null;
         }
     }
-    /**
-     * Set the acting-as identity for managed accounts.
-     *
-     * When set, all subsequent API requests will include the `X-Acting-As` header,
-     * causing the server to attribute actions to the managed account. The
-     * authenticated user must be an authorized manager of the target account.
-     *
-     * Pass `null` to clear and revert to the authenticated user's own identity.
-     *
-     * @param userId - The managed account user ID, or null to clear
-     */
-    setActingAs(userId) {
-        this.httpService.setActingAs(userId);
-    }
-    /**
-     * Get the current acting-as identity (managed account user ID), or null
-     * if operating as the authenticated user's own identity.
-     */
-    getActingAs() {
-        return this.httpService.getActingAs();
-    }
     /**
      * Wait for authentication to be ready
      *

package/dist/cjs/crypto/keyManager.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeyManager = exports.IdentityPersistError = exports.IdentityAlreadyExistsError = void 0;
 const elliptic_1 = require("elliptic");
 const platform_1 = require("../utils/platform");
-const platformCrypto_1 = require("../utils/platformCrypto");
+const protocol_1 = require("@oxyhq/protocol");
 const loggerUtils_1 = require("../utils/loggerUtils");
 const debugUtils_1 = require("../shared/utils/debugUtils");
 /**
@@ -72,15 +72,15 @@ const ANDROID_ACCOUNT_TYPE = 'com.oxy.account';
 /**
  * Initialize React Native specific modules
  *
- * Delegates to `platformCrypto`, which is a per-platform module
- * (`platformCrypto.ts` vs `platformCrypto.react-native.ts`) selected by the
+ * Delegates to `@oxyhq/protocol`'s `platform/crypto`, a per-platform module
+ * (`crypto.ts` vs `crypto.native.ts`) selected by the
  * consumer's bundler. On RN it returns a statically-imported handle to
  * `expo-secure-store`; off RN it throws (and is never called because every
  * caller is gated by `isWebPlatform()` / native-only paths).
  */
 async function initSecureStore() {
     try {
-        return await (0, platformCrypto_1.loadSecureStore)();
+        return await (0, protocol_1.loadSecureStore)();
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -97,7 +97,7 @@ function isWebPlatform() {
 }
 async function initExpoCrypto() {
     // Same per-platform delegation as initSecureStore — see comment there.
-    return (0, platformCrypto_1.loadExpoCrypto)();
+    return (0, protocol_1.loadExpoCrypto)();
 }
 /**
  * Convert Uint8Array to hexadecimal string
@@ -113,7 +113,7 @@ function uint8ArrayToHex(bytes) {
  */
 async function getSecureRandomBytes(length) {
     // In React Native, always use expo-crypto
-    if ((0, platform_1.isReactNative)() || !(0, platform_1.isNodeJS)()) {
+    if ((0, protocol_1.isReactNative)() || !(0, protocol_1.isNodeJS)()) {
         const Crypto = await initExpoCrypto();
         return Crypto.getRandomBytes(length);
     }
@@ -123,7 +123,7 @@ async function getSecureRandomBytes(length) {
     // `await import('crypto')`, the RN variant throws (and we'd never reach
     // here on RN because the early-return above caught it).
     try {
-        const nodeCrypto = await (0, platformCrypto_1.loadNodeCrypto)();
+        const nodeCrypto = await (0, protocol_1.loadNodeCrypto)();
         return new Uint8Array(nodeCrypto.randomBytes(length));
     }
     catch (error) {

package/dist/cjs/crypto/polyfill.js

@@ -7,14 +7,14 @@
  *
  * - Browser/Node.js: Uses native crypto
  * - React Native: Uses expo-crypto (statically imported via the
- *   per-platform `platformCrypto` module — see that file's doc-comment for
- *   how platform routing works).
+ *   per-platform `platform/crypto` module in `@oxyhq/protocol` — see that
+ *   file's doc-comment for how platform routing works).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Buffer = void 0;
 const buffer_1 = require("buffer");
 Object.defineProperty(exports, "Buffer", { enumerable: true, get: function () { return buffer_1.Buffer; } });
-const platformCrypto_1 = require("../utils/platformCrypto");
+const protocol_1 = require("@oxyhq/protocol");
 const getGlobalObject = () => {
     if (typeof globalThis !== 'undefined')
         return globalThis;
@@ -34,7 +34,8 @@ if (!globalObject.Buffer) {
 /**
  * Synchronous random-bytes shim. On RN, this delegates to
  * `expo-crypto.getRandomBytes` (statically imported by the RN variant of
- * `platformCrypto`, so available without any async warm-up). On Node /
+ * `@oxyhq/protocol`'s `platform/crypto`, so available without any async
+ * warm-up). On Node /
  * browser, this throws — but is never called there because both platforms
  * already provide `globalThis.crypto.getRandomValues` natively.
  */
@@ -43,7 +44,7 @@ function getRandomBytesSync(byteCount) {
     // function is only ever called as a fallback when the native
     // `globalThis.crypto.getRandomValues` is missing, which on a normal
     // Node/browser host never happens.
-    return (0, platformCrypto_1.getRandomBytesRN)(byteCount);
+    return (0, protocol_1.getRandomBytesRN)(byteCount);
 }
 const cryptoPolyfill = {
     getRandomValues(array) {

package/dist/cjs/crypto/signatureService.js

@@ -1,87 +1,18 @@
 "use strict";
 /**
- * Signature Service - ECDSA Digital Signatures
+ * Signature Service - ECDSA Digital Signatures (device-key bound)
  *
- * Handles signing and verification of messages using ECDSA secp256k1.
- * Used for authenticating requests and proving identity ownership.
+ * Handles signing and verification of messages with the user's DEVICE identity
+ * key (read from {@link KeyManager} / secure storage). All cryptography itself —
+ * canonical signing input, SHA-256, secp256k1 sign/verify, envelope assembly —
+ * is delegated to `@oxyhq/protocol`; this service only resolves the key from
+ * storage and orchestrates the protocol primitives.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignatureService = void 0;
-exports.signedRecordSigningInput = signedRecordSigningInput;
-exports.computeRecordId = computeRecordId;
-const elliptic_1 = require("elliptic");
+const protocol_1 = require("@oxyhq/protocol");
 const keyManager_1 = require("./keyManager");
-const canonicalJson_1 = require("./canonicalJson");
-const platform_1 = require("../utils/platform");
-const platformCrypto_1 = require("../utils/platformCrypto");
 const loggerUtils_1 = require("../utils/loggerUtils");
-const debugUtils_1 = require("../shared/utils/debugUtils");
-const ec = new elliptic_1.ec('secp256k1');
-/**
- * Compute the canonical signing input for a signed-record envelope.
- *
- * This is the single definition of "what the signature covers". `@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.
- *
- * - **v1**: the canonical JSON of `{version, type, subject, issuer, record,
- *   issuedAt}` — BYTE-IDENTICAL to the original scheme, so every signature
- *   already in production keeps verifying.
- * - **v2**: the canonical JSON additionally includes the hash-chain fields
- *   `{seq, prev, collection, rkey}`. Because {@link canonicalize} sorts keys,
- *   the on-the-wire field order is irrelevant; the resulting canonical key
- *   order is `collection, issuedAt, issuer, prev, record, rkey, seq, subject,
- *   type, version`. `prev` is `null` at genesis (serialized as `null`, not
- *   omitted), so it is always part of the signed bytes.
- */
-function signedRecordSigningInput(fields) {
-    const { version, type, subject, issuer, record, issuedAt } = fields;
-    if (version === 2) {
-        const { seq, prev, collection, rkey } = fields;
-        return (0, canonicalJson_1.canonicalize)({ version, type, subject, issuer, record, issuedAt, seq, prev, collection, rkey });
-    }
-    return (0, canonicalJson_1.canonicalize)({ version, type, subject, issuer, record, issuedAt });
-}
-/**
- * Compute the `recordId` (content address) of a signed record: the SHA-256 hex
- * digest of its canonical {@link signedRecordSigningInput}.
- *
- * Deterministic and stable across runtimes (it reuses the same canonicalization
- * + SHA-256 the signature itself is built on). The recordId is what `prev`
- * references in the per-subject hash chain, so `@oxyhq/core` (client) and
- * `@oxyhq/api` (server) MUST compute it identically — both call this function.
- * It is taken over the SIGNING input (excluding `publicKey`/`signature`), so it
- * is a pure content address of the record's meaning, independent of who signed.
- */
-async function computeRecordId(fields) {
-    return sha256(signedRecordSigningInput(fields));
-}
-/**
- * Compute SHA-256 hash of a string
- */
-async function sha256(message) {
-    // In React Native, use expo-crypto
-    if ((0, platform_1.isReactNative)()) {
-        const Crypto = await (0, platformCrypto_1.loadExpoCrypto)();
-        return Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, message);
-    }
-    if ((0, platform_1.isNodeJS)()) {
-        try {
-            const nodeCrypto = await (0, platformCrypto_1.loadNodeCrypto)();
-            return nodeCrypto.createHash('sha256').update(message).digest('hex');
-        }
-        catch (error) {
-            // Node crypto failed to load — log and fall through to Web Crypto API
-            loggerUtils_1.logger.warn('[oxy.crypto] Node crypto unavailable, falling back to Web Crypto', { component: 'SignatureService' }, error);
-        }
-    }
-    // Browser: use Web Crypto API
-    const encoder = new TextEncoder();
-    const data = encoder.encode(message);
-    const hashBuffer = await globalThis.crypto.subtle.digest('SHA-256', data);
-    const hashArray = Array.from(new Uint8Array(hashBuffer));
-    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-}
 class SignatureService {
     /**
      * Generate a random challenge string (for offline use)
@@ -89,16 +20,16 @@ class SignatureService {
      */
     static async generateChallenge() {
         // In React Native, use expo-crypto
-        if ((0, platform_1.isReactNative)()) {
-            const Crypto = await (0, platformCrypto_1.loadExpoCrypto)();
+        if ((0, protocol_1.isReactNative)()) {
+            const Crypto = await (0, protocol_1.loadExpoCrypto)();
             const randomBytes = await Crypto.getRandomBytesAsync(32);
             return Array.from(new Uint8Array(randomBytes))
                 .map((b) => b.toString(16).padStart(2, '0'))
                 .join('');
         }
-        if ((0, platform_1.isNodeJS)()) {
+        if ((0, protocol_1.isNodeJS)()) {
             try {
-                const nodeCrypto = await (0, platformCrypto_1.loadNodeCrypto)();
+                const nodeCrypto = await (0, protocol_1.loadNodeCrypto)();
                 return nodeCrypto.randomBytes(32).toString('hex');
             }
             catch (error) {
@@ -117,79 +48,18 @@ class SignatureService {
      * Hash a message using SHA-256
      */
     static async hashMessage(message) {
-        return sha256(message);
+        return (0, protocol_1.sha256)(message);
     }
     /**
-     * Sign a message using the stored private key
+     * Sign a message using the stored device private key
      * Returns the signature in DER format (hex encoded)
      */
     static async sign(message) {
-        const keyPair = await keyManager_1.KeyManager.getKeyPairObject();
-        if (!keyPair) {
+        const privateKey = await keyManager_1.KeyManager.getPrivateKey();
+        if (!privateKey) {
             throw new Error('No identity found. Please create or import an identity first.');
         }
-        const messageHash = await sha256(message);
-        const signature = keyPair.sign(messageHash);
-        return signature.toDER('hex');
-    }
-    /**
-     * Sign a message with an explicit private key (without storing)
-     * Useful for one-time operations or testing
-     */
-    static async signWithKey(message, privateKey) {
-        const keyPair = ec.keyFromPrivate(privateKey);
-        const messageHash = await sha256(message);
-        const signature = keyPair.sign(messageHash);
-        return signature.toDER('hex');
-    }
-    /**
-     * Verify a signature against a message and public key
-     *
-     * Returns false on any error (invalid signature, malformed input, etc.).
-     * Errors are logged at debug level so they're available when troubleshooting
-     * signature mismatches but don't surface to the caller.
-     */
-    static async verify(message, signature, publicKey) {
-        try {
-            const key = ec.keyFromPublic(publicKey, 'hex');
-            const messageHash = await sha256(message);
-            return key.verify(messageHash, signature);
-        }
-        catch (error) {
-            if ((0, debugUtils_1.isDev)()) {
-                loggerUtils_1.logger.debug('[oxy.crypto] verify() returned false', { component: 'SignatureService' }, error);
-            }
-            return false;
-        }
-    }
-    /**
-     * Synchronous verification (for Node.js backend)
-     * Uses crypto module directly for hashing
-     * Note: This method should only be used in Node.js environments
-     */
-    static verifySync(message, signature, publicKey) {
-        try {
-            if (!(0, platform_1.isNodeJS)()) {
-                // In React Native, use async verify instead
-                throw new Error('verifySync should only be used in Node.js. Use verify() in React Native.');
-            }
-            // Intentionally using Function constructor here: this method is synchronous by design
-            // (Node.js backend hot-path) so we cannot use `await import()`. The Function constructor
-            // prevents Metro/bundlers from statically resolving the require. This is acceptable because
-            // verifySync is gated by isNodeJS() and will never execute in browser/RN environments.
-            // eslint-disable-next-line @typescript-eslint/no-implied-eval
-            const getCrypto = new Function('return require("crypto")');
-            const crypto = getCrypto();
-            const key = ec.keyFromPublic(publicKey, 'hex');
-            const messageHash = crypto.createHash('sha256').update(message).digest('hex');
-            return key.verify(messageHash, signature);
-        }
-        catch (error) {
-            if ((0, debugUtils_1.isDev)()) {
-                loggerUtils_1.logger.debug('[oxy.crypto] verifySync() returned false', { component: 'SignatureService' }, error);
-            }
-            return false;
-        }
+        return (0, protocol_1.signMessage)(message, privateKey);
     }
     /**
      * Create a signed message object with metadata
@@ -223,7 +93,7 @@ class SignatureService {
         }
         // Verify signature
         const messageWithTimestamp = `${message}:${timestamp}`;
-        return SignatureService.verify(messageWithTimestamp, signature, publicKey);
+        return (0, protocol_1.verifySignature)(messageWithTimestamp, signature, publicKey);
     }
     /**
      * Create a signed authentication challenge response
@@ -251,9 +121,10 @@ class SignatureService {
      * 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.
+     * `KeyManager` and signs with the protocol's explicit-key {@link signMessage}.
+     * 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).
@@ -266,7 +137,7 @@ class SignatureService {
         }
         const timestamp = Date.now();
         const message = `auth:${publicKey}:${challenge}:${timestamp}`;
-        const signature = await SignatureService.signWithKey(message, privateKey);
+        const signature = await (0, protocol_1.signMessage)(message, privateKey);
         return {
             challenge: signature,
             publicKey,
@@ -284,7 +155,7 @@ class SignatureService {
             return false;
         }
         const message = `auth:${publicKey}:${originalChallenge}:${timestamp}`;
-        return SignatureService.verify(message, signature, publicKey);
+        return (0, protocol_1.verifySignature)(message, signature, publicKey);
     }
     /**
      * Create a registration signature
@@ -332,9 +203,11 @@ class SignatureService {
      *
      * 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.
+     * and `signature`; `alg` is `ES256K-DER-SHA256` (secp256k1 over the SHA-256 of
+     * the canonical bytes, DER-encoded). The cryptography is delegated to the
+     * protocol's {@link signEnvelope}, which derives the (uncompressed-hex)
+     * `publicKey` from the stored device key — identical to the registered
+     * verification method.
      *
      * Requires a stored identity (native secure storage); throws if none exists.
      *
@@ -343,41 +216,26 @@ class SignatureService {
      * @param record - The arbitrary record payload to attest to.
      */
     static async signRecord(type, subject, record) {
-        const publicKey = await keyManager_1.KeyManager.getPublicKey();
-        if (!publicKey) {
+        const privateKey = await keyManager_1.KeyManager.getPrivateKey();
+        if (!privateKey) {
             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,
+        return (0, protocol_1.signEnvelope)({
+            version: 1,
             type,
             subject,
-            issuer,
+            issuer: subject,
             record,
-            issuedAt,
-            publicKey,
-            alg: 'ES256K-DER-SHA256',
-            signature,
-        };
+            issuedAt: Date.now(),
+        }, privateKey);
     }
     /**
      * Build a signed-record envelope (v2) carrying the per-subject hash-chain
      * fields.
      *
      * Identical to {@link signRecord} (self-issued: `issuer === subject`; same
-     * `ES256K-DER-SHA256` scheme over {@link signedRecordSigningInput}) but
-     * `version` is `2` and the signed bytes additionally cover the chain fields:
+     * `ES256K-DER-SHA256` scheme) but `version` is `2` and the signed bytes
+     * additionally cover the chain fields:
      *
      * @param type - The record category.
      * @param subject - The subject DID the record is about (also the issuer).
@@ -392,57 +250,23 @@ class SignatureService {
      * none exists.
      */
     static async signRecordV2(type, subject, record, chain) {
-        const publicKey = await keyManager_1.KeyManager.getPublicKey();
-        if (!publicKey) {
+        const privateKey = await keyManager_1.KeyManager.getPrivateKey();
+        if (!privateKey) {
             throw new Error('No identity found. Please create or import an identity first.');
         }
-        const version = 2;
-        const issuer = subject;
-        const issuedAt = Date.now();
         const { seq, prev, collection, rkey } = chain;
-        const signingInput = signedRecordSigningInput({
-            version,
+        return (0, protocol_1.signEnvelope)({
+            version: 2,
             type,
             subject,
-            issuer,
+            issuer: subject,
             record,
-            issuedAt,
+            issuedAt: Date.now(),
             seq,
             prev,
             collection,
             rkey,
-        });
-        const signature = await SignatureService.sign(signingInput);
-        return {
-            version,
-            type,
-            subject,
-            issuer,
-            record,
-            issuedAt,
-            seq,
-            prev,
-            collection,
-            rkey,
-            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);
+        }, privateKey);
     }
 }
 exports.SignatureService = SignatureService;