@getpara/react-native-wallet 2.0.0-fc.3 → 2.1.0

package/README.md

@@ -0,0 +1,21 @@
+https://www.npmjs.com/package/@getpara/react-native-wallet
+
+The `@getpara/react-native-wallet` package is Para's React Native SDK for building mobile wallet applications.
+
+###Key Features
+
+- Native Passkey Authentication: Uses device biometrics and passkeys for secure wallet access
+- Multi-blockchain Support: Works with EVM, Solana, and Cosmos networks
+- Custom Storage: Supports MMKV for improved performance over AsyncStorage
+- OAuth Integration: Supports social login with Google, Discord, and Farcaster
+- Pregenerated Wallets: Create wallets before user authentication
+
+###Prerequisites
+
+To use Para, you need an API key. This key authenticates your requests to Para services and is essential for integration.
+
+Don't have an API key yet? Request access to the [Developer Portal](https://developer.getpara.com/) to create API keys, manage billing, teams, and more.
+
+###Learn more
+
+For more information on Para’s React Native SDK visit the [Para Docs](https://docs.getpara.com/v2/react-native/setup/react-native)

package/dist/config.d.ts

@@ -1,5 +1,5 @@
 import { Environment } from '@getpara/web-sdk';
-declare function getPortalBaseURL(env: Environment): "http://localhost:3003" | "https://app.sandbox.usecapsule.com" | "https://app.beta.usecapsule.com" | "https://app.usecapsule.com";
+declare function getPortalBaseURL(env: Environment): "http://localhost:3003" | "https://app.sandbox.getpara.com" | "https://app.beta.getpara.com" | "https://app.getpara.com";
 declare function getBaseUrl(env: Environment): string;
 export declare function getBaseMPCNetworkWSUrl(env: Environment): string;
 export declare let userManagementServer: string;

package/dist/config.js

@@ -5,11 +5,11 @@ function getPortalBaseURL(env) {
         case Environment.DEV:
             return 'http://localhost:3003';
         case Environment.SANDBOX:
-            return 'https://app.sandbox.usecapsule.com';
+            return 'https://app.sandbox.getpara.com';
         case Environment.BETA:
-            return 'https://app.beta.usecapsule.com';
+            return 'https://app.beta.getpara.com';
         case Environment.PROD:
-            return 'https://app.usecapsule.com';
+            return 'https://app.getpara.com';
         default:
             throw new Error(`env: ${env} not supported`);
     }

package/dist/react-native/ParaMobile.d.ts

@@ -11,13 +11,14 @@ export declare class ParaMobile extends ParaCore {
     private relyingPartyId;
     /**
      * Creates an instance of ParaMobile.
-     * @param {Environment} env - The environment to use (DEV, SANDBOX, BETA, or PROD).
+     * @param {Environment} env - The environment to use (DEV, SANDBOX, BETA, or PROD). Optional if the apiKey contains an environment prefix (e.g., "prod_your_api_key"). Updated API keys can be found at https://developer.getpara.com.
      * @param {string} [apiKey] - The API key for authentication.
      * @param {string} [relyingPartyId] - The relying party ID for WebAuthn.
      * @param {ConstructorOpts} [opts] - Additional constructor options.
      */
-    constructor(env: Environment, apiKey: string, relyingPartyId?: string, opts?: ConstructorOpts);
-    protected ready(): Promise<void>;
+    constructor(env: Environment | undefined, apiKey: string, relyingPartyId?: string, opts?: ConstructorOpts);
+    constructor(apiKey: string, relyingPartyId?: string, opts?: ConstructorOpts);
+    ready(): Promise<void>;
     protected getPlatformUtils(): PlatformUtils;
     isPasskeySupported(): Promise<boolean>;
     /**

package/dist/react-native/ParaMobile.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { ParaCore, Environment, decryptPrivateKeyAndDecryptShare, encryptPrivateKey, getAsymmetricKeyPair, getDerivedPrivateKeyAndDecrypt, getPublicKeyHex, getSHA256HashHex, parseCredentialCreationRes, } from '@getpara/web-sdk';
 import { ReactNativeUtils } from './ReactNativeUtils.js';
 import { Passkey, } from 'react-native-passkey';
-import { PublicKeyStatus } from '@getpara/user-management-client';
+import { AuthMethodStatus } from '@getpara/user-management-client';
 import { setEnv } from '../config.js';
 import base64url from 'base64url';
 import { webcrypto } from 'crypto';
@@ -24,14 +24,59 @@ const RS256_ALGORITHM = -257;
  * const para = new ParaMobile(Environment.BETA, "api_key");
  */
 export class ParaMobile extends ParaCore {
-    /**
-     * Creates an instance of ParaMobile.
-     * @param {Environment} env - The environment to use (DEV, SANDBOX, BETA, or PROD).
-     * @param {string} [apiKey] - The API key for authentication.
-     * @param {string} [relyingPartyId] - The relying party ID for WebAuthn.
-     * @param {ConstructorOpts} [opts] - Additional constructor options.
-     */
-    constructor(env, apiKey, relyingPartyId, opts) {
+    constructor(envOrApiKey, apiKeyOrRelyingPartyId, relyingPartyIdOrOpts, optsArg) {
+        let env, apiKey, relyingPartyId, opts;
+        // Helper function to check if value is a valid Environment
+        const isEnvironment = (value) => {
+            return Object.values(Environment).includes(value);
+        };
+        if (arguments.length === 1) {
+            // 1-parameter case: (apiKey)
+            env = undefined;
+            apiKey = envOrApiKey;
+            relyingPartyId = undefined;
+            opts = undefined;
+        }
+        else if (arguments.length === 2) {
+            if (isEnvironment(envOrApiKey)) {
+                // 2-parameter case: (env, apiKey)
+                env = envOrApiKey;
+                apiKey = apiKeyOrRelyingPartyId;
+                relyingPartyId = undefined;
+                opts = undefined;
+            }
+            else {
+                // 2-parameter case: (apiKey, relyingPartyId)
+                env = undefined;
+                apiKey = envOrApiKey;
+                relyingPartyId = apiKeyOrRelyingPartyId;
+                opts = undefined;
+            }
+        }
+        else if (arguments.length === 3) {
+            if (isEnvironment(envOrApiKey)) {
+                // 3-parameter case: (env, apiKey, relyingPartyId)
+                env = envOrApiKey;
+                apiKey = apiKeyOrRelyingPartyId;
+                relyingPartyId = relyingPartyIdOrOpts;
+                opts = undefined;
+            }
+            else {
+                // 3-parameter case: (apiKey, relyingPartyId, opts)
+                env = undefined;
+                apiKey = envOrApiKey;
+                relyingPartyId = apiKeyOrRelyingPartyId;
+                opts = relyingPartyIdOrOpts;
+            }
+        }
+        else {
+            // 4-parameter case: (env, apiKey, relyingPartyId, opts)
+            env = envOrApiKey;
+            apiKey = apiKeyOrRelyingPartyId;
+            relyingPartyId = relyingPartyIdOrOpts;
+            opts = optsArg;
+        }
+        env = ParaCore.resolveEnvironment(env, apiKey); // Ensure the environment is resolved before calling super
         super(env, apiKey, opts);
         this.isNativePasskey = true;
         setEnv(env);
@@ -135,7 +180,7 @@ export class ParaMobile extends ParaCore {
                 sigDerivedPublicKey: publicKeyHex,
                 cosePublicKey,
                 clientDataJSON,
-                status: PublicKeyStatus.COMPLETE,
+                status: AuthMethodStatus.COMPLETE,
             });
             yield this.ctx.client.uploadEncryptedWalletPrivateKey(userId, encryptedPrivateKeyHex, encryptionKeyHash, resultJson.id);
         });

package/dist/react-native/ReactNativeUtils.d.ts

@@ -48,4 +48,5 @@ export declare class ReactNativeUtils implements PlatformUtils {
         walletId: string;
     }>;
     ed25519Sign(ctx: Ctx, userId: string, walletId: string, share: string, base64Bytes: string, _sessionCookie: string): Promise<SignatureRes>;
+    initializeWorker(_ctx: Ctx): Promise<void>;
 }

package/dist/react-native/ReactNativeUtils.js

@@ -168,4 +168,9 @@ export class ReactNativeUtils {
             return { signature: base64Sig };
         });
     }
+    initializeWorker(_ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
+    }
 }

package/dist/shim.d.ts

@@ -1 +1,130 @@
-export {};
+export function ensureParaCrypto(): {
+    baseCrypto: webcrypto.Crypto | {
+        getCiphers: () => string[];
+        getHashes: () => string[];
+        webcrypto: {
+            subtle: import("react-native-quick-crypto/lib/typescript/src/subtle").Subtle;
+            SubtleCrypto: typeof import("react-native-quick-crypto/lib/typescript/src/subtle").Subtle;
+            CryptoKey: typeof import("react-native-quick-crypto/lib/typescript/src/keys").CryptoKey;
+        };
+        randomFill<T extends import("react-native-quick-crypto/lib/typescript/src/Utils").ABV>(buffer: T, callback: (err: Error | null, buf: T) => void): void;
+        randomFill<T extends import("react-native-quick-crypto/lib/typescript/src/Utils").ABV>(buffer: T, offset: number, callback: (err: Error | null, buf: T) => void): void;
+        randomFill<T extends import("react-native-quick-crypto/lib/typescript/src/Utils").ABV>(buffer: T, offset: number, size: number, callback: (err: Error | null, buf: T) => void): void;
+        randomFillSync<T extends import("react-native-quick-crypto/lib/typescript/src/Utils").ABV>(buffer: T, offset?: number, size?: number): T;
+        randomBytes(size: number): Buffer;
+        randomBytes(size: number, callback: (err: Error | null, buf?: Buffer) => void): void;
+        randomInt(max: number, callback: (err: Error | null, value: number) => void): void;
+        randomInt(max: number): number;
+        randomInt(min: number, max: number, callback: (err: Error | null, value: number) => void): void;
+        randomInt(min: number, max: number): number;
+        getRandomValues(data: import("react-native-quick-crypto/lib/typescript/src/random").RandomTypedArrays): import("react-native-quick-crypto/lib/typescript/src/random").RandomTypedArrays;
+        randomUUID(): string;
+        rng: typeof import("react-native-quick-crypto/lib/typescript/src/random").randomBytes;
+        pseudoRandomBytes: typeof import("react-native-quick-crypto/lib/typescript/src/random").randomBytes;
+        prng: typeof import("react-native-quick-crypto/lib/typescript/src/random").randomBytes;
+        pbkdf2(password: import("react-native-quick-crypto/lib/typescript/src/Utils").BinaryLike, salt: import("react-native-quick-crypto/lib/typescript/src/Utils").BinaryLike, iterations: number, keylen: number, digest: string, callback: (err: Error | null, derivedKey?: Buffer) => void): void;
+        pbkdf2Sync(password: import("react-native-quick-crypto/lib/typescript/src/Utils").BinaryLike, salt: import("react-native-quick-crypto/lib/typescript/src/Utils").BinaryLike, iterations: number, keylen: number, digest?: string): ArrayBuffer;
+        pbkdf2DeriveBits(algorithm: import("react-native-quick-crypto/lib/typescript/src/keys").SubtleAlgorithm, baseKey: import("react-native-quick-crypto/lib/typescript/src/keys").CryptoKey, length: number): Promise<ArrayBuffer>;
+        createHmac: typeof import("react-native-quick-crypto/lib/typescript/src/Hmac").createHmac;
+        Hmac: typeof import("react-native-quick-crypto/lib/typescript/src/Hmac").createHmac;
+        Hash: typeof import("react-native-quick-crypto/lib/typescript/src/Hash").createHash;
+        createHash: typeof import("react-native-quick-crypto/lib/typescript/src/Hash").createHash;
+        createCipher: typeof import("react-native-quick-crypto/lib/typescript/src/Cipher").createCipher;
+        createCipheriv: typeof import("react-native-quick-crypto/lib/typescript/src/Cipher").createCipheriv;
+        createDecipher: typeof import("react-native-quick-crypto/lib/typescript/src/Cipher").createDecipher;
+        createDecipheriv: typeof import("react-native-quick-crypto/lib/typescript/src/Cipher").createDecipheriv;
+        createPublicKey: typeof import("react-native-quick-crypto/lib/typescript/src/keys").createPublicKey;
+        createPrivateKey: (key: import("react-native-quick-crypto/lib/typescript/src/Utils").BinaryLike | import("react-native-quick-crypto/lib/typescript/src/keys").EncodingOptions) => import("react-native-quick-crypto/lib/typescript/src/keys").PrivateKeyObject;
+        createSecretKey: typeof import("react-native-quick-crypto/lib/typescript/src/keys").createSecretKey;
+        publicEncrypt: (options: import("react-native-quick-crypto/lib/typescript/src/keys").EncodingOptions | import("react-native-quick-crypto/lib/typescript/src/Utils").BinaryLike, buffer: import("react-native-quick-crypto/lib/typescript/src/Utils").BinaryLike) => Buffer;
+        publicDecrypt: (options: import("react-native-quick-crypto/lib/typescript/src/keys").EncodingOptions | import("react-native-quick-crypto/lib/typescript/src/Utils").BinaryLike, buffer: import("react-native-quick-crypto/lib/typescript/src/Utils").BinaryLike) => Buffer;
+        privateDecrypt: (options: import("react-native-quick-crypto/lib/typescript/src/keys").EncodingOptions | import("react-native-quick-crypto/lib/typescript/src/Utils").BinaryLike, buffer: import("react-native-quick-crypto/lib/typescript/src/Utils").BinaryLike) => Buffer;
+        generateKey: (type: import("react-native-quick-crypto/lib/typescript/src/keys").SecretKeyType, options: import("react-native-quick-crypto/lib/typescript/src/keys").AesKeyGenParams, callback: import("react-native-quick-crypto/lib/typescript/src/keygen").KeyGenCallback) => void;
+        generateKeyPair: (type: import("react-native-quick-crypto/lib/typescript/src/keys").KeyPairType, options: import("react-native-quick-crypto/lib/typescript/src/Cipher").GenerateKeyPairOptions, callback: import("react-native-quick-crypto/lib/typescript/src/Cipher").GenerateKeyPairCallback) => void;
+        generateKeyPairSync: typeof import("react-native-quick-crypto/lib/typescript/src/Cipher").generateKeyPairSync;
+        generateKeySync: (type: import("react-native-quick-crypto/lib/typescript/src/keys").SecretKeyType, options: import("react-native-quick-crypto/lib/typescript/src/keys").AesKeyGenParams) => import("react-native-quick-crypto/lib/typescript/src/keys").SecretKeyObject;
+        createSign: typeof import("react-native-quick-crypto/lib/typescript/src/sig").createSign;
+        createVerify: typeof import("react-native-quick-crypto/lib/typescript/src/sig").createVerify;
+        subtle: import("react-native-quick-crypto/lib/typescript/src/subtle").Subtle;
+        constants: {
+            OPENSSL_VERSION_NUMBER: number;
+            SSL_OP_ALL: number;
+            SSL_OP_ALLOW_NO_DHE_KEX: number;
+            SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number;
+            SSL_OP_CIPHER_SERVER_PREFERENCE: number;
+            SSL_OP_CISCO_ANYCONNECT: number;
+            SSL_OP_COOKIE_EXCHANGE: number;
+            SSL_OP_CRYPTOPRO_TLSEXT_BUG: number;
+            SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: number;
+            SSL_OP_EPHEMERAL_RSA: number;
+            SSL_OP_LEGACY_SERVER_CONNECT: number;
+            SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: number;
+            SSL_OP_MICROSOFT_SESS_ID_BUG: number;
+            SSL_OP_MSIE_SSLV2_RSA_PADDING: number;
+            SSL_OP_NETSCAPE_CA_DN_BUG: number;
+            SSL_OP_NETSCAPE_CHALLENGE_BUG: number;
+            SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: number;
+            SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: number;
+            SSL_OP_NO_COMPRESSION: number;
+            SSL_OP_NO_ENCRYPT_THEN_MAC: number;
+            SSL_OP_NO_QUERY_MTU: number;
+            SSL_OP_NO_RENEGOTIATION: number;
+            SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number;
+            SSL_OP_NO_SSLv2: number;
+            SSL_OP_NO_SSLv3: number;
+            SSL_OP_NO_TICKET: number;
+            SSL_OP_NO_TLSv1: number;
+            SSL_OP_NO_TLSv1_1: number;
+            SSL_OP_NO_TLSv1_2: number;
+            SSL_OP_NO_TLSv1_3: number;
+            SSL_OP_PKCS1_CHECK_1: number;
+            SSL_OP_PKCS1_CHECK_2: number;
+            SSL_OP_PRIORITIZE_CHACHA: number;
+            SSL_OP_SINGLE_DH_USE: number;
+            SSL_OP_SINGLE_ECDH_USE: number;
+            SSL_OP_SSLEAY_080_CLIENT_DH_BUG: number;
+            SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: number;
+            SSL_OP_TLS_BLOCK_PADDING_BUG: number;
+            SSL_OP_TLS_D5_BUG: number;
+            SSL_OP_TLS_ROLLBACK_BUG: number;
+            ENGINE_METHOD_RSA: number;
+            ENGINE_METHOD_DSA: number;
+            ENGINE_METHOD_DH: number;
+            ENGINE_METHOD_RAND: number;
+            ENGINE_METHOD_EC: number;
+            ENGINE_METHOD_CIPHERS: number;
+            ENGINE_METHOD_DIGESTS: number;
+            ENGINE_METHOD_PKEY_METHS: number;
+            ENGINE_METHOD_PKEY_ASN1_METHS: number;
+            ENGINE_METHOD_ALL: number;
+            ENGINE_METHOD_NONE: number;
+            DH_CHECK_P_NOT_SAFE_PRIME: number;
+            DH_CHECK_P_NOT_PRIME: number;
+            DH_UNABLE_TO_CHECK_GENERATOR: number;
+            DH_NOT_SUITABLE_GENERATOR: number;
+            ALPN_ENABLED: number;
+            RSA_PKCS1_PADDING: number;
+            RSA_SSLV23_PADDING: number;
+            RSA_NO_PADDING: number;
+            RSA_PKCS1_OAEP_PADDING: number;
+            RSA_X931_PADDING: number;
+            RSA_PKCS1_PSS_PADDING: number;
+            RSA_PSS_SALTLEN_DIGEST: number;
+            RSA_PSS_SALTLEN_MAX_SIGN: number;
+            RSA_PSS_SALTLEN_AUTO: number;
+            defaultCoreCipherList: string;
+            TLS1_VERSION: number;
+            TLS1_1_VERSION: number;
+            TLS1_2_VERSION: number;
+            TLS1_3_VERSION: number;
+            POINT_CONVERSION_COMPRESSED: number;
+            POINT_CONVERSION_UNCOMPRESSED: number;
+            POINT_CONVERSION_HYBRID: number;
+        };
+    };
+    peculiarCrypto: PeculiarCrypto;
+};
+export function ensureCreateECDH(): any;
+import { webcrypto } from 'crypto';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { Crypto as PeculiarCrypto } from '@peculiar/webcrypto';

package/dist/shim.js

@@ -1,6 +1,7 @@
-import crypto from 'react-native-quick-crypto';
+import quickCrypto from 'react-native-quick-crypto';
 import { webcrypto } from 'crypto';
-import { Crypto } from '@peculiar/webcrypto';
+import { Crypto as PeculiarCrypto } from '@peculiar/webcrypto';
+import { ec as EllipticEC } from 'elliptic';
 import Forge from 'node-forge';
 import modPow from 'react-native-modpow';
 import { atob, btoa } from 'react-native-quick-base64';
@@ -8,7 +9,37 @@ import { Buffer } from '@craftzdog/react-native-buffer';
 import process from 'process';
 import 'react-native-url-polyfill/auto';
 import { TextEncoder, TextDecoder } from 'text-encoding';
-import structuredClone from '@ungap/structured-clone';
+let cachedStructuredCloneImpl;
+const resolveStructuredClone = () => {
+    if (typeof cachedStructuredCloneImpl !== 'undefined') {
+        return cachedStructuredCloneImpl;
+    }
+    if (typeof globalThis.structuredClone === 'function') {
+        cachedStructuredCloneImpl = globalThis.structuredClone.bind(globalThis);
+        return cachedStructuredCloneImpl;
+    }
+    const isHermes = typeof globalThis.HermesInternal === 'object' && globalThis.HermesInternal !== null;
+    if (isHermes) {
+        // Hermes crashes when @ungap/structured-clone rewires Reflect helpers.
+        cachedStructuredCloneImpl = null;
+        return cachedStructuredCloneImpl;
+    }
+    try {
+        const maybePolyfill = require('@ungap/structured-clone');
+        const polyfill = (maybePolyfill && maybePolyfill.default) || maybePolyfill;
+        if (typeof polyfill === 'function') {
+            cachedStructuredCloneImpl = polyfill;
+            return cachedStructuredCloneImpl;
+        }
+    }
+    catch (err) {
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+            console.warn('[Para React Native shim] Failed to load structuredClone polyfill', err);
+        }
+    }
+    cachedStructuredCloneImpl = null;
+    return cachedStructuredCloneImpl;
+};
 const setupProcessPolyfill = () => {
     if (typeof globalThis.process === 'undefined') {
         globalThis.process = process;
@@ -33,16 +64,191 @@ const setupBase64Polyfills = () => {
         throw new Error('Base64 polyfills failed to initialize');
     }
 };
-const setupCryptoPolyfills = () => {
-    const peculiarCrypto = new Crypto();
-    if (typeof globalThis.crypto === 'undefined') {
-        globalThis.crypto = crypto;
+const curveAliases = {
+    'P-256': 'p256',
+    'p-256': 'p256',
+    'prime256v1': 'p256',
+    'secp256r1': 'p256',
+    'secp256k1': 'secp256k1',
+};
+const getBufferImpl = () => {
+    const BufferImpl = globalThis.Buffer;
+    if (!BufferImpl) {
+        // prettier-ignore
+        throw new Error("[Para React Native shim] Buffer global missing. Please import '@getpara/react-native-wallet/shim' before using cryptography helpers.");
+    }
+    return BufferImpl;
+};
+const bufferFrom = (data, encoding = 'binary') => {
+    const BufferImpl = getBufferImpl();
+    if (BufferImpl.isBuffer && BufferImpl.isBuffer(data)) {
+        return data;
     }
-    if (!globalThis.crypto.subtle) {
-        globalThis.crypto.subtle = peculiarCrypto.subtle;
-        globalThis.crypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+    if (typeof data === 'string') {
+        switch (encoding) {
+            case 'hex':
+                return BufferImpl.from(data, 'hex');
+            case 'base64':
+                return BufferImpl.from(data, 'base64');
+            default:
+                return BufferImpl.from(data, 'binary');
+        }
+    }
+    return BufferImpl.from(data);
+};
+const bufferTo = (buf, encoding = 'binary') => {
+    const BufferImpl = getBufferImpl();
+    switch (encoding) {
+        case 'hex':
+            return BufferImpl.from(buf).toString('hex');
+        case 'base64':
+            return BufferImpl.from(buf).toString('base64');
+        case 'binary':
+        default:
+            return BufferImpl.from(buf);
+    }
+};
+let cachedCreateECDH = null;
+const ensureCreateECDH = () => {
+    if (!cachedCreateECDH) {
+        cachedCreateECDH = curveName => {
+            const BufferImpl = getBufferImpl();
+            const normalizedCurve = curveAliases[curveName] || curveName;
+            if (!normalizedCurve && typeof __DEV__ !== 'undefined' && __DEV__) {
+                console.warn('[Para React Native shim] Unknown curve alias', curveName);
+            }
+            const ec = new EllipticEC(normalizedCurve);
+            const secretByteLength = (() => {
+                const order = (ec && ec.curve && ec.curve.n) || (ec && ec.n);
+                if (!order) {
+                    return null;
+                }
+                if (typeof order.byteLength === 'function') {
+                    return order.byteLength();
+                }
+                if (typeof order.bitLength === 'function') {
+                    return Math.ceil(order.bitLength() / 8);
+                }
+                return null;
+            })();
+            let keyPair = ec.genKeyPair();
+            return {
+                generateKeys: (encoding = 'binary', format = 'uncompressed') => {
+                    keyPair = ec.genKeyPair();
+                    const compressed = format === 'compressed' || format === 'comp';
+                    const publicKey = keyPair.getPublic(compressed, 'array');
+                    return bufferTo(BufferImpl.from(publicKey), encoding || 'binary');
+                },
+                computeSecret: (publicKey, inputEncoding = 'binary', outputEncoding = 'binary') => {
+                    const publicKeyBuf = bufferFrom(publicKey, inputEncoding || 'binary');
+                    const derived = keyPair.derive(ec.keyFromPublic(publicKeyBuf).getPublic());
+                    const padded = secretByteLength ? derived.toArray('be', secretByteLength) : derived.toArray('be');
+                    // Match Node's ECDH API: shared secret is always curve-size bytes.
+                    const secret = BufferImpl.from(padded);
+                    return bufferTo(secret, outputEncoding || 'binary');
+                },
+                getPrivateKey: (encoding = 'binary') => {
+                    return bufferTo(keyPair.getPrivate().toArrayLike(BufferImpl, 'be', 32), encoding || 'binary');
+                },
+                getPublicKey: (encoding = 'binary', format = 'uncompressed') => {
+                    const compressed = format === 'compressed' || format === 'comp';
+                    const publicKey = keyPair.getPublic(compressed, 'array');
+                    return bufferTo(BufferImpl.from(publicKey), encoding || 'binary');
+                },
+                setPrivateKey: (privateKey, encoding = 'binary') => {
+                    keyPair = ec.keyFromPrivate(bufferFrom(privateKey, encoding));
+                },
+                setPublicKey: (publicKey, encoding = 'binary') => {
+                    keyPair = ec.keyFromPublic(bufferFrom(publicKey, encoding));
+                },
+            };
+        };
+    }
+    const possibleTargets = [];
+    const globalCrypto = globalThis.crypto;
+    if (globalCrypto) {
+        possibleTargets.push(globalCrypto, globalCrypto.default);
+    }
+    possibleTargets.push(quickCrypto, quickCrypto && quickCrypto.default);
+    try {
+        const nodeCrypto = require('crypto');
+        possibleTargets.push(nodeCrypto, nodeCrypto && nodeCrypto.default);
+        // eslint-disable-next-line no-unused-vars
+    }
+    catch (_err) {
+        // The Node crypto module is not available in React Native; ignore failures.
+    }
+    const patchedTargets = new Set(possibleTargets.filter(Boolean));
+    let patched = false;
+    patchedTargets.forEach(target => {
+        if (target && typeof target === 'object' && target.createECDH !== cachedCreateECDH) {
+            try {
+                target.createECDH = cachedCreateECDH;
+                patched = true;
+            }
+            catch (err) {
+                if (typeof __DEV__ !== 'undefined' && __DEV__) {
+                    console.warn('[Para React Native shim] Failed to patch createECDH', err);
+                }
+            }
+        }
+    });
+    if (patched && typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.info('[Para React Native shim] createECDH patched function');
+    }
+    return cachedCreateECDH;
+};
+const syncWindowLikeGlobals = cryptoObj => {
+    const maybeWindow = globalThis.window;
+    if (maybeWindow && typeof maybeWindow === 'object' && maybeWindow.crypto !== cryptoObj) {
+        maybeWindow.crypto = cryptoObj;
+    }
+    const maybeSelf = globalThis.self;
+    if (maybeSelf && typeof maybeSelf === 'object' && maybeSelf.crypto !== cryptoObj) {
+        maybeSelf.crypto = cryptoObj;
+    }
+};
+const ensureParaCrypto = () => {
+    getBufferImpl();
+    const baseCrypto = (typeof globalThis.crypto === 'object' && globalThis.crypto) || quickCrypto;
+    if (!baseCrypto || typeof baseCrypto !== 'object') {
+        throw new Error('[Para React Native shim] No crypto object found to polyfill');
+    }
+    if (typeof baseCrypto.default === 'undefined') {
+        baseCrypto.default = baseCrypto;
+    }
+    const peculiarCrypto = new PeculiarCrypto();
+    baseCrypto.subtle = peculiarCrypto.subtle;
+    baseCrypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+    if (baseCrypto.default && baseCrypto.default !== baseCrypto) {
+        baseCrypto.default.subtle = baseCrypto.subtle;
+        baseCrypto.default.getRandomValues = baseCrypto.getRandomValues;
+    }
+    globalThis.crypto = baseCrypto;
+    syncWindowLikeGlobals(baseCrypto);
+    try {
+        const brorand = require('brorand');
+        if (brorand && brorand.Rand) {
+            brorand.Rand.prototype._rand = function _rand(n) {
+                const arr = new Uint8Array(n);
+                baseCrypto.getRandomValues(arr);
+                return arr;
+            };
+        }
+    }
+    catch (err) {
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+            console.warn('[Para React Native shim] Failed to patch brorand RNG', err);
+        }
+    }
+    ensureCreateECDH();
+    return { baseCrypto, peculiarCrypto };
+};
+const setupCryptoPolyfills = () => {
+    const { peculiarCrypto } = ensureParaCrypto();
+    if (webcrypto && typeof webcrypto === 'object') {
+        webcrypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
     }
-    webcrypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
     if (typeof Forge === 'undefined') {
         throw new Error('node-forge not loaded');
     }
@@ -62,14 +268,78 @@ const setupTextEncodingPolyfills = () => {
     globalThis.TextEncoder = TextEncoder;
     globalThis.TextDecoder = TextDecoder;
 };
+const setupWindowLocationPolyfill = () => {
+    const FALLBACK_HOST = 'para.mobile';
+    const FALLBACK_ORIGIN = `https://${FALLBACK_HOST}`;
+    const globalScope = globalThis;
+    if (!globalScope.window || typeof globalScope.window !== 'object') {
+        globalScope.window = globalScope;
+    }
+    const win = globalScope.window;
+    const existingLocation = (win && win.location) || globalScope.location;
+    const hasOrigin = existingLocation &&
+        typeof existingLocation === 'object' &&
+        typeof existingLocation.origin === 'string' &&
+        typeof existingLocation.host === 'string';
+    if (hasOrigin) {
+        if (!globalScope.location) {
+            globalScope.location = existingLocation;
+        }
+        return;
+    }
+    const fallbackLocation = {
+        href: `${FALLBACK_ORIGIN}/`,
+        origin: FALLBACK_ORIGIN,
+        protocol: 'https:',
+        host: FALLBACK_HOST,
+        hostname: FALLBACK_HOST,
+        port: '',
+        pathname: '/',
+    };
+    const patchedLocation = typeof existingLocation === 'object' && existingLocation !== null
+        ? Object.assign({}, fallbackLocation, existingLocation)
+        : fallbackLocation;
+    win.location = patchedLocation;
+    globalScope.location = patchedLocation;
+};
 const setupStructuredClonePolyfill = () => {
-    if (typeof globalThis.structuredClone === 'undefined') {
-        globalThis.structuredClone = structuredClone;
+    if (typeof globalThis.structuredClone === 'function') {
+        return;
     }
+    const structuredCloneImpl = resolveStructuredClone();
+    const safeStructuredClone = (value, options) => {
+        if (typeof structuredCloneImpl === 'function') {
+            try {
+                return structuredCloneImpl(value, options);
+            }
+            catch (err) {
+                if (typeof __DEV__ !== 'undefined' && __DEV__) {
+                    console.warn('[Para React Native shim] structuredClone polyfill failed, falling back to JSON clone', err);
+                }
+            }
+        }
+        try {
+            return JSON.parse(JSON.stringify(value));
+        }
+        catch (_err) {
+            if (typeof __DEV__ !== 'undefined' && __DEV__) {
+                console.warn('[Para React Native shim] JSON clone failed, returning original value', _err);
+            }
+            return value;
+        }
+    };
+    Object.defineProperty(globalThis, 'structuredClone', {
+        value: safeStructuredClone,
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
 };
 setupProcessPolyfill();
 setupBufferPolyfill();
 setupBase64Polyfills();
+setupWindowLocationPolyfill();
 setupCryptoPolyfills();
 setupTextEncodingPolyfills();
 setupStructuredClonePolyfill();
+export { ensureParaCrypto, ensureCreateECDH };

package/package.json

@@ -1,15 +1,14 @@
 {
   "name": "@getpara/react-native-wallet",
   "description": "Para Wallet for React Native",
-  "version": "2.0.0-fc.3",
+  "version": "2.1.0",
   "author": "Para Team <hello@getpara.com> (https://getpara.com)",
   "dependencies": {
-    "@getpara/core-sdk": "2.0.0-fc.3",
-    "@getpara/user-management-client": "2.0.0-fc.3",
-    "@getpara/web-sdk": "2.0.0-fc.3",
+    "@getpara/core-sdk": "2.1.0",
+    "@getpara/user-management-client": "2.1.0",
+    "@getpara/web-sdk": "2.1.0",
     "@peculiar/webcrypto": "^1.5.0",
     "@ungap/structured-clone": "1.3.0",
-    "node-forge": "1.3.1",
     "react-native-url-polyfill": "2.0.0",
     "text-encoding": "0.7.0"
   },
@@ -93,5 +92,5 @@
       ]
     }
   },
-  "gitHead": "5ba068331384bed874c0da0d3d0e1fed6bf03ff9"
+  "gitHead": "3ae7f836324a3a2a8a57156e16304aeaf0d37b42"
 }

package/para-react-native-wallet.podspec

@@ -2,6 +2,7 @@ require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+new_arch_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
 
 Pod::Spec.new do |s|
   s.name         = "para-react-native-wallet"
@@ -19,8 +20,9 @@ Pod::Spec.new do |s|
 
   s.dependency "React-Core"
 
-  # Don't install the dependencies when we run `pod install` in the old architecture.
-  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  elsif new_arch_enabled
     s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
     s.pod_target_xcconfig    = {
         "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
@@ -33,4 +35,4 @@ Pod::Spec.new do |s|
     s.dependency "RCTTypeSafety"
     s.dependency "ReactCommon/turbomodule/core"
   end
-end
+end

package/src/config.ts

@@ -6,11 +6,11 @@ function getPortalBaseURL(env: Environment) {
     case Environment.DEV:
       return 'http://localhost:3003';
     case Environment.SANDBOX:
-      return 'https://app.sandbox.usecapsule.com';
+      return 'https://app.sandbox.getpara.com';
     case Environment.BETA:
-      return 'https://app.beta.usecapsule.com';
+      return 'https://app.beta.getpara.com';
     case Environment.PROD:
-      return 'https://app.usecapsule.com';
+      return 'https://app.getpara.com';
     default:
       throw new Error(`env: ${env} not supported`);
   }

package/src/react-native/ParaMobile.ts

@@ -22,7 +22,7 @@ import {
   PasskeyGetRequest,
   PasskeyGetResult,
 } from 'react-native-passkey';
-import { CurrentWalletIds, PublicKeyStatus, TWalletScheme } from '@getpara/user-management-client';
+import { CurrentWalletIds, AuthMethodStatus, TWalletScheme } from '@getpara/user-management-client';
 import { setEnv } from '../config.js';
 import base64url from 'base64url';
 import { webcrypto } from 'crypto';
@@ -43,12 +43,70 @@ export class ParaMobile extends ParaCore {
   private relyingPartyId: string;
   /**
    * Creates an instance of ParaMobile.
-   * @param {Environment} env - The environment to use (DEV, SANDBOX, BETA, or PROD).
+   * @param {Environment} env - The environment to use (DEV, SANDBOX, BETA, or PROD). Optional if the apiKey contains an environment prefix (e.g., "prod_your_api_key"). Updated API keys can be found at https://developer.getpara.com.
    * @param {string} [apiKey] - The API key for authentication.
    * @param {string} [relyingPartyId] - The relying party ID for WebAuthn.
    * @param {ConstructorOpts} [opts] - Additional constructor options.
    */
-  constructor(env: Environment, apiKey: string, relyingPartyId?: string, opts?: ConstructorOpts) {
+  constructor(env: Environment | undefined, apiKey: string, relyingPartyId?: string, opts?: ConstructorOpts);
+  constructor(apiKey: string, relyingPartyId?: string, opts?: ConstructorOpts);
+  constructor(
+    envOrApiKey: Environment | undefined | string,
+    apiKeyOrRelyingPartyId?: string,
+    relyingPartyIdOrOpts?: string | ConstructorOpts,
+    optsArg?: ConstructorOpts,
+  ) {
+    let env: Environment | undefined, apiKey: string, relyingPartyId: string | undefined, opts: ConstructorOpts | undefined;
+
+    // Helper function to check if value is a valid Environment
+    const isEnvironment = (value: any): value is Environment => {
+      return Object.values(Environment).includes(value);
+    };
+
+    if (arguments.length === 1) {
+      // 1-parameter case: (apiKey)
+      env = undefined;
+      apiKey = envOrApiKey as string;
+      relyingPartyId = undefined;
+      opts = undefined;
+    } else if (arguments.length === 2) {
+      if (isEnvironment(envOrApiKey)) {
+        // 2-parameter case: (env, apiKey)
+        env = envOrApiKey;
+        apiKey = apiKeyOrRelyingPartyId as string;
+        relyingPartyId = undefined;
+        opts = undefined;
+      } else {
+        // 2-parameter case: (apiKey, relyingPartyId)
+        env = undefined;
+        apiKey = envOrApiKey as string;
+        relyingPartyId = apiKeyOrRelyingPartyId;
+        opts = undefined;
+      }
+    } else if (arguments.length === 3) {
+      if (isEnvironment(envOrApiKey)) {
+        // 3-parameter case: (env, apiKey, relyingPartyId)
+        env = envOrApiKey;
+        apiKey = apiKeyOrRelyingPartyId as string;
+        relyingPartyId = relyingPartyIdOrOpts as string;
+        opts = undefined;
+      } else {
+        // 3-parameter case: (apiKey, relyingPartyId, opts)
+        env = undefined;
+        apiKey = envOrApiKey as string;
+        relyingPartyId = apiKeyOrRelyingPartyId;
+        opts = relyingPartyIdOrOpts as ConstructorOpts;
+      }
+    } else {
+      // 4-parameter case: (env, apiKey, relyingPartyId, opts)
+      env = envOrApiKey as Environment | undefined;
+      apiKey = apiKeyOrRelyingPartyId as string;
+      relyingPartyId = relyingPartyIdOrOpts as string | undefined;
+      opts = optsArg;
+    }
+
+    env = ParaCore.resolveEnvironment(env, apiKey); // Ensure the environment is resolved before calling super
+
     super(env, apiKey, opts);
 
     setEnv(env);
@@ -72,7 +130,7 @@ export class ParaMobile extends ParaCore {
     }
   }
 
-  protected async ready() {
+  async ready() {
     this.isReady = true;
   }
 
@@ -159,7 +217,7 @@ export class ParaMobile extends ParaCore {
       sigDerivedPublicKey: publicKeyHex,
       cosePublicKey,
       clientDataJSON,
-      status: PublicKeyStatus.COMPLETE,
+      status: AuthMethodStatus.COMPLETE,
     });
 
     await this.ctx.client.uploadEncryptedWalletPrivateKey(userId, encryptedPrivateKeyHex, encryptionKeyHash, resultJson.id);

package/src/react-native/ReactNativeUtils.ts

@@ -262,4 +262,8 @@ export class ReactNativeUtils implements PlatformUtils {
     const base64Sig = await ParaSignerModule.ed25519Sign(protocolId, share, base64Bytes);
     return { signature: base64Sig };
   }
+
+  async initializeWorker(_ctx: Ctx): Promise<void> {
+    return;
+  }
 }

package/src/shim.js

@@ -1,6 +1,7 @@
-import crypto from 'react-native-quick-crypto';
+import quickCrypto from 'react-native-quick-crypto';
 import { webcrypto } from 'crypto';
-import { Crypto } from '@peculiar/webcrypto';
+import { Crypto as PeculiarCrypto } from '@peculiar/webcrypto';
+import { ec as EllipticEC } from 'elliptic';
 import Forge from 'node-forge';
 import modPow from 'react-native-modpow';
 import { atob, btoa } from 'react-native-quick-base64';
@@ -8,7 +9,42 @@ import { Buffer } from '@craftzdog/react-native-buffer';
 import process from 'process';
 import 'react-native-url-polyfill/auto';
 import { TextEncoder, TextDecoder } from 'text-encoding';
-import structuredClone from '@ungap/structured-clone';
+
+let cachedStructuredCloneImpl;
+
+const resolveStructuredClone = () => {
+  if (typeof cachedStructuredCloneImpl !== 'undefined') {
+    return cachedStructuredCloneImpl;
+  }
+
+  if (typeof globalThis.structuredClone === 'function') {
+    cachedStructuredCloneImpl = globalThis.structuredClone.bind(globalThis);
+    return cachedStructuredCloneImpl;
+  }
+
+  const isHermes = typeof globalThis.HermesInternal === 'object' && globalThis.HermesInternal !== null;
+  if (isHermes) {
+    // Hermes crashes when @ungap/structured-clone rewires Reflect helpers.
+    cachedStructuredCloneImpl = null;
+    return cachedStructuredCloneImpl;
+  }
+
+  try {
+    const maybePolyfill = require('@ungap/structured-clone');
+    const polyfill = (maybePolyfill && maybePolyfill.default) || maybePolyfill;
+    if (typeof polyfill === 'function') {
+      cachedStructuredCloneImpl = polyfill;
+      return cachedStructuredCloneImpl;
+    }
+  } catch (err) {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.warn('[Para React Native shim] Failed to load structuredClone polyfill', err);
+    }
+  }
+
+  cachedStructuredCloneImpl = null;
+  return cachedStructuredCloneImpl;
+};
 
 const setupProcessPolyfill = () => {
   if (typeof globalThis.process === 'undefined') {
@@ -37,16 +73,218 @@ const setupBase64Polyfills = () => {
   }
 };
 
-const setupCryptoPolyfills = () => {
-  const peculiarCrypto = new Crypto();
-  if (typeof globalThis.crypto === 'undefined') {
-    globalThis.crypto = crypto;
+const curveAliases = {
+  'P-256': 'p256',
+  'p-256': 'p256',
+  'prime256v1': 'p256',
+  'secp256r1': 'p256',
+  'secp256k1': 'secp256k1',
+};
+
+const getBufferImpl = () => {
+  const BufferImpl = globalThis.Buffer;
+  if (!BufferImpl) {
+    // prettier-ignore
+    throw new Error(
+      "[Para React Native shim] Buffer global missing. Please import '@getpara/react-native-wallet/shim' before using cryptography helpers."
+    );
+  }
+  return BufferImpl;
+};
+
+const bufferFrom = (data, encoding = 'binary') => {
+  const BufferImpl = getBufferImpl();
+  if (BufferImpl.isBuffer && BufferImpl.isBuffer(data)) {
+    return data;
+  }
+
+  if (typeof data === 'string') {
+    switch (encoding) {
+      case 'hex':
+        return BufferImpl.from(data, 'hex');
+      case 'base64':
+        return BufferImpl.from(data, 'base64');
+      default:
+        return BufferImpl.from(data, 'binary');
+    }
+  }
+
+  return BufferImpl.from(data);
+};
+
+const bufferTo = (buf, encoding = 'binary') => {
+  const BufferImpl = getBufferImpl();
+  switch (encoding) {
+    case 'hex':
+      return BufferImpl.from(buf).toString('hex');
+    case 'base64':
+      return BufferImpl.from(buf).toString('base64');
+    case 'binary':
+    default:
+      return BufferImpl.from(buf);
+  }
+};
+
+let cachedCreateECDH = null;
+
+const ensureCreateECDH = () => {
+  if (!cachedCreateECDH) {
+    cachedCreateECDH = curveName => {
+      const BufferImpl = getBufferImpl();
+      const normalizedCurve = curveAliases[curveName] || curveName;
+      if (!normalizedCurve && typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.warn('[Para React Native shim] Unknown curve alias', curveName);
+      }
+
+      const ec = new EllipticEC(normalizedCurve);
+      const secretByteLength = (() => {
+        const order = (ec && ec.curve && ec.curve.n) || (ec && ec.n);
+        if (!order) {
+          return null;
+        }
+        if (typeof order.byteLength === 'function') {
+          return order.byteLength();
+        }
+        if (typeof order.bitLength === 'function') {
+          return Math.ceil(order.bitLength() / 8);
+        }
+        return null;
+      })();
+      let keyPair = ec.genKeyPair();
+
+      return {
+        generateKeys: (encoding = 'binary', format = 'uncompressed') => {
+          keyPair = ec.genKeyPair();
+          const compressed = format === 'compressed' || format === 'comp';
+          const publicKey = keyPair.getPublic(compressed, 'array');
+          return bufferTo(BufferImpl.from(publicKey), encoding || 'binary');
+        },
+        computeSecret: (publicKey, inputEncoding = 'binary', outputEncoding = 'binary') => {
+          const publicKeyBuf = bufferFrom(publicKey, inputEncoding || 'binary');
+          const derived = keyPair.derive(ec.keyFromPublic(publicKeyBuf).getPublic());
+          const padded = secretByteLength ? derived.toArray('be', secretByteLength) : derived.toArray('be');
+          // Match Node's ECDH API: shared secret is always curve-size bytes.
+          const secret = BufferImpl.from(padded);
+          return bufferTo(secret, outputEncoding || 'binary');
+        },
+        getPrivateKey: (encoding = 'binary') => {
+          return bufferTo(keyPair.getPrivate().toArrayLike(BufferImpl, 'be', 32), encoding || 'binary');
+        },
+        getPublicKey: (encoding = 'binary', format = 'uncompressed') => {
+          const compressed = format === 'compressed' || format === 'comp';
+          const publicKey = keyPair.getPublic(compressed, 'array');
+          return bufferTo(BufferImpl.from(publicKey), encoding || 'binary');
+        },
+        setPrivateKey: (privateKey, encoding = 'binary') => {
+          keyPair = ec.keyFromPrivate(bufferFrom(privateKey, encoding));
+        },
+        setPublicKey: (publicKey, encoding = 'binary') => {
+          keyPair = ec.keyFromPublic(bufferFrom(publicKey, encoding));
+        },
+      };
+    };
+  }
+
+  const possibleTargets = [];
+  const globalCrypto = globalThis.crypto;
+  if (globalCrypto) {
+    possibleTargets.push(globalCrypto, globalCrypto.default);
+  }
+  possibleTargets.push(quickCrypto, quickCrypto && quickCrypto.default);
+
+  try {
+    const nodeCrypto = require('crypto');
+    possibleTargets.push(nodeCrypto, nodeCrypto && nodeCrypto.default);
+    // eslint-disable-next-line no-unused-vars
+  } catch (_err) {
+    // The Node crypto module is not available in React Native; ignore failures.
+  }
+
+  const patchedTargets = new Set(possibleTargets.filter(Boolean));
+  let patched = false;
+
+  patchedTargets.forEach(target => {
+    if (target && typeof target === 'object' && target.createECDH !== cachedCreateECDH) {
+      try {
+        target.createECDH = cachedCreateECDH;
+        patched = true;
+      } catch (err) {
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+          console.warn('[Para React Native shim] Failed to patch createECDH', err);
+        }
+      }
+    }
+  });
+
+  if (patched && typeof __DEV__ !== 'undefined' && __DEV__) {
+    console.info('[Para React Native shim] createECDH patched function');
+  }
+
+  return cachedCreateECDH;
+};
+
+const syncWindowLikeGlobals = cryptoObj => {
+  const maybeWindow = globalThis.window;
+  if (maybeWindow && typeof maybeWindow === 'object' && maybeWindow.crypto !== cryptoObj) {
+    maybeWindow.crypto = cryptoObj;
+  }
+
+  const maybeSelf = globalThis.self;
+  if (maybeSelf && typeof maybeSelf === 'object' && maybeSelf.crypto !== cryptoObj) {
+    maybeSelf.crypto = cryptoObj;
+  }
+};
+
+const ensureParaCrypto = () => {
+  getBufferImpl();
+  const baseCrypto = (typeof globalThis.crypto === 'object' && globalThis.crypto) || quickCrypto;
+
+  if (!baseCrypto || typeof baseCrypto !== 'object') {
+    throw new Error('[Para React Native shim] No crypto object found to polyfill');
+  }
+
+  if (typeof baseCrypto.default === 'undefined') {
+    baseCrypto.default = baseCrypto;
   }
-  if (!globalThis.crypto.subtle) {
-    globalThis.crypto.subtle = peculiarCrypto.subtle;
-    globalThis.crypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+
+  const peculiarCrypto = new PeculiarCrypto();
+
+  baseCrypto.subtle = peculiarCrypto.subtle;
+  baseCrypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+
+  if (baseCrypto.default && baseCrypto.default !== baseCrypto) {
+    baseCrypto.default.subtle = baseCrypto.subtle;
+    baseCrypto.default.getRandomValues = baseCrypto.getRandomValues;
+  }
+
+  globalThis.crypto = baseCrypto;
+  syncWindowLikeGlobals(baseCrypto);
+  try {
+    const brorand = require('brorand');
+    if (brorand && brorand.Rand) {
+      brorand.Rand.prototype._rand = function _rand(n) {
+        const arr = new Uint8Array(n);
+        baseCrypto.getRandomValues(arr);
+        return arr;
+      };
+    }
+  } catch (err) {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.warn('[Para React Native shim] Failed to patch brorand RNG', err);
+    }
   }
-  webcrypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+  ensureCreateECDH();
+
+  return { baseCrypto, peculiarCrypto };
+};
+
+const setupCryptoPolyfills = () => {
+  const { peculiarCrypto } = ensureParaCrypto();
+
+  if (webcrypto && typeof webcrypto === 'object') {
+    webcrypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+  }
+
   if (typeof Forge === 'undefined') {
     throw new Error('node-forge not loaded');
   }
@@ -68,15 +306,89 @@ const setupTextEncodingPolyfills = () => {
   globalThis.TextDecoder = TextDecoder;
 };
 
+const setupWindowLocationPolyfill = () => {
+  const FALLBACK_HOST = 'para.mobile';
+  const FALLBACK_ORIGIN = `https://${FALLBACK_HOST}`;
+
+  const globalScope = globalThis;
+  if (!globalScope.window || typeof globalScope.window !== 'object') {
+    globalScope.window = globalScope;
+  }
+
+  const win = globalScope.window;
+  const existingLocation = (win && win.location) || globalScope.location;
+  const hasOrigin =
+    existingLocation &&
+    typeof existingLocation === 'object' &&
+    typeof existingLocation.origin === 'string' &&
+    typeof existingLocation.host === 'string';
+
+  if (hasOrigin) {
+    if (!globalScope.location) {
+      globalScope.location = existingLocation;
+    }
+    return;
+  }
+
+  const fallbackLocation = {
+    href: `${FALLBACK_ORIGIN}/`,
+    origin: FALLBACK_ORIGIN,
+    protocol: 'https:',
+    host: FALLBACK_HOST,
+    hostname: FALLBACK_HOST,
+    port: '',
+    pathname: '/',
+  };
+
+  const patchedLocation =
+    typeof existingLocation === 'object' && existingLocation !== null
+      ? Object.assign({}, fallbackLocation, existingLocation)
+      : fallbackLocation;
+
+  win.location = patchedLocation;
+  globalScope.location = patchedLocation;
+};
+
 const setupStructuredClonePolyfill = () => {
-  if (typeof globalThis.structuredClone === 'undefined') {
-    globalThis.structuredClone = structuredClone;
+  if (typeof globalThis.structuredClone === 'function') {
+    return;
   }
+
+  const structuredCloneImpl = resolveStructuredClone();
+  const safeStructuredClone = (value, options) => {
+    if (typeof structuredCloneImpl === 'function') {
+      try {
+        return structuredCloneImpl(value, options);
+      } catch (err) {
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+          console.warn('[Para React Native shim] structuredClone polyfill failed, falling back to JSON clone', err);
+        }
+      }
+    }
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch (_err) {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.warn('[Para React Native shim] JSON clone failed, returning original value', _err);
+      }
+      return value;
+    }
+  };
+
+  Object.defineProperty(globalThis, 'structuredClone', {
+    value: safeStructuredClone,
+    configurable: true,
+    enumerable: false,
+    writable: true,
+  });
 };
 
 setupProcessPolyfill();
 setupBufferPolyfill();
 setupBase64Polyfills();
+setupWindowLocationPolyfill();
 setupCryptoPolyfills();
 setupTextEncodingPolyfills();
 setupStructuredClonePolyfill();
+
+export { ensureParaCrypto, ensureCreateECDH };