@getpara/react-native-wallet 2.18.0 → 2.19.0

package/android/build.gradle

@@ -64,7 +64,7 @@ dependencies {
   // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
-  implementation 'com.github.briancorbin:aar-testing:0.0.4@aar'
+  implementation 'com.github.getpara:react-native-signer:1.0.0@aar'
 }
 
 if (isNewArchitectureEnabled()) {

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export * from '@getpara/web-sdk';
 export { ParaMobile } from './react-native/ParaMobile.js';
-export * from '@getpara/viem-v2-integration/aa';
+export type * from '@getpara/viem-v2-integration/aa';
+export * from './provider/index.js';
+export * from '@getpara/react-core';

package/dist/index.js

@@ -1,4 +1,6 @@
 export * from '@getpara/web-sdk';
 export { ParaMobile } from './react-native/ParaMobile.js';
-// Smart Account types, errors, utilities — re-exported from viem-v2-integration/aa
-export * from '@getpara/viem-v2-integration/aa';
+// React Native provider (wraps ParaProviderCore with AsyncStorage persistence)
+export * from './provider/index.js';
+// Core provider hooks and config types — platform-agnostic, work with any ParaCore subclass
+export * from '@getpara/react-core';

package/dist/provider/ParaProvider.d.ts

@@ -0,0 +1,19 @@
+import { type ParaProviderCoreProps, type ParaClientConfig } from '@getpara/react-core/internal';
+import { ParaMobile } from '../react-native/ParaMobile.js';
+/**
+ * RN provider props. Same as ParaProviderCoreProps but:
+ * - Defaults to ParaMobile
+ * - paraClientConfig accepts a simple { apiKey, env?, opts? } config (no createClient needed)
+ * - storageAdapter defaults to AsyncStorage
+ * - Omits configureClient, waitForReady, store (internal concerns)
+ */
+export type ParaProviderProps = Omit<ParaProviderCoreProps<ParaMobile>, 'paraClientConfig' | 'configureClient' | 'waitForReady' | 'store'> & {
+    /** A pre-instantiated ParaMobile, or a config with apiKey + optional env/opts. */
+    paraClientConfig: ParaMobile | ParaClientConfig;
+};
+/**
+ * React Native Para provider. Wraps ParaProviderCore with AsyncStorage-backed
+ * persistence by default. Accepts either a ParaMobile instance or a simple
+ * `{ apiKey, env?, opts? }` config — the provider creates the client internally.
+ */
+export declare function ParaProvider({ children, paraClientConfig: paraClientInput, config, callbacks, storageAdapter, }: ParaProviderProps): import("react").JSX.Element;

package/dist/provider/ParaProvider.js

@@ -0,0 +1,19 @@
+import { useMemo } from 'react';
+import { ParaProviderCore, } from '@getpara/react-core/internal';
+import { asyncStorageAdapter } from './asyncStorageAdapter.js';
+import { ParaMobile } from '../react-native/ParaMobile.js';
+/**
+ * React Native Para provider. Wraps ParaProviderCore with AsyncStorage-backed
+ * persistence by default. Accepts either a ParaMobile instance or a simple
+ * `{ apiKey, env?, opts? }` config — the provider creates the client internally.
+ */
+export function ParaProvider({ children, paraClientConfig: paraClientInput, config, callbacks, storageAdapter = asyncStorageAdapter, }) {
+    const coreInput = useMemo(() => {
+        if (paraClientInput instanceof ParaMobile)
+            return paraClientInput;
+        return Object.assign(Object.assign({}, paraClientInput), { createClient: (apiKey, env, opts) => new ParaMobile(apiKey, env, opts) });
+    }, [paraClientInput]);
+    return (<ParaProviderCore paraClientConfig={coreInput} config={config} callbacks={callbacks} storageAdapter={storageAdapter}>
+      {children}
+    </ParaProviderCore>);
+}

package/dist/provider/asyncStorageAdapter.d.ts

@@ -0,0 +1,6 @@
+import type { ParaStorageAdapter } from '@getpara/react-core';
+/**
+ * ParaStorageAdapter backed by React Native AsyncStorage.
+ * Used by the core Zustand store for state persistence.
+ */
+export declare const asyncStorageAdapter: ParaStorageAdapter;

package/dist/provider/asyncStorageAdapter.js

@@ -0,0 +1,41 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import RNAsyncStorage from '@react-native-async-storage/async-storage';
+/**
+ * ParaStorageAdapter backed by React Native AsyncStorage.
+ * Used by the core Zustand store for state persistence.
+ */
+export const asyncStorageAdapter = {
+    getItem: (key) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            return yield RNAsyncStorage.getItem(key);
+        }
+        catch (error) {
+            console.warn('[Para] Error reading from AsyncStorage:', error);
+            return null;
+        }
+    }),
+    setItem: (key, value) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield RNAsyncStorage.setItem(key, value);
+        }
+        catch (error) {
+            console.warn(`[Para] Error writing to AsyncStorage (key: ${key}):`, error);
+        }
+    }),
+    removeItem: (key) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield RNAsyncStorage.removeItem(key);
+        }
+        catch (error) {
+            console.warn(`[Para] Error removing from AsyncStorage (key: ${key}):`, error);
+        }
+    }),
+};

package/dist/provider/index.d.ts

@@ -0,0 +1,2 @@
+export { ParaProvider, type ParaProviderProps } from './ParaProvider.js';
+export { asyncStorageAdapter } from './asyncStorageAdapter.js';

package/dist/provider/index.js

@@ -0,0 +1,2 @@
+export { ParaProvider } from './ParaProvider.js';
+export { asyncStorageAdapter } from './asyncStorageAdapter.js';

package/dist/react-native/ParaMobile.js

@@ -13,7 +13,6 @@ import { Passkey, } from 'react-native-passkey';
 import { AuthMethodStatus } from '@getpara/user-management-client';
 import { setEnv } from '../config.js';
 import base64url from 'base64url';
-import { webcrypto } from 'crypto';
 const ES256_ALGORITHM = -7;
 const RS256_ALGORITHM = -257;
 /**
@@ -120,11 +119,11 @@ export class ParaMobile extends ParaCore {
             }
             const userId = this.assertUserId();
             const authInfo = this.assertIsAuthSet();
-            if (!webcrypto || !webcrypto.getRandomValues) {
+            if (!globalThis.crypto || !globalThis.crypto.getRandomValues) {
                 throw new Error('Web crypto is not available. Ensure you have imported the shim from @getpara/react-native-wallet.');
             }
             const userHandle = new Uint8Array(32);
-            webcrypto.getRandomValues(userHandle);
+            globalThis.crypto.getRandomValues(userHandle);
             const userHandleEncoded = base64url.encode(userHandle);
             const requestJson = {
                 authenticatorSelection: {

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

@@ -1,6 +1,4 @@
-import { PlatformUtils, TPregenIdentifierType, EventHandler, EventData } from '@getpara/web-sdk';
-import { Ctx } from '@getpara/web-sdk';
-import { SignatureRes } from '@getpara/web-sdk';
+import type { PlatformUtils, TPregenIdentifierType, EventHandler, EventData, Ctx, SignatureRes } from '@getpara/web-sdk';
 import { BackupKitEmailProps, TWalletType, SDKType } from '@getpara/user-management-client';
 import { AsyncStorage } from '../AsyncStorage.js';
 import { KeychainStorage } from '../KeychainStorage.js';

package/dist/shim.d.ts

@@ -1,130 +1,178 @@
 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;
+    baseCrypto: import("crypto").webcrypto.Crypto | {
+        Certificate: typeof import("react-native-quick-crypto").Certificate;
+        X509Certificate: typeof import("react-native-quick-crypto").X509Certificate;
+        getCurves: typeof import("react-native-quick-crypto").getCurves;
+        constants: {
+            readonly RSA_PKCS1_PADDING: 1;
+            readonly RSA_NO_PADDING: 3;
+            readonly RSA_PKCS1_OAEP_PADDING: 4;
+            readonly RSA_X931_PADDING: 5;
+            readonly RSA_PKCS1_PSS_PADDING: 6;
+            readonly RSA_PSS_SALTLEN_DIGEST: -1;
+            readonly RSA_PSS_SALTLEN_MAX_SIGN: -2;
+            readonly RSA_PSS_SALTLEN_AUTO: -2;
+            readonly POINT_CONVERSION_COMPRESSED: 2;
+            readonly POINT_CONVERSION_UNCOMPRESSED: 4;
+            readonly POINT_CONVERSION_HYBRID: 6;
+            readonly DH_CHECK_P_NOT_PRIME: 1;
+            readonly DH_CHECK_P_NOT_SAFE_PRIME: 2;
+            readonly DH_UNABLE_TO_CHECK_GENERATOR: 4;
+            readonly DH_NOT_SUITABLE_GENERATOR: 8;
+            readonly OPENSSL_VERSION_NUMBER: 805306368;
+        };
+        Buffer: typeof Buffer;
+        isCryptoKeyPair(result: import("react-native-quick-crypto").CryptoKey | import("react-native-quick-crypto").CryptoKeyPair): result is import("react-native-quick-crypto").CryptoKeyPair;
+        Subtle: typeof import("react-native-quick-crypto").Subtle;
+        subtle: import("react-native-quick-crypto").Subtle;
+        toArrayBuffer(buf: Buffer | import("safe-buffer").Buffer | ArrayBufferView): ArrayBuffer;
+        bufferLikeToArrayBuffer(buf: import("react-native-quick-crypto").BufferLike): ArrayBuffer;
+        binaryLikeToArrayBuffer(input: import("react-native-quick-crypto").BinaryLikeNode, encoding?: string): ArrayBuffer;
+        ab2str(buf: ArrayBuffer, encoding?: string): string;
+        bufferToString(buf: ArrayBuffer, encoding?: string): string;
+        stringToBuffer(str: string, encoding?: string): ArrayBuffer;
+        abvToArrayBuffer: (buf: import("react-native-quick-crypto").ABV) => ArrayBuffer;
+        kEmptyObject: any;
+        ensureBytes(title: string, hex: import("react-native-quick-crypto").Hex, expectedLength?: number): Uint8Array;
+        isBytes(a: unknown): a is Uint8Array;
+        hexToBytes(hex: string): Uint8Array;
+        lazyDOMException(message: string, domName: string | {
+            name: string;
+            cause: unknown;
+        }): Error;
+        normalizeHashName(algo: string | import("react-native-quick-crypto").HashAlgorithm | {
+            name: string;
+        } | undefined, context?: import("react-native-quick-crypto").HashContext): string;
+        HashContext: typeof import("react-native-quick-crypto").HashContext;
+        timingSafeEqual(a: import("react-native-quick-crypto").ABV, b: import("react-native-quick-crypto").ABV): boolean;
+        KFormatType: typeof import("react-native-quick-crypto").KFormatType;
+        KeyType: typeof import("react-native-quick-crypto").KeyType;
+        KeyEncoding: typeof import("react-native-quick-crypto").KeyEncoding;
+        KeyFormat: typeof import("react-native-quick-crypto").KeyFormat;
+        kNamedCurveAliases: {
+            readonly "P-256": "prime256v1";
+            readonly "P-384": "secp384r1";
+            readonly "P-521": "secp521r1";
         };
-        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;
+        KeyVariant: typeof import("react-native-quick-crypto").KeyVariant;
+        validateFunction(f: unknown): boolean;
+        isStringOrBuffer(val: unknown): val is string | ArrayBuffer;
+        validateObject<T>(value: unknown, name: string, options?: {
+            allowArray: boolean;
+            allowFunction: boolean;
+            nullable: boolean;
+        } | null): value is T;
+        hasAnyNotIn(set: string[], checks: string[]): boolean;
+        validateMaxBufferLength: (data: import("react-native-quick-crypto").BinaryLike | import("react-native-quick-crypto").BufferLike, name: string) => void;
+        getUsagesUnion: (usageSet: import("react-native-quick-crypto").KeyUsage[], ...usages: import("react-native-quick-crypto").KeyUsage[]) => import("react-native-quick-crypto").KeyUsage[];
+        validateKeyOps: (keyOps: import("react-native-quick-crypto").KeyUsage[] | undefined, usagesSet: import("react-native-quick-crypto").KeyUsage[]) => void;
+        setDefaultEncoding(encoding: import("react-native-quick-crypto").Encoding): void;
+        getDefaultEncoding(): import("react-native-quick-crypto").Encoding;
+        normalizeEncoding(enc: string): "ascii" | "utf8" | "utf16le" | "base64" | "latin1" | "hex" | undefined;
+        validateEncoding(data: string, encoding: string): void;
+        getUIntOption(options: Record<string, any>, key: string): any;
+        encapsulate(key: import("react-native-quick-crypto").CryptoKey | import("react-native-quick-crypto").BinaryLike | import("react-native-quick-crypto").KeyObject | import("react-native-quick-crypto").KeyInputObject, callback?: (err: Error | null, result?: import("react-native-quick-crypto").EncapsulateResult) => void): import("react-native-quick-crypto").EncapsulateResult | void;
+        decapsulate(key: import("react-native-quick-crypto").CryptoKey | import("react-native-quick-crypto").BinaryLike | import("react-native-quick-crypto").KeyObject | import("react-native-quick-crypto").KeyInputObject, ciphertext: import("react-native-quick-crypto").BinaryLike, callback?: (err: Error | null, result?: ArrayBuffer) => void): ArrayBuffer | void;
+        mlkem_generateKeyPairWebCrypto(variant: import("react-native-quick-crypto").MlKemVariant, extractable: boolean, keyUsages: import("react-native-quick-crypto").KeyUsage[]): Promise<import("react-native-quick-crypto").CryptoKeyPair>;
+        MlKem: typeof import("react-native-quick-crypto").MlKem;
+        createDiffieHellman(primeOrSize: number | string | Buffer, primeEncodingOrGenerator?: string | number | Buffer, generator?: number | string | Buffer, _generatorEncoding?: string): import("react-native-quick-crypto").DiffieHellman;
+        getDiffieHellman(groupName: string): import("react-native-quick-crypto").DiffieHellman;
+        DiffieHellman: typeof import("react-native-quick-crypto").DiffieHellman;
+        createDiffieHellmanGroup: typeof import("react-native-quick-crypto").getDiffieHellman;
+        createECDH(curveName: string): import("react-native-quick-crypto").ECDH;
+        ECDH: typeof import("react-native-quick-crypto").ECDH;
+        randomFill<T extends import("react-native-quick-crypto").ABV>(buffer: T, callback: import("react-native-quick-crypto").RandomCallback<T>): void;
+        randomFill<T extends import("react-native-quick-crypto").ABV>(buffer: T, offset: number, callback: import("react-native-quick-crypto").RandomCallback<T>): void;
+        randomFill<T extends import("react-native-quick-crypto").ABV>(buffer: T, offset: number, size: number, callback: import("react-native-quick-crypto").RandomCallback<T>): void;
+        randomFillSync<T extends import("react-native-quick-crypto").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;
+        getRandomValues(data: import("react-native-quick-crypto").RandomTypedArrays): import("react-native-quick-crypto").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): Buffer;
-        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;
+        rng: typeof import("react-native-quick-crypto").randomBytes;
+        pseudoRandomBytes: typeof import("react-native-quick-crypto").randomBytes;
+        prng: typeof import("react-native-quick-crypto").randomBytes;
+        scrypt(password: import("react-native-quick-crypto").BinaryLike, salt: import("react-native-quick-crypto").BinaryLike, keylen: number, options?: import("react-native-quick-crypto").ScryptOptions | ((err: Error | null, derivedKey?: Buffer) => void), callback?: (err: Error | null, derivedKey?: Buffer) => void): void;
+        scryptSync(password: import("react-native-quick-crypto").BinaryLike, salt: import("react-native-quick-crypto").BinaryLike, keylen: number, options?: import("react-native-quick-crypto").ScryptOptions): Buffer;
+        generatePrimeSync(size: number, options?: import("react-native-quick-crypto").GeneratePrimeOptions): Buffer | bigint;
+        generatePrime(size: number, options: import("react-native-quick-crypto").GeneratePrimeOptions | ((err: Error | null, prime: Buffer | bigint) => void), callback?: (err: Error | null, prime: Buffer | bigint) => void): void;
+        checkPrimeSync(candidate: import("react-native-quick-crypto").BinaryLike | bigint, options?: import("react-native-quick-crypto").CheckPrimeOptions): boolean;
+        checkPrime(candidate: import("react-native-quick-crypto").BinaryLike | bigint, options: import("react-native-quick-crypto").CheckPrimeOptions | ((err: Error | null, result: boolean) => void), callback?: (err: Error | null, result: boolean) => void): void;
+        pbkdf2(password: import("react-native-quick-crypto").BinaryLike, salt: import("react-native-quick-crypto").BinaryLike, iterations: number, keylen: number, digest: string, callback: (err: Error | null, derivedKey?: Buffer) => void): void;
+        pbkdf2Sync(password: import("react-native-quick-crypto").BinaryLike, salt: import("react-native-quick-crypto").BinaryLike, iterations: number, keylen: number, digest: string): Buffer;
+        pbkdf2DeriveBits(algorithm: import("react-native-quick-crypto").SubtleAlgorithm, baseKey: import("react-native-quick-crypto").CryptoKey, length: number): Promise<ArrayBuffer>;
+        hkdf(digest: string, key: import("react-native-quick-crypto").BinaryLike, salt: import("react-native-quick-crypto").BinaryLike, info: import("react-native-quick-crypto").BinaryLike, keylen: number, callback: import("react-native-quick-crypto").HkdfCallback): void;
+        hkdfSync(digest: string, key: import("react-native-quick-crypto").BinaryLike, salt: import("react-native-quick-crypto").BinaryLike, info: import("react-native-quick-crypto").BinaryLike, keylen: number): Buffer;
+        hkdfDeriveBits(algorithm: import("react-native-quick-crypto").HkdfAlgorithm, baseKey: import("react-native-quick-crypto").CryptoKey, length: number): ArrayBuffer;
+        createHmac: typeof import("react-native-quick-crypto").createHmac;
+        createHash: typeof import("react-native-quick-crypto").createHash;
+        getHashes: typeof import("react-native-quick-crypto").getHashes;
+        hash: typeof import("react-native-quick-crypto").hash;
+        asyncDigest: (algorithm: import("react-native-quick-crypto").SubtleAlgorithm, data: import("react-native-quick-crypto").BufferLike) => Promise<ArrayBuffer>;
+        diffieHellman(options: import("react-native-quick-crypto").DiffieHellmanOptions, callback?: import("react-native-quick-crypto").DiffieHellmanCallback): Buffer | void;
+        ed_generateKeyPair(isAsync: boolean, type: import("react-native-quick-crypto").CFRGKeyPairType, encoding: import("react-native-quick-crypto").KeyPairGenConfig, callback: import("react-native-quick-crypto").GenerateKeyPairCallback | undefined): import("react-native-quick-crypto").GenerateKeyPairReturn | void;
+        ed_generateKeyPairWebCrypto(type: "ed25519" | "ed448", extractable: boolean, keyUsages: import("react-native-quick-crypto").KeyUsage[]): Promise<import("react-native-quick-crypto").CryptoKeyPair>;
+        x_generateKeyPairWebCrypto(type: "x25519" | "x448", extractable: boolean, keyUsages: import("react-native-quick-crypto").KeyUsage[]): Promise<import("react-native-quick-crypto").CryptoKeyPair>;
+        xDeriveBits(algorithm: import("react-native-quick-crypto").SubtleAlgorithm, baseKey: import("react-native-quick-crypto").CryptoKey, length: number | null): ArrayBuffer;
+        Ed: typeof import("react-native-quick-crypto").Ed;
+        getCiphers(): string[];
+        getCipherInfo(name: string, options?: {
+            keyLength?: number;
+            ivLength?: number;
+        }): import("react-native-quick-crypto").CipherInfoResult | undefined;
+        createDecipheriv(algorithm: import("crypto").CipherCCMTypes, key: import("react-native-quick-crypto").BinaryLikeNode, iv: import("react-native-quick-crypto").BinaryLike, options: import("crypto").CipherCCMOptions): import("react-native-quick-crypto").Decipher;
+        createDecipheriv(algorithm: import("crypto").CipherOCBTypes, key: import("react-native-quick-crypto").BinaryLikeNode, iv: import("react-native-quick-crypto").BinaryLike, options: import("crypto").CipherOCBOptions): import("react-native-quick-crypto").Decipher;
+        createDecipheriv(algorithm: import("crypto").CipherGCMTypes, key: import("react-native-quick-crypto").BinaryLikeNode, iv: import("react-native-quick-crypto").BinaryLike, options?: import("crypto").CipherGCMOptions): import("react-native-quick-crypto").Decipher;
+        createDecipheriv(algorithm: string, key: import("react-native-quick-crypto").BinaryLikeNode, iv: import("react-native-quick-crypto").BinaryLike, options?: import("readable-stream").TransformOptions): import("react-native-quick-crypto").Decipher;
+        createCipheriv(algorithm: import("crypto").CipherCCMTypes, key: import("react-native-quick-crypto").BinaryLikeNode, iv: import("react-native-quick-crypto").BinaryLike, options: import("crypto").CipherCCMOptions): import("react-native-quick-crypto").Cipher;
+        createCipheriv(algorithm: import("crypto").CipherOCBTypes, key: import("react-native-quick-crypto").BinaryLikeNode, iv: import("react-native-quick-crypto").BinaryLike, options: import("crypto").CipherOCBOptions): import("react-native-quick-crypto").Cipher;
+        createCipheriv(algorithm: import("crypto").CipherGCMTypes, key: import("react-native-quick-crypto").BinaryLikeNode, iv: import("react-native-quick-crypto").BinaryLike, options?: import("crypto").CipherGCMOptions): import("react-native-quick-crypto").Cipher;
+        createCipheriv(algorithm: string, key: import("react-native-quick-crypto").BinaryLikeNode, iv: import("react-native-quick-crypto").BinaryLike, options?: import("readable-stream").TransformOptions): import("react-native-quick-crypto").Cipher;
+        xsalsa20(key: Uint8Array, nonce: Uint8Array, data: Uint8Array, output?: Uint8Array | undefined, counter?: number): Uint8Array;
+        createBlake3(opts?: import("react-native-quick-crypto").Blake3Options): import("react-native-quick-crypto").Blake3;
+        blake3: typeof import("react-native-quick-crypto").blake3;
+        Blake3: typeof import("react-native-quick-crypto").Blake3;
+        blake3Exports: {
+            Blake3: typeof import("react-native-quick-crypto").Blake3;
+            createBlake3: typeof import("react-native-quick-crypto").createBlake3;
+            blake3: typeof import("react-native-quick-crypto").blake3;
         };
+        createSecretKey: typeof import("react-native-quick-crypto").createSecretKey;
+        createPublicKey: typeof import("react-native-quick-crypto").createPublicKey;
+        createPrivateKey: typeof import("react-native-quick-crypto").createPrivateKey;
+        CryptoKey: typeof import("react-native-quick-crypto").CryptoKey;
+        generateKey: typeof import("react-native-quick-crypto").generateKey;
+        generateKeySync: typeof import("react-native-quick-crypto").generateKeySync;
+        generateKeyPair: (type: import("react-native-quick-crypto").KeyPairType, options: import("react-native-quick-crypto").GenerateKeyPairOptions, callback: import("react-native-quick-crypto").GenerateKeyPairCallback) => void;
+        generateKeyPairSync: typeof import("react-native-quick-crypto").generateKeyPairSync;
+        AsymmetricKeyObject: typeof import("react-native-quick-crypto").AsymmetricKeyObject;
+        KeyObject: typeof import("react-native-quick-crypto").KeyObject;
+        createSign: typeof import("react-native-quick-crypto").createSign;
+        createVerify: typeof import("react-native-quick-crypto").createVerify;
+        sign: typeof import("react-native-quick-crypto").sign;
+        verify: typeof import("react-native-quick-crypto").verify;
+        Sign: typeof import("react-native-quick-crypto").Sign;
+        Verify: typeof import("react-native-quick-crypto").Verify;
+        publicEncrypt: typeof import("react-native-quick-crypto").publicEncrypt;
+        publicDecrypt: typeof import("react-native-quick-crypto").publicDecrypt;
+        privateEncrypt: typeof import("react-native-quick-crypto").privateEncrypt;
+        privateDecrypt: typeof import("react-native-quick-crypto").privateDecrypt;
+        parsePublicKeyEncoding: typeof import("react-native-quick-crypto").parsePublicKeyEncoding;
+        parsePrivateKeyEncoding: typeof import("react-native-quick-crypto").parsePrivateKeyEncoding;
+        parseKeyEncoding: typeof import("react-native-quick-crypto").parseKeyEncoding;
+        SecretKeyObject: typeof import("react-native-quick-crypto").SecretKeyObject;
+        PublicKeyObject: typeof import("react-native-quick-crypto").PublicKeyObject;
+        PrivateKeyObject: typeof import("react-native-quick-crypto").PrivateKeyObject;
+        isCryptoKey: (obj: any) => boolean;
+        argon2Sync(algorithm: string, params: import("react-native-quick-crypto").Argon2Params): Buffer;
+        argon2(algorithm: string, params: import("react-native-quick-crypto").Argon2Params, callback: (err: Error | null, result: Buffer) => void): void;
     };
     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,5 +1,4 @@
 import quickCrypto from 'react-native-quick-crypto';
-import { webcrypto } from 'crypto';
 import { Crypto as PeculiarCrypto } from '@peculiar/webcrypto';
 import { ec as EllipticEC } from 'elliptic';
 import Forge from 'node-forge';
@@ -246,8 +245,26 @@ const ensureParaCrypto = () => {
 };
 const setupCryptoPolyfills = () => {
     const { peculiarCrypto } = ensureParaCrypto();
-    if (webcrypto && typeof webcrypto === 'object') {
-        webcrypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+    // Ensure `import { webcrypto } from 'crypto'` works regardless of quick-crypto version.
+    // quick-crypto 1.x (Nitro) removed the webcrypto export that 0.7.x had.
+    try {
+        const cryptoModule = require('crypto');
+        if (!cryptoModule.webcrypto || typeof cryptoModule.webcrypto !== 'object') {
+            Object.defineProperty(cryptoModule, 'webcrypto', {
+                get() {
+                    return globalThis.crypto;
+                },
+                configurable: true,
+                enumerable: true,
+            });
+        }
+        if (cryptoModule.webcrypto && typeof cryptoModule.webcrypto === 'object') {
+            cryptoModule.webcrypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+        }
+        // eslint-disable-next-line no-unused-vars
+    }
+    catch (_err) {
+        // crypto module not available
     }
     if (typeof Forge === 'undefined') {
         throw new Error('node-forge not loaded');

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@getpara/react-native-wallet",
   "description": "Para Wallet for React Native",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "author": "Para Team <hello@getpara.com> (https://getpara.com)",
   "dependencies": {
-    "@getpara/core-sdk": "2.18.0",
-    "@getpara/user-management-client": "2.18.0",
-    "@getpara/viem-v2-integration": "2.18.0",
-    "@getpara/web-sdk": "2.18.0",
+    "@getpara/core-sdk": "2.19.0",
+    "@getpara/react-core": "2.19.0",
+    "@getpara/user-management-client": "2.19.0",
+    "@getpara/viem-v2-integration": "2.19.0",
+    "@getpara/web-sdk": "2.19.0",
     "@peculiar/webcrypto": "^1.5.0",
     "@ungap/structured-clone": "1.3.0",
     "react-native-url-polyfill": "2.0.0",
+    "readable-stream": "^4.5.2",
     "text-encoding": "0.7.0"
   },
   "devDependencies": {
@@ -22,9 +24,10 @@
     "@types/text-encoding": "0.0.39",
     "react-native-keychain": "^10.0.0",
     "react-native-modpow": "^1.1.0",
+    "react-native-nitro-modules": "^0.29.1",
     "react-native-passkey": "^3.1.0",
     "react-native-quick-base64": "^2.2.0",
-    "react-native-quick-crypto": "^0.7.14",
+    "react-native-quick-crypto": "^1.0.0",
     "typescript": "^5.8.3"
   },
   "exports": {
@@ -45,8 +48,7 @@
     "android",
     "cpp",
     "*.podspec",
-    "signer.xcframework",
-    "signer.aar"
+    "signer.xcframework"
   ],
   "homepage": "https://getpara.com",
   "main": "./dist/index.js",
@@ -54,14 +56,15 @@
   "peerDependencies": {
     "@craftzdog/react-native-buffer": ">=6.0.0",
     "@react-native-async-storage/async-storage": ">=2.0.0",
+    "@tanstack/react-query": ">=5",
     "react": ">=18",
     "react-native": ">=0.70.0",
     "react-native-keychain": ">=8.0.0",
     "react-native-modpow": ">=1.0.0",
+    "react-native-nitro-modules": ">=0.29.1",
     "react-native-passkey": ">=3.0.0",
     "react-native-quick-base64": ">=2.0.0",
-    "react-native-quick-crypto": ">=0.7.0",
-    "readable-stream": ">=4.0.0"
+    "react-native-quick-crypto": ">=1.0.0"
   },
   "publishConfig": {
     "access": "public"
@@ -93,5 +96,5 @@
       ]
     }
   },
-  "gitHead": "4481f6f4e108e682d14c74d4433696141c47fc58"
+  "gitHead": "7dc9400777adb653c0cc28e0d9236424eb384467"
 }

package/src/index.ts

@@ -1,5 +1,11 @@
 export * from '@getpara/web-sdk';
 export { ParaMobile } from './react-native/ParaMobile.js';
 
-// Smart Account types, errors, utilities — re-exported from viem-v2-integration/aa
-export * from '@getpara/viem-v2-integration/aa';
+// Smart Account types — type-only re-export so Metro doesn't bundle viem for non-AA users
+export type * from '@getpara/viem-v2-integration/aa';
+
+// React Native provider (wraps ParaProviderCore with AsyncStorage persistence)
+export * from './provider/index.js';
+
+// Core provider hooks and config types — platform-agnostic, work with any ParaCore subclass
+export * from '@getpara/react-core';

package/src/provider/ParaProvider.tsx

@@ -0,0 +1,51 @@
+import { useMemo } from 'react';
+import {
+  ParaProviderCore,
+  type ParaProviderCoreProps,
+  type ParaClientConfig,
+  type ParaClientConfigWithFactory,
+} from '@getpara/react-core/internal';
+import { asyncStorageAdapter } from './asyncStorageAdapter.js';
+import { ParaMobile } from '../react-native/ParaMobile.js';
+
+/**
+ * RN provider props. Same as ParaProviderCoreProps but:
+ * - Defaults to ParaMobile
+ * - paraClientConfig accepts a simple { apiKey, env?, opts? } config (no createClient needed)
+ * - storageAdapter defaults to AsyncStorage
+ * - Omits configureClient, waitForReady, store (internal concerns)
+ */
+export type ParaProviderProps = Omit<
+  ParaProviderCoreProps<ParaMobile>,
+  'paraClientConfig' | 'configureClient' | 'waitForReady' | 'store'
+> & {
+  /** A pre-instantiated ParaMobile, or a config with apiKey + optional env/opts. */
+  paraClientConfig: ParaMobile | ParaClientConfig;
+};
+
+/**
+ * React Native Para provider. Wraps ParaProviderCore with AsyncStorage-backed
+ * persistence by default. Accepts either a ParaMobile instance or a simple
+ * `{ apiKey, env?, opts? }` config — the provider creates the client internally.
+ */
+export function ParaProvider({
+  children,
+  paraClientConfig: paraClientInput,
+  config,
+  callbacks,
+  storageAdapter = asyncStorageAdapter,
+}: ParaProviderProps) {
+  const coreInput = useMemo<ParaMobile | ParaClientConfigWithFactory<ParaMobile>>(() => {
+    if (paraClientInput instanceof ParaMobile) return paraClientInput;
+    return {
+      ...paraClientInput,
+      createClient: (apiKey, env, opts) => new ParaMobile(apiKey, env, opts),
+    };
+  }, [paraClientInput]);
+
+  return (
+    <ParaProviderCore paraClientConfig={coreInput} config={config} callbacks={callbacks} storageAdapter={storageAdapter}>
+      {children}
+    </ParaProviderCore>
+  );
+}

package/src/provider/asyncStorageAdapter.ts

@@ -0,0 +1,31 @@
+import type { ParaStorageAdapter } from '@getpara/react-core';
+import RNAsyncStorage from '@react-native-async-storage/async-storage';
+
+/**
+ * ParaStorageAdapter backed by React Native AsyncStorage.
+ * Used by the core Zustand store for state persistence.
+ */
+export const asyncStorageAdapter: ParaStorageAdapter = {
+  getItem: async (key: string) => {
+    try {
+      return await RNAsyncStorage.getItem(key);
+    } catch (error) {
+      console.warn('[Para] Error reading from AsyncStorage:', error);
+      return null;
+    }
+  },
+  setItem: async (key: string, value: string) => {
+    try {
+      await RNAsyncStorage.setItem(key, value);
+    } catch (error) {
+      console.warn(`[Para] Error writing to AsyncStorage (key: ${key}):`, error);
+    }
+  },
+  removeItem: async (key: string) => {
+    try {
+      await RNAsyncStorage.removeItem(key);
+    } catch (error) {
+      console.warn(`[Para] Error removing from AsyncStorage (key: ${key}):`, error);
+    }
+  },
+};

package/src/provider/index.ts

@@ -0,0 +1,2 @@
+export { ParaProvider, type ParaProviderProps } from './ParaProvider.js';
+export { asyncStorageAdapter } from './asyncStorageAdapter.js';

package/src/react-native/ParaMobile.ts

@@ -26,7 +26,6 @@ import {
 import { CurrentWalletIds, AuthMethodStatus, TWalletScheme } from '@getpara/user-management-client';
 import { setEnv } from '../config.js';
 import base64url from 'base64url';
-import { webcrypto } from 'crypto';
 
 const ES256_ALGORITHM = -7;
 const RS256_ALGORITHM = -257;
@@ -159,11 +158,11 @@ export class ParaMobile extends ParaCore {
     const userId = this.assertUserId();
     const authInfo = this.assertIsAuthSet();
 
-    if (!webcrypto || !webcrypto.getRandomValues) {
+    if (!globalThis.crypto || !globalThis.crypto.getRandomValues) {
       throw new Error('Web crypto is not available. Ensure you have imported the shim from @getpara/react-native-wallet.');
     }
     const userHandle = new Uint8Array(32);
-    webcrypto.getRandomValues(userHandle);
+    globalThis.crypto.getRandomValues(userHandle);
     const userHandleEncoded = base64url.encode(userHandle as any);
 
     const requestJson: PasskeyCreateRequest = {

package/src/react-native/ReactNativeUtils.ts

@@ -1,6 +1,4 @@
-import { PlatformUtils, TPregenIdentifierType, EventHandler, EventData } from '@getpara/web-sdk';
-import { Ctx } from '@getpara/web-sdk';
-import { SignatureRes } from '@getpara/web-sdk';
+import type { PlatformUtils, TPregenIdentifierType, EventHandler, EventData, Ctx, SignatureRes } from '@getpara/web-sdk';
 import { BackupKitEmailProps, KeyShareType, TWalletType, SDKType } from '@getpara/user-management-client';
 import { NativeModules } from 'react-native';
 

package/src/shim.js

@@ -1,5 +1,4 @@
 import quickCrypto from 'react-native-quick-crypto';
-import { webcrypto } from 'crypto';
 import { Crypto as PeculiarCrypto } from '@peculiar/webcrypto';
 import { ec as EllipticEC } from 'elliptic';
 import Forge from 'node-forge';
@@ -281,8 +280,25 @@ const ensureParaCrypto = () => {
 const setupCryptoPolyfills = () => {
   const { peculiarCrypto } = ensureParaCrypto();
 
-  if (webcrypto && typeof webcrypto === 'object') {
-    webcrypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+  // Ensure `import { webcrypto } from 'crypto'` works regardless of quick-crypto version.
+  // quick-crypto 1.x (Nitro) removed the webcrypto export that 0.7.x had.
+  try {
+    const cryptoModule = require('crypto');
+    if (!cryptoModule.webcrypto || typeof cryptoModule.webcrypto !== 'object') {
+      Object.defineProperty(cryptoModule, 'webcrypto', {
+        get() {
+          return globalThis.crypto;
+        },
+        configurable: true,
+        enumerable: true,
+      });
+    }
+    if (cryptoModule.webcrypto && typeof cryptoModule.webcrypto === 'object') {
+      cryptoModule.webcrypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+    }
+    // eslint-disable-next-line no-unused-vars
+  } catch (_err) {
+    // crypto module not available
   }
 
   if (typeof Forge === 'undefined') {