@oxyhq/services 5.17.18 → 5.18.1

package/lib/typescript/module/core/mixins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/core/mixins/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAmBtD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB;;;;;;;;;;;;;aAiBI,QAAQ,EAAC,QAC9C,EAAiC,4BAA4B;QAC5B,SADtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoBu2F,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA3mG,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAAuhG,CAAC;qBAAwB,CAAC;;;;;2BAF79L"}

package/lib/typescript/module/core/mixins/mixinHelpers.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Helper utilities for mixin classes
+ * Provides common patterns to reduce code duplication
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+/**
+ * Wraps an async method with standard error handling
+ * Reduces boilerplate in mixin methods
+ */
+export declare function withErrorHandling<T>(operation: () => Promise<T>, handleError: (error: any) => Error): Promise<T>;
+/**
+ * Creates a standard API request method with error handling
+ * Reduces duplication across mixin methods
+ */
+export declare function createApiMethod<T>(makeRequest: OxyServicesBase['makeRequest'], handleError: OxyServicesBase['handleError'], method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string | ((...args: any[]) => string), options?: {
+    cache?: boolean;
+    cacheTTL?: number;
+    retry?: boolean;
+    transformData?: (data: any) => any;
+    transformResponse?: (response: any) => T;
+}): (...args: any[]) => Promise<T>;
+/**
+ * Cache time constants (in milliseconds)
+ */
+export declare const CACHE_TIMES: {
+    readonly SHORT: number;
+    readonly MEDIUM: number;
+    readonly LONG: number;
+    readonly VERY_LONG: number;
+    readonly EXTRA_LONG: number;
+};
+//# sourceMappingURL=mixinHelpers.d.ts.map

package/lib/typescript/module/core/mixins/mixinHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixinHelpers.d.ts","sourceRoot":"","sources":["../../../../../src/core/mixins/mixinHelpers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,WAAW,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,KAAK,GACjC,OAAO,CAAC,CAAC,CAAC,CAMZ;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,WAAW,EAAE,eAAe,CAAC,aAAa,CAAC,EAC3C,WAAW,EAAE,eAAe,CAAC,aAAa,CAAC,EAC3C,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,EACnD,GAAG,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,CAAC,EAC1C,OAAO,GAAE;IACP,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC;IACnC,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,CAAC,CAAC;CACrC,IAEQ,GAAG,MAAM,GAAG,EAAE,KAAG,OAAO,CAAC,CAAC,CAAC,CAiB1C;AAED;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;CAMd,CAAC"}

package/lib/typescript/module/crypto/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Oxy Crypto Module
+ *
+ * Provides cryptographic identity management for the Oxy ecosystem.
+ * Handles key generation, secure storage, digital signatures, and recovery phrases.
+ */
+import './polyfill';
+export { KeyManager, type KeyPair } from './keyManager';
+export { SignatureService, type SignedMessage, type AuthChallenge } from './signatureService';
+export { RecoveryPhraseService, type RecoveryPhraseResult } from './recoveryPhrase';
+export { KeyManager as default } from './keyManager';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/crypto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/crypto/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,YAAY,CAAC;AAEpB,OAAO,EAAE,UAAU,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EACL,gBAAgB,EAChB,KAAK,aAAa,EAClB,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,qBAAqB,EACrB,KAAK,oBAAoB,EAC1B,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,UAAU,IAAI,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/lib/typescript/module/crypto/keyManager.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Key Manager - ECDSA secp256k1 Key Generation and Storage
+ *
+ * Handles secure generation, storage, and retrieval of cryptographic keys.
+ * Private keys are stored securely using expo-secure-store and never leave the device.
+ */
+import type { ECKeyPair } from 'elliptic';
+export interface KeyPair {
+    publicKey: string;
+    privateKey: string;
+}
+export declare class KeyManager {
+    private static cachedPublicKey;
+    private static cachedHasIdentity;
+    private static cachedSharedPublicKey;
+    private static cachedHasSharedIdentity;
+    /**
+     * Invalidate cached identity state
+     * Called internally when identity is created/deleted/imported
+     */
+    private static invalidateCache;
+    /**
+     * Invalidate cached shared identity state
+     * Called internally when shared identity is created/deleted/imported
+     */
+    private static invalidateSharedCache;
+    /**
+     * Generate a new ECDSA secp256k1 key pair
+     * Returns the keys in hexadecimal format
+     */
+    static generateKeyPairSync(): KeyPair;
+    /**
+     * Generate a new key pair using secure random bytes
+     */
+    static generateKeyPair(): Promise<KeyPair>;
+    /**
+     * Create a shared identity accessible across all Oxy apps
+     *
+     * iOS: Stores in shared keychain group (requires entitlement configuration)
+     * Android: Stores in Account Manager (requires sharedUserId in manifest)
+     *
+     * This enables true cross-app SSO - when user signs in to one Oxy app,
+     * they're automatically signed in to all other Oxy apps.
+     *
+     * @returns Public key of the shared identity
+     * @throws Error if not on native platform or if sharing is not configured
+     */
+    static createSharedIdentity(): Promise<string>;
+    /**
+     * Get the shared public key (accessible across all Oxy apps)
+     *
+     * @returns Shared public key or null if no shared identity exists
+     */
+    static getSharedPublicKey(): Promise<string | null>;
+    /**
+     * Get the shared private key (for signing operations)
+     *
+     * WARNING: Only use this for signing operations within the app.
+     * The private key should NEVER be transmitted or exposed.
+     *
+     * @returns Shared private key or null if no shared identity exists
+     */
+    static getSharedPrivateKey(): Promise<string | null>;
+    /**
+     * Check if a shared identity exists (accessible across all Oxy apps)
+     *
+     * @returns True if shared identity exists, false otherwise
+     */
+    static hasSharedIdentity(): Promise<boolean>;
+    /**
+     * Import an existing key pair as shared identity
+     *
+     * This is used when:
+     * 1. User signs in to a new Oxy app for the first time
+     * 2. User has existing identity on another Oxy app
+     * 3. We want to sync the identity across apps
+     *
+     * @param privateKey - Private key in hex format
+     * @returns Public key
+     */
+    static importSharedIdentity(privateKey: string): Promise<string>;
+    /**
+     * Store session information in shared storage
+     *
+     * This allows all Oxy apps to access the same session without
+     * re-authenticating. When user signs in to one app, all apps
+     * get the session automatically.
+     *
+     * @param sessionId - Session ID from authentication
+     * @param accessToken - Access token for API calls
+     */
+    static storeSharedSession(sessionId: string, accessToken: string): Promise<void>;
+    /**
+     * Get shared session information
+     *
+     * This allows any Oxy app to check if user is already signed in
+     * via another Oxy app. Enables instant cross-app SSO.
+     *
+     * @returns Session data or null if no shared session exists
+     */
+    static getSharedSession(): Promise<{
+        sessionId: string;
+        accessToken: string;
+    } | null>;
+    /**
+     * Clear shared session (on logout)
+     *
+     * This signs out the user from ALL Oxy apps simultaneously.
+     * Call this when user explicitly logs out.
+     */
+    static clearSharedSession(): Promise<void>;
+    /**
+     * Migrate local identity to shared identity
+     *
+     * Call this when upgrading existing apps to use shared identities.
+     * Copies the device-specific identity to shared storage so it can
+     * be accessed by other Oxy apps.
+     *
+     * @returns True if migration was successful, false if no local identity exists
+     */
+    static migrateToSharedIdentity(): Promise<boolean>;
+    /**
+     * Generate and securely store a new key pair on the device
+     * Returns only the public key (private key is stored securely)
+     */
+    static createIdentity(): Promise<string>;
+    /**
+     * Import an existing key pair (e.g., from recovery phrase)
+     */
+    static importKeyPair(privateKey: string): Promise<string>;
+    /**
+     * Get the stored private key
+     * WARNING: Only use this for signing operations within the app
+     */
+    static getPrivateKey(): Promise<string | null>;
+    /**
+     * Get the stored public key (cached for performance)
+     */
+    static getPublicKey(): Promise<string | null>;
+    /**
+     * Check if an identity (key pair) exists on this device (cached for performance)
+     */
+    static hasIdentity(): Promise<boolean>;
+    /**
+     * Delete the stored identity (both keys)
+     * Use with EXTREME caution - this is irreversible without a recovery phrase
+     * This should ONLY be called when explicitly requested by the user
+     * @param skipBackup - If true, skip backup before deletion (default: false)
+     * @param force - If true, skip confirmation checks (default: false)
+     * @param userConfirmed - If true, user has explicitly confirmed deletion (default: false)
+     */
+    static deleteIdentity(skipBackup?: boolean, force?: boolean, userConfirmed?: boolean): Promise<void>;
+    /**
+     * Backup identity to SecureStore (separate backup storage)
+     * This provides a recovery mechanism if primary storage fails
+     */
+    static backupIdentity(): Promise<boolean>;
+    /**
+     * Verify identity integrity - checks if keys are valid and accessible
+     */
+    static verifyIdentityIntegrity(): Promise<boolean>;
+    /**
+     * Restore identity from backup if primary storage is corrupted
+     */
+    static restoreIdentityFromBackup(): Promise<boolean>;
+    /**
+     * Get the elliptic curve key object from the stored private key
+     * Used internally for signing operations
+     */
+    static getKeyPairObject(): Promise<ECKeyPair | null>;
+    /**
+     * Derive public key from a private key (without storing)
+     */
+    static derivePublicKey(privateKey: string): string;
+    /**
+     * Validate that a string is a valid public key
+     */
+    static isValidPublicKey(publicKey: string): boolean;
+    /**
+     * Validate that a string is a valid private key
+     */
+    static isValidPrivateKey(privateKey: string): boolean;
+    /**
+     * Get a shortened version of the public key for display
+     * Format: first 8 chars...last 8 chars
+     */
+    static shortenPublicKey(publicKey: string): string;
+}
+export default KeyManager;
+//# sourceMappingURL=keyManager.d.ts.map

package/lib/typescript/module/crypto/keyManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyManager.d.ts","sourceRoot":"","sources":["../../../../src/crypto/keyManager.ts"],"names":[],"mappings":"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"}

package/lib/typescript/module/crypto/polyfill.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Crypto Polyfills for React Native
+ *
+ * This file ensures that required polyfills are available
+ * before any crypto operations are performed.
+ *
+ * Polyfills included:
+ * - Buffer: Required by bip39 and other crypto libraries
+ * - crypto.getRandomValues: Required by bip39 for secure random number generation
+ */
+import { Buffer } from 'buffer';
+export { Buffer };
+//# sourceMappingURL=polyfill.d.ts.map

package/lib/typescript/module/crypto/polyfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyfill.d.ts","sourceRoot":"","sources":["../../../../src/crypto/polyfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAkEhC,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/lib/typescript/module/crypto/recoveryPhrase.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Recovery Phrase Service - BIP39 Mnemonic Generation
+ *
+ * Handles generation and restoration of recovery phrases (mnemonic seeds)
+ * for backing up and restoring user identities.
+ *
+ * Note: This module requires the polyfill to be loaded first (done via crypto/index.ts)
+ */
+export interface RecoveryPhraseResult {
+    phrase: string;
+    words: string[];
+    publicKey: string;
+}
+export declare class RecoveryPhraseService {
+    /**
+     * Generate a new identity with a recovery phrase
+     * Returns the mnemonic phrase (should only be shown once to the user)
+     */
+    static generateIdentityWithRecovery(): Promise<RecoveryPhraseResult>;
+    /**
+     * Generate a 24-word recovery phrase for higher security
+     */
+    static generateIdentityWithRecovery24(): Promise<RecoveryPhraseResult>;
+    /**
+     * Restore an identity from a recovery phrase
+     */
+    static restoreFromPhrase(phrase: string): Promise<string>;
+    /**
+     * Validate a recovery phrase without importing it
+     */
+    static validatePhrase(phrase: string): boolean;
+    /**
+     * Get the word list for autocomplete/validation
+     */
+    static getWordList(): string[];
+    /**
+     * Check if a word is valid in the BIP39 word list
+     */
+    static isValidWord(word: string): boolean;
+    /**
+     * Get suggestions for a partial word
+     */
+    static getSuggestions(partial: string, limit?: number): string[];
+    /**
+     * Derive the public key from a phrase without storing
+     * Useful for verification before importing
+     */
+    static derivePublicKeyFromPhrase(phrase: string): Promise<string>;
+    /**
+     * Convert a phrase to its word array
+     */
+    static phraseToWords(phrase: string): string[];
+    /**
+     * Convert a word array to a phrase string
+     */
+    static wordsToPhrase(words: string[]): string;
+}
+export default RecoveryPhraseService;
+//# sourceMappingURL=recoveryPhrase.d.ts.map

package/lib/typescript/module/crypto/recoveryPhrase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recoveryPhrase.d.ts","sourceRoot":"","sources":["../../../../src/crypto/recoveryPhrase.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAiBH,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,qBAAqB;IAChC;;;OAGG;WACU,4BAA4B,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAsB1E;;OAEG;WACU,8BAA8B,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAgB5E;;OAEG;WACU,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAmB/D;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAK9C;;OAEG;IACH,MAAM,CAAC,WAAW,IAAI,MAAM,EAAE;IAI9B;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIzC;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAU,GAAG,MAAM,EAAE;IAOnE;;;OAGG;WACU,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAcvE;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAI9C;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM;CAG9C;AAED,eAAe,qBAAqB,CAAC"}

package/lib/typescript/module/crypto/signatureService.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Signature Service - ECDSA Digital Signatures
+ *
+ * Handles signing and verification of messages using ECDSA secp256k1.
+ * Used for authenticating requests and proving identity ownership.
+ */
+export interface SignedMessage {
+    message: string;
+    signature: string;
+    publicKey: string;
+    timestamp: number;
+}
+export interface AuthChallenge {
+    challenge: string;
+    publicKey: string;
+    timestamp: number;
+}
+export declare class SignatureService {
+    /**
+     * Generate a random challenge string (for offline use)
+     * Uses expo-crypto in React Native, crypto.randomBytes in Node.js
+     */
+    static generateChallenge(): Promise<string>;
+    /**
+     * Hash a message using SHA-256
+     */
+    static hashMessage(message: string): Promise<string>;
+    /**
+     * Sign a message using the stored private key
+     * Returns the signature in DER format (hex encoded)
+     */
+    static sign(message: string): Promise<string>;
+    /**
+     * Sign a message with an explicit private key (without storing)
+     * Useful for one-time operations or testing
+     */
+    static signWithKey(message: string, privateKey: string): Promise<string>;
+    /**
+     * Verify a signature against a message and public key
+     */
+    static verify(message: string, signature: string, publicKey: string): Promise<boolean>;
+    /**
+     * 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: string, signature: string, publicKey: string): boolean;
+    /**
+     * Create a signed message object with metadata
+     */
+    static createSignedMessage(message: string): Promise<SignedMessage>;
+    /**
+     * Verify a signed message object
+     * Checks both signature validity and timestamp freshness
+     */
+    static verifySignedMessage(signedMessage: SignedMessage, maxAgeMs?: number): Promise<boolean>;
+    /**
+     * Create a signed authentication challenge response
+     * Used for challenge-response authentication
+     */
+    static signChallenge(challenge: string): Promise<AuthChallenge>;
+    /**
+     * Verify a challenge response
+     */
+    static verifyChallengeResponse(originalChallenge: string, response: AuthChallenge, maxAgeMs?: number): Promise<boolean>;
+    /**
+     * Create a registration signature
+     * Used when registering a new identity with the server
+     * Format matches server expectation: oxy:register:{publicKey}:{timestamp}
+     */
+    static createRegistrationSignature(): Promise<{
+        signature: string;
+        publicKey: string;
+        timestamp: number;
+    }>;
+    /**
+     * Sign arbitrary data for API requests
+     * Creates a canonical string representation and signs it
+     */
+    static signRequestData(data: Record<string, unknown>): Promise<{
+        signature: string;
+        publicKey: string;
+        timestamp: number;
+    }>;
+}
+export default SignatureService;
+//# sourceMappingURL=signatureService.d.ts.map

package/lib/typescript/module/crypto/signatureService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signatureService.d.ts","sourceRoot":"","sources":["../../../../src/crypto/signatureService.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAiEH,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,gBAAgB;IAC3B;;;OAGG;WACU,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IA0BjD;;OAEG;WACU,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI1D;;;OAGG;WACU,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAWnD;;;OAGG;WACU,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAO9E;;OAEG;WACU,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAU5F;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;IAkBjF;;OAEG;WACU,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAkBzE;;;OAGG;WACU,mBAAmB,CAC9B,aAAa,EAAE,aAAa,EAC5B,QAAQ,GAAE,MAAsB,GAC/B,OAAO,CAAC,OAAO,CAAC;IAcnB;;;OAGG;WACU,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAiBrE;;OAEG;WACU,uBAAuB,CAClC,iBAAiB,EAAE,MAAM,EACzB,QAAQ,EAAE,aAAa,EACvB,QAAQ,GAAE,MAAsB,GAC/B,OAAO,CAAC,OAAO,CAAC;IAanB;;;;OAIG;WACU,2BAA2B,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAiBhH;;;OAGG;WACU,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;QACnE,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CAsBH;AAED,eAAe,gBAAgB,CAAC"}

package/lib/typescript/module/i18n/index.d.ts

@@ -0,0 +1,4 @@
+export type LocaleDict = Record<string, any>;
+export declare function translate(locale: string | undefined, key: string, vars?: Record<string, string | number>): string;
+export declare function hasKey(locale: string | undefined, key: string): boolean;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/i18n/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/i18n/index.ts"],"names":[],"mappings":"AAwBA,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAiC7C,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,CAYjH;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAGvE"}

package/lib/typescript/module/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * OxyHQServices Main Export File - Universal (Frontend + Backend)
+ *
+ * This exports everything but uses environment detection to avoid crashes.
+ * - Frontend: Full UI + Core functionality
+ * - Backend: Core functionality only (UI components are no-ops)
+ */
+import './crypto/polyfill';
+export { KeyManager, SignatureService, RecoveryPhraseService } from './crypto';
+export { OxyServices, OxyAuthenticationError, OxyAuthenticationTimeoutError } from './core';
+export { OXY_CLOUD_URL, oxyClient } from './core';
+export { CrossDomainAuth, createCrossDomainAuth } from './core';
+export type { CrossDomainAuthOptions } from './core';
+export type { KeyPair, SignedMessage, AuthChallenge, RecoveryPhraseResult } from './crypto';
+export { useOxy } from './ui/context/OxyContext';
+export { default as OxyProvider } from './ui/components/OxyProvider';
+export { DeviceManager } from './utils/deviceManager';
+export type { DeviceFingerprint, StoredDeviceInfo } from './utils/deviceManager';
+export { SUPPORTED_LANGUAGES, getLanguageMetadata, getLanguageName, getNativeLanguageName, normalizeLanguageCode } from './utils/languageUtils';
+export type { LanguageMetadata } from './utils/languageUtils';
+export type { OxyConfig, User, LoginResponse, Notification, Wallet, Transaction, TransferFundsRequest, PurchaseRequest, WithdrawalRequest, TransactionResponse, KarmaRule, KarmaHistory, KarmaLeaderboardEntry, KarmaAwardRequest, ApiError, PaymentMethod, PaymentRequest, PaymentResponse, AnalyticsData, FollowerDetails, ContentViewer, FileMetadata, FileUploadResponse, FileListResponse, FileUpdateRequest, FileDeleteResponse, DeviceSession, DeviceSessionsResponse, DeviceSessionLogoutResponse, UpdateDeviceNameResponse, BlockedUser, RestrictedUser, FileVisibility, AssetLink, AssetVariant, Asset, AssetInitRequest, AssetInitResponse, AssetCompleteRequest, AssetLinkRequest, AssetUnlinkRequest, AssetUrlResponse, AssetDeleteSummary, AssetUploadProgress, AssetUpdateVisibilityRequest, AssetUpdateVisibilityResponse, AccountStorageCategoryUsage, AccountStorageUsageResponse, SecurityEventType, SecurityEventSeverity, SecurityActivity, SecurityActivityResponse } from './models/interfaces';
+export { SECURITY_EVENT_SEVERITY_MAP } from './models/interfaces';
+export type { SessionLoginResponse, ClientSession, MinimalUserData } from './models/session';
+export { useAuthStore } from './ui/stores/authStore';
+export { useAssetStore, useAssets as useAssetsStore, useAsset, useUploadProgress, useAssetLoading, useAssetErrors, useAssetsByApp, useAssetsByEntity, useAssetUsageCount, useIsAssetLinked } from './ui/stores/assetStore';
+export { useSessionSocket } from './ui/hooks/useSessionSocket';
+export { useAssets, setOxyAssetInstance } from './ui/hooks/useAssets';
+export { useFileDownloadUrl, setOxyFileUrlInstance } from './ui/hooks/useFileDownloadUrl';
+export { useUserProfile, useUserProfiles, useCurrentUser, useUserById, useUserByUsername, useUsersBySessions, usePrivacySettings, useSessions, useSession, useDeviceSessions, useUserDevices, useSecurityInfo, useSecurityActivity, useRecentSecurityActivity, } from './ui/hooks/queries';
+export { useUpdateProfile, useUploadAvatar, useUpdateAccountSettings, useUpdatePrivacySettings, useUploadFile, useSwitchSession, useLogoutSession, useLogoutAll, useUpdateDeviceName, useRemoveDevice, } from './ui/hooks/mutations';
+export { OxySignInButton } from './ui/components/OxySignInButton';
+export { OxyLogo, FollowButton } from './ui';
+export * from './utils/apiUtils';
+export { ErrorCodes, createApiError, handleHttpError, validateRequiredFields, retryWithBackoff } from './utils/errorUtils';
+export * from './utils/validationUtils';
+export { logger, LogLevel, LogContext, logAuth, logApi, logSession, logUser, logDevice, logPayment, logPerformance } from './utils/loggerUtils';
+export * from './utils/asyncUtils';
+export * from './utils/hookUtils';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"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"}

package/lib/typescript/module/lib/sonner-safe.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Safe sonner export that works in both frontend and backend
+ * In frontend: exports the actual toast function
+ * In backend: exports a no-op function
+ */
+type ToastFunction = (message: string, options?: Record<string, unknown>) => void;
+declare let toast: ToastFunction;
+export { toast };
+//# sourceMappingURL=sonner-safe.d.ts.map

package/lib/typescript/module/lib/sonner-safe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sonner-safe.d.ts","sourceRoot":"","sources":["../../../../src/lib/sonner-safe.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,KAAK,aAAa,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;AAElF,QAAA,IAAI,KAAK,EAAE,aAAa,CAAC;AAqBzB,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/lib/typescript/module/lib/sonner.d.ts

@@ -0,0 +1,15 @@
+interface ToastFunction {
+    (message: string, options?: Record<string, unknown>): void;
+    success: (message: string, options?: Record<string, unknown>) => void;
+    error: (message: string, options?: Record<string, unknown>) => void;
+    info: (message: string, options?: Record<string, unknown>) => void;
+    warning: (message: string, options?: Record<string, unknown>) => void;
+    loading: (message: string, options?: Record<string, unknown>) => void;
+}
+type ToasterComponent = (props?: Record<string, unknown>) => React.ReactElement | null;
+declare const webToast: ToastFunction;
+export declare const toast: ToastFunction;
+export declare const Toaster: ToasterComponent;
+export type ToastT = typeof webToast;
+export {};
+//# sourceMappingURL=sonner.d.ts.map

package/lib/typescript/module/lib/sonner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sonner.d.ts","sourceRoot":"","sources":["../../../../src/lib/sonner.ts"],"names":[],"mappings":"AAKA,UAAU,aAAa;IACrB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC3D,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACtE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACpE,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACnE,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACtE,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;CACvE;AAED,KAAK,gBAAgB,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC;AAEvF,QAAA,MAAe,QAAQ,eAGtB,CAAC;AAMF,eAAO,MAAM,KAAK,eAAiD,CAAC;AACpE,eAAO,MAAM,OAAO,kBAAqD,CAAC;AAC1E,MAAM,MAAM,MAAM,GAAG,OAAO,QAAQ,CAAC"}