@getpara/react-native-wallet 1.0.2-dev.6 → 1.0.2-dev.7

package/dist/cjs/AsyncStorage.js

@@ -0,0 +1,47 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncStorage = void 0;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+/**
+ * Implements `StorageUtils` using React Native Async Storage.
+ */
+class AsyncStorage {
+    clear(prefix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keys = yield async_storage_1.default.getAllKeys();
+            for (const key of keys) {
+                if (key.startsWith(prefix)) {
+                    yield async_storage_1.default.removeItem(key);
+                }
+            }
+        });
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return async_storage_1.default.getItem(key);
+        });
+    }
+    removeItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield async_storage_1.default.removeItem(key);
+        });
+    }
+    set(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield async_storage_1.default.setItem(key, value);
+        });
+    }
+}
+exports.AsyncStorage = AsyncStorage;

package/dist/cjs/KeychainStorage.js

@@ -0,0 +1,78 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeychainStorage = void 0;
+const react_native_keychain_1 = __importDefault(require("react-native-keychain"));
+const USERNAME = '@CAPSULE';
+const KEYCHAIN_USER_CANCELLED_ERRORS = [
+    'user canceled the operation',
+    'error: code: 13, msg: cancel',
+    'error: code: 10, msg: fingerprint operation canceled by the user',
+];
+function isUserCancelledError(error) {
+    return KEYCHAIN_USER_CANCELLED_ERRORS.some(userCancelledError => error.toString().toLowerCase().includes(userCancelledError));
+}
+/**
+ * Implements `StorageUtils` using React Native `Keychain`.
+ */
+class KeychainStorage {
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const item = yield react_native_keychain_1.default.getGenericPassword({
+                    service: key,
+                });
+                if (!item) {
+                    return null;
+                }
+                return item.password;
+            }
+            catch (error) {
+                if (error instanceof Error && !isUserCancelledError(error)) {
+                    // triggered when biometry verification fails and user cancels the action
+                    throw new Error('Error retrieving stored item ' + error.message);
+                }
+                throw error;
+            }
+        });
+    }
+    set(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield react_native_keychain_1.default.setGenericPassword(USERNAME, value, {
+                service: key,
+                accessible: react_native_keychain_1.default.ACCESSIBLE.AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY,
+                securityLevel: react_native_keychain_1.default.SECURITY_LEVEL.ANY,
+            });
+            if (!result) {
+                throw new Error('Failed to store key ' + key);
+            }
+        });
+    }
+    removeItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield react_native_keychain_1.default.resetGenericPassword({ service: key });
+        });
+    }
+    clear(prefix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const services = yield react_native_keychain_1.default.getAllGenericPasswordServices();
+            for (const key of services) {
+                if (key && key.startsWith(prefix)) {
+                    yield react_native_keychain_1.default.resetGenericPassword({ service: key });
+                }
+            }
+        });
+    }
+}
+exports.KeychainStorage = KeychainStorage;

package/dist/cjs/config.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEBUG_MODE_ENABLED = exports.mpcNetworkWSServer = exports.portalBase = exports.userManagementServer = void 0;
+exports.getBaseMPCNetworkWSUrl = getBaseMPCNetworkWSUrl;
+exports.setEnv = setEnv;
+const react_native_1 = require("react-native");
+const web_sdk_1 = require("@getpara/web-sdk");
+function getPortalBaseURL(env) {
+    switch (env) {
+        case web_sdk_1.Environment.DEV:
+            return 'http://localhost:3003';
+        case web_sdk_1.Environment.SANDBOX:
+            return 'https://app.sandbox.usecapsule.com';
+        case web_sdk_1.Environment.BETA:
+            return 'https://app.beta.usecapsule.com';
+        case web_sdk_1.Environment.PROD:
+            return 'https://app.usecapsule.com';
+        default:
+            throw new Error(`env: ${env} not supported`);
+    }
+}
+function getBaseUrl(env) {
+    switch (env) {
+        case web_sdk_1.Environment.DEV:
+            return 'http://localhost:8080/';
+        case web_sdk_1.Environment.SANDBOX:
+            return 'https://api.sandbox.getpara.com/';
+        case web_sdk_1.Environment.BETA:
+            return 'https://api.beta.getpara.com/';
+        case web_sdk_1.Environment.PROD:
+            return 'https://api.getpara.com/';
+        default:
+            throw new Error(`unsupported env: ${env}`);
+    }
+}
+function getBaseMPCNetworkWSUrl(env) {
+    switch (env) {
+        case web_sdk_1.Environment.DEV:
+            return `ws://localhost:3000`;
+        case web_sdk_1.Environment.SANDBOX:
+            return `wss://mpc-network.sandbox.getpara.com`;
+        case web_sdk_1.Environment.BETA:
+            return `wss://mpc-network.beta.getpara.com`;
+        case web_sdk_1.Environment.PROD:
+            return `wss://mpc-network.getpara.com`;
+        default:
+            throw new Error(`unsupported env: ${env}`);
+    }
+}
+exports.userManagementServer = getBaseUrl(web_sdk_1.Environment.BETA);
+exports.portalBase = getPortalBaseURL(web_sdk_1.Environment.BETA);
+exports.mpcNetworkWSServer = getBaseMPCNetworkWSUrl(web_sdk_1.Environment.BETA);
+function setEnv(env) {
+    exports.userManagementServer = getBaseUrl(env);
+    exports.portalBase = getPortalBaseURL(env);
+    exports.mpcNetworkWSServer = getBaseMPCNetworkWSUrl(env);
+    init();
+}
+const { ParaSignerModule } = react_native_1.NativeModules;
+exports.DEBUG_MODE_ENABLED = false;
+function init() {
+    ParaSignerModule.setServerUrl(exports.userManagementServer);
+    ParaSignerModule.setWsServerUrl(exports.mpcNetworkWSServer);
+}
+init();

package/dist/cjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParaMobile = void 0;
+__exportStar(require("@getpara/web-sdk"), exports);
+var ParaMobile_js_1 = require("./react-native/ParaMobile.js");
+Object.defineProperty(exports, "ParaMobile", { enumerable: true, get: function () { return ParaMobile_js_1.ParaMobile; } });

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/react-native/ParaMobile.js

@@ -0,0 +1,258 @@
+"use strict";
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParaMobile = void 0;
+const web_sdk_1 = require("@getpara/web-sdk");
+const ReactNativeUtils_js_1 = require("./ReactNativeUtils.js");
+const react_native_passkey_1 = require("react-native-passkey");
+const user_management_client_1 = require("@getpara/user-management-client");
+const config_js_1 = require("../config.js");
+const base64url_1 = __importDefault(require("base64url"));
+const crypto_1 = require("crypto");
+const ES256_ALGORITHM = -7;
+const RS256_ALGORITHM = -257;
+/**
+ * Represents a mobile implementation of the Para SDK.
+ * @extends ParaCore
+ *
+ * @example
+ * const para = new ParaMobile(Environment.BETA, "api_key");
+ */
+class ParaMobile extends web_sdk_1.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) {
+        super(env, apiKey, opts);
+        (0, config_js_1.setEnv)(env);
+        if (relyingPartyId) {
+            this.relyingPartyId = relyingPartyId;
+        }
+        else {
+            switch (env) {
+                case web_sdk_1.Environment.DEV:
+                    throw new Error('relyingPartyId is required');
+                case web_sdk_1.Environment.SANDBOX:
+                    this.relyingPartyId = 'app.sandbox.usecapsule.com';
+                    break;
+                case web_sdk_1.Environment.BETA:
+                    this.relyingPartyId = 'app.beta.usecapsule.com';
+                    break;
+                case web_sdk_1.Environment.PROD:
+                    this.relyingPartyId = 'app.usecapsule.com';
+                    break;
+            }
+        }
+    }
+    getPlatformUtils() {
+        return new ReactNativeUtils_js_1.ReactNativeUtils();
+    }
+    /**
+     * Verifies an email and returns the biometrics ID.
+     * @param {string} verificationCode - The verification code sent to the email.
+     * @returns {Promise<string>} The biometrics ID.
+     */
+    verifyEmailBiometricsId(_a) {
+        const _super = Object.create(null, {
+            verifyEmail: { get: () => super.verifyEmail }
+        });
+        return __awaiter(this, arguments, void 0, function* ({ verificationCode }) {
+            const webAuthCreateUrl = yield _super.verifyEmail.call(this, { verificationCode });
+            const segments = webAuthCreateUrl.split('/');
+            const segments2 = segments[segments.length - 1].split('?');
+            const biometricsId = segments2[0];
+            return biometricsId;
+        });
+    }
+    /**
+     * Verifies a phone number and returns the biometrics ID.
+     * @param {string} verificationCode - The verification code sent to the phone.
+     * @returns {Promise<string>} The biometrics ID.
+     */
+    verifyPhoneBiometricsId(_a) {
+        const _super = Object.create(null, {
+            verifyPhone: { get: () => super.verifyPhone }
+        });
+        return __awaiter(this, arguments, void 0, function* ({ verificationCode }) {
+            const webAuthCreateUrl = yield _super.verifyPhone.call(this, { verificationCode });
+            const segments = webAuthCreateUrl.split('/');
+            const segments2 = segments[segments.length - 1].split('?');
+            const biometricsId = segments2[0];
+            return biometricsId;
+        });
+    }
+    /**
+     * Registers a passkey for the user.
+     * @param {Auth<'email'> | Auth<'phone'>} auth - The user's authentication details
+     * @param {string} biometricsId - The biometrics ID obtained from verification.
+     * @returns {Promise<void>}
+     */
+    registerPasskey(_a) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var { biometricsId } = _a, auth = __rest(_a, ["biometricsId"]);
+            if (!crypto_1.webcrypto || !crypto_1.webcrypto.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);
+            crypto_1.webcrypto.getRandomValues(userHandle);
+            const userHandleEncoded = base64url_1.default.encode(userHandle);
+            const { identifier: displayIdentifier } = (0, user_management_client_1.extractAuthInfo)(auth, { isRequired: true });
+            const requestJson = {
+                authenticatorSelection: {
+                    authenticatorAttachment: 'platform',
+                    requireResidentKey: true,
+                    residentKey: 'required',
+                    userVerification: 'required',
+                },
+                rp: {
+                    id: this.relyingPartyId,
+                    name: 'Para',
+                },
+                user: {
+                    id: userHandleEncoded,
+                    name: displayIdentifier,
+                    displayName: displayIdentifier,
+                },
+                pubKeyCredParams: [
+                    {
+                        type: 'public-key',
+                        alg: ES256_ALGORITHM,
+                    },
+                    {
+                        type: 'public-key',
+                        alg: RS256_ALGORITHM,
+                    },
+                ],
+                attestation: 'direct',
+                timeout: 60000,
+                challenge: base64url_1.default.encode('somechallenge'),
+            };
+            const result = yield react_native_passkey_1.Passkey.create(requestJson);
+            let resultJson;
+            if (typeof result === 'string') {
+                resultJson = JSON.parse(result);
+            }
+            else {
+                resultJson = result;
+            }
+            const { cosePublicKey, clientDataJSON } = (0, web_sdk_1.parseCredentialCreationRes)(resultJson, ES256_ALGORITHM);
+            const keyPair = yield (0, web_sdk_1.getAsymmetricKeyPair)(this.ctx);
+            const publicKeyHex = (0, web_sdk_1.getPublicKeyHex)(keyPair);
+            const encryptionKeyHash = (0, web_sdk_1.getSHA256HashHex)(userHandleEncoded);
+            const encryptedPrivateKeyHex = yield (0, web_sdk_1.encryptPrivateKey)(keyPair, userHandleEncoded);
+            const session = yield this.ctx.client.touchSession();
+            yield this.ctx.client.patchSessionPublicKey(session.data.partnerId, this.getUserId(), biometricsId, {
+                publicKey: resultJson.id,
+                sigDerivedPublicKey: publicKeyHex,
+                cosePublicKey,
+                clientDataJSON,
+                status: user_management_client_1.PublicKeyStatus.COMPLETE,
+            });
+            yield this.ctx.client.uploadEncryptedWalletPrivateKey(this.getUserId(), encryptedPrivateKeyHex, encryptionKeyHash, resultJson.id);
+        });
+    }
+    /**
+     * Logs in the user using their authentication credentials.
+     * @param {AuthParams} params - The authentication parameters.
+     * @returns {Promise<void>}
+     */
+    login(_a) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var auth = __rest(_a, []);
+            yield this.logout();
+            const authInfo = (0, user_management_client_1.extractAuthInfo)(auth, { isRequired: true });
+            const { challenge, allowedPublicKeys } = yield this.ctx.client.getWebChallenge(authInfo.auth);
+            const requestJson = {
+                challenge,
+                timeout: 60000,
+                rpId: this.relyingPartyId,
+                allowCredentials: (allowedPublicKeys === null || allowedPublicKeys === void 0 ? void 0 : allowedPublicKeys[0]) ? [{ type: 'public-key', id: allowedPublicKeys[0] }] : [],
+            };
+            const result = yield react_native_passkey_1.Passkey.get(requestJson);
+            let resultJson;
+            if (typeof result === 'string') {
+                resultJson = JSON.parse(result);
+            }
+            else {
+                resultJson = result;
+            }
+            const session = yield this.ctx.client.touchSession();
+            const publicKey = resultJson.id;
+            const verifyWebChallengeResult = yield this.ctx.client.verifyWebChallenge(session.data.partnerId, {
+                publicKey,
+                signature: {
+                    clientDataJSON: resultJson.response.clientDataJSON,
+                    authenticatorData: resultJson.response.authenticatorData,
+                    signature: resultJson.response.signature,
+                },
+            });
+            const userId = verifyWebChallengeResult.data.userId;
+            yield this.setUserId(userId);
+            const { user } = yield this.ctx.client.getUser(userId);
+            if (user.phone) {
+                yield this.setPhoneNumber(user.phone.number, user.phone.countryCode);
+            }
+            if (user.email) {
+                yield this.setEmail(user.email);
+            }
+            if (user.farcasterUsername) {
+                yield this.setFarcasterUsername(user.farcasterUsername);
+            }
+            const encryptedSharesResult = yield this.ctx.client.getBiometricKeyshares(userId, resultJson.id);
+            const encryptionKeyHash = (0, web_sdk_1.getSHA256HashHex)(resultJson.response.userHandle);
+            const { encryptedPrivateKeys } = yield this.ctx.client.getEncryptedWalletPrivateKeys(userId, encryptionKeyHash);
+            let decryptedShares;
+            if (encryptedPrivateKeys.length === 0) {
+                decryptedShares = yield (0, web_sdk_1.getDerivedPrivateKeyAndDecrypt)(this.ctx, resultJson.response.userHandle, encryptedSharesResult.data.keyShares);
+                const keyPair = yield (0, web_sdk_1.getAsymmetricKeyPair)(this.ctx, resultJson.response.userHandle);
+                const encryptedPrivateKeyHex = yield (0, web_sdk_1.encryptPrivateKey)(keyPair, resultJson.response.userHandle);
+                yield this.ctx.client.uploadEncryptedWalletPrivateKey(userId, encryptedPrivateKeyHex, encryptionKeyHash, resultJson.id);
+            }
+            else {
+                decryptedShares = yield (0, web_sdk_1.decryptPrivateKeyAndDecryptShare)(resultJson.response.userHandle, encryptedSharesResult.data.keyShares, encryptedPrivateKeys[0].encryptedPrivateKey);
+            }
+            const walletsRes = yield this.ctx.client.getWallets(userId);
+            const desiredWallets = walletsRes.data.wallets;
+            const walletsToInsert = {};
+            for (let desiredWallet of desiredWallets) {
+                const decryptedShare = decryptedShares.find(share => share.walletId === desiredWallet.id);
+                walletsToInsert[decryptedShare.walletId] = {
+                    id: decryptedShare.walletId,
+                    signer: decryptedShare.signer,
+                    address: desiredWallet.address || undefined,
+                    publicKey: desiredWallet.publicKey || undefined,
+                    scheme: desiredWallet.scheme,
+                    type: desiredWallet.type || undefined,
+                };
+            }
+            yield this.setWallets(walletsToInsert);
+        });
+    }
+}
+exports.ParaMobile = ParaMobile;

package/dist/cjs/react-native/ReactNativeUtils.js

@@ -0,0 +1,174 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactNativeUtils = void 0;
+const user_management_client_1 = require("@getpara/user-management-client");
+const react_native_1 = require("react-native");
+const AsyncStorage_js_1 = require("../AsyncStorage.js");
+const KeychainStorage_js_1 = require("../KeychainStorage.js");
+const { ParaSignerModule } = react_native_1.NativeModules;
+function keygenRequest(ctx, userId, walletId, protocolId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { data } = yield ctx.mpcComputationClient.post('/wallets', {
+            userId,
+            walletId,
+            protocolId,
+        });
+        return data;
+    });
+}
+function signMessageRequest(ctx, userId, walletId, protocolId, message, signer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { data } = yield ctx.mpcComputationClient.post(`/wallets/${walletId}/messages/sign`, {
+            userId,
+            protocolId,
+            message,
+            signer,
+        });
+        return data;
+    });
+}
+function sendTransactionRequest(ctx, userId, walletId, protocolId, transaction, signer, chainId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { data } = yield ctx.mpcComputationClient.post(`/wallets/${walletId}/transactions/send`, {
+            userId,
+            protocolId,
+            transaction,
+            signer,
+            chainId,
+        });
+        return data;
+    });
+}
+class ReactNativeUtils {
+    constructor() {
+        this.localStorage = new AsyncStorage_js_1.AsyncStorage();
+        this.sessionStorage = new AsyncStorage_js_1.AsyncStorage();
+        this.secureStorage = new KeychainStorage_js_1.KeychainStorage();
+        this.isSyncStorage = false;
+    }
+    // only used in web for now, can implement functionality if ever needed for mobile
+    generateBlumPrimes(_ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('method not implemented');
+        });
+    }
+    keygen(ctx, userId, type, _secretKey, _sessionCookie, _emailProps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { walletId, protocolId } = yield ctx.client.createWallet(userId, {
+                type,
+                useTwoSigners: true,
+                scheme: ctx.useDKLS ? user_management_client_1.WalletScheme.DKLS : user_management_client_1.WalletScheme.CGGMP,
+            });
+            if (ctx.mpcComputationClient && !ctx.useDKLS) {
+                const { signer } = yield keygenRequest(ctx, userId, walletId, protocolId);
+                return { signer, walletId };
+            }
+            const createAccountFn = !ctx.useDKLS ? ParaSignerModule.createAccount : ParaSignerModule.dklsCreateAccount;
+            const signer = yield createAccountFn(walletId, protocolId, user_management_client_1.KeyShareType.USER, userId);
+            return { signer, walletId };
+        });
+    }
+    refresh(_ctx, _sessionCookie, _userId, _walletId, _share, _oldPartnerId, _newPartnerId) {
+        throw new Error('Method not implemented.');
+    }
+    preKeygen(_ctx, _partnerId, _email, _secretKey, _sessionCookie) {
+        throw new Error('Method not implemented.');
+    }
+    getPrivateKey(_ctx, _userId, _walletId, _share, _sessionCookie) {
+        throw new Error('Method not implemented.');
+    }
+    openPopup(_popupUrl) {
+        throw new Error('Method not implemented.');
+    }
+    baseSignTransaction(ctx, userId, walletId, protocolId, share, rlpEncodedTxBase64, chainId, isDKLS) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ctx.mpcComputationClient && !isDKLS) {
+                const signature = (yield sendTransactionRequest(ctx, userId, walletId, protocolId, rlpEncodedTxBase64, share, chainId))
+                    .signature;
+                return { signature };
+            }
+            const sendTransactionFn = isDKLS ? ParaSignerModule.dklsSendTransaction : ParaSignerModule.sendTransaction;
+            const signature = yield sendTransactionFn(protocolId, share, rlpEncodedTxBase64, userId);
+            return { signature: signature.slice(2) };
+        });
+    }
+    sendTransaction(ctx, userId, walletId, share, rlpEncodedTxBase64, chainId, _sessionCookie, isDKLS) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { protocolId } = (yield ctx.client.sendTransaction(userId, walletId, {
+                transaction: rlpEncodedTxBase64,
+                chainId,
+            })).data;
+            return this.baseSignTransaction(ctx, userId, walletId, protocolId, share, rlpEncodedTxBase64, chainId, isDKLS);
+        });
+    }
+    signHash(_address, _hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('not implemented');
+        });
+    }
+    signMessage(ctx, userId, walletId, share, messageBase64, // base64 message
+    _sessionCookie, isDKLS) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield ctx.client.preSignMessage(userId, walletId, messageBase64);
+            if (ctx.mpcComputationClient && !isDKLS) {
+                const signature = (yield signMessageRequest(ctx, userId, walletId, res.protocolId, messageBase64, share)).signature;
+                return { signature };
+            }
+            const signMessageFn = isDKLS ? ParaSignerModule.dklsSignMessage : ParaSignerModule.signMessage;
+            const signature = yield signMessageFn(res.protocolId, share, messageBase64, userId);
+            if (signature.startsWith('0x')) {
+                return { signature: signature.slice(2) };
+            }
+            return { signature };
+        });
+    }
+    signTransaction(ctx, userId, walletId, share, rlpEncodedTxBase64, // base64 encoding of rlp encoded tx
+    chainId, _sessionCookie, isDKLS) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { protocolId } = (yield ctx.client.signTransaction(userId, walletId, {
+                transaction: rlpEncodedTxBase64,
+                chainId,
+            })).data;
+            return this.baseSignTransaction(ctx, userId, walletId, protocolId, share, rlpEncodedTxBase64, chainId, isDKLS);
+        });
+    }
+    ed25519Keygen(ctx, userId, _sessionCookie, _emailProps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { walletId, protocolId } = yield ctx.client.createWallet(userId, {
+                scheme: user_management_client_1.WalletScheme.ED25519,
+                type: user_management_client_1.WalletType.SOLANA,
+            });
+            const signer = yield ParaSignerModule.ed25519CreateAccount(walletId, protocolId);
+            return { signer, walletId };
+        });
+    }
+    ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType, _sessionCookie) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { walletId, protocolId } = yield ctx.client.createPregenWallet({
+                pregenIdentifier,
+                pregenIdentifierType,
+                scheme: user_management_client_1.WalletScheme.ED25519,
+                type: user_management_client_1.WalletType.SOLANA,
+            });
+            const signer = yield ParaSignerModule.ed25519CreateAccount(walletId, protocolId);
+            return { signer, walletId };
+        });
+    }
+    ed25519Sign(ctx, userId, walletId, share, base64Bytes, _sessionCookie) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { protocolId } = yield ctx.client.preSignMessage(userId, walletId, base64Bytes, user_management_client_1.WalletScheme.ED25519);
+            const base64Sig = yield ParaSignerModule.ed25519Sign(protocolId, share, base64Bytes);
+            return { signature: base64Sig };
+        });
+    }
+}
+exports.ReactNativeUtils = ReactNativeUtils;

package/dist/cjs/shim.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// 1) Node-like crypto + Web Crypto API (subtle + getRandomValues)
+const react_native_quick_crypto_1 = __importDefault(require("react-native-quick-crypto"));
+const crypto_1 = require("crypto");
+const webcrypto_1 = require("@peculiar/webcrypto");
+if (typeof global.crypto === 'undefined') {
+    // Attach Node-style crypto for randomFillSync, createHash, etc.
+    global.crypto = react_native_quick_crypto_1.default;
+}
+// If `crypto.subtle` is missing, patch it with `@peculiar/webcrypto`
+if (!global.crypto.subtle) {
+    const peculiarCrypto = new webcrypto_1.Crypto();
+    global.crypto.subtle = peculiarCrypto.subtle;
+    global.crypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+}
+// Add getRandomValues to webcrypto from peculiar
+const peculiarCrypto = new webcrypto_1.Crypto();
+crypto_1.webcrypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+// 2) Provide TextEncoder / TextDecoder
+const FSTED = __importStar(require("fastestsmallesttextencoderdecoder"));
+if (typeof global.TextEncoder === 'undefined') {
+    global.TextEncoder = FSTED.TextEncoder;
+}
+if (typeof global.TextDecoder === 'undefined') {
+    global.TextDecoder = FSTED.TextDecoder;
+}
+// 3) Provide atob / btoa via react-native-quick-base64
+const react_native_quick_base64_1 = require("react-native-quick-base64");
+if (typeof global.atob === 'undefined') {
+    global.atob = react_native_quick_base64_1.atob;
+}
+if (typeof global.btoa === 'undefined') {
+    global.btoa = react_native_quick_base64_1.btoa;
+}
+// 4) Patch node-forge with react-native-modpow for faster RSA ops
+const node_forge_1 = __importDefault(require("node-forge"));
+const react_native_modpow_1 = __importDefault(require("react-native-modpow"));
+node_forge_1.default.jsbn.BigInteger.prototype.modPow = function nativeModPow(e, m) {
+    const result = (0, react_native_modpow_1.default)({
+        target: this.toString(16),
+        value: e.toString(16),
+        modifier: m.toString(16),
+    });
+    return new node_forge_1.default.jsbn.BigInteger(result, 16);
+};
+// 5) Provide global Buffer
+const react_native_buffer_1 = require("@craftzdog/react-native-buffer");
+if (typeof global.Buffer === 'undefined') {
+    global.Buffer = react_native_buffer_1.Buffer;
+}
+// 6) React Native URL polyfill
+require("react-native-url-polyfill/auto");

package/dist/esm/AsyncStorage.d.ts

@@ -0,0 +1,10 @@
+import { StorageUtils } from '@getpara/web-sdk';
+/**
+ * Implements `StorageUtils` using React Native Async Storage.
+ */
+export declare class AsyncStorage implements StorageUtils {
+    clear(prefix: string): Promise<void>;
+    get(key: string): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+    set(key: string, value: string): Promise<void>;
+}

package/dist/esm/KeychainStorage.d.ts

@@ -0,0 +1,10 @@
+import { StorageUtils } from '@getpara/web-sdk';
+/**
+ * Implements `StorageUtils` using React Native `Keychain`.
+ */
+export declare class KeychainStorage implements StorageUtils {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(prefix: string): Promise<void>;
+}

package/dist/esm/config.d.ts

@@ -0,0 +1,7 @@
+import { Environment } from '@getpara/web-sdk';
+export declare function getBaseMPCNetworkWSUrl(env: Environment): string;
+export declare let userManagementServer: string;
+export declare let portalBase: string;
+export declare let mpcNetworkWSServer: string;
+export declare function setEnv(env: Environment): void;
+export declare const DEBUG_MODE_ENABLED = false;

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+export * from '@getpara/web-sdk';
+export { ParaMobile } from './react-native/ParaMobile.js';

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

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

@@ -0,0 +1,52 @@
+import { ConstructorOpts, ParaCore, Environment, PlatformUtils } from '@getpara/web-sdk';
+import { Auth } from '@getpara/user-management-client';
+/**
+ * Represents a mobile implementation of the Para SDK.
+ * @extends ParaCore
+ *
+ * @example
+ * const para = new ParaMobile(Environment.BETA, "api_key");
+ */
+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 {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 getPlatformUtils(): PlatformUtils;
+    /**
+     * Verifies an email and returns the biometrics ID.
+     * @param {string} verificationCode - The verification code sent to the email.
+     * @returns {Promise<string>} The biometrics ID.
+     */
+    verifyEmailBiometricsId({ verificationCode }: {
+        verificationCode: string;
+    }): Promise<string>;
+    /**
+     * Verifies a phone number and returns the biometrics ID.
+     * @param {string} verificationCode - The verification code sent to the phone.
+     * @returns {Promise<string>} The biometrics ID.
+     */
+    verifyPhoneBiometricsId({ verificationCode }: {
+        verificationCode: string;
+    }): Promise<string>;
+    /**
+     * Registers a passkey for the user.
+     * @param {Auth<'email'> | Auth<'phone'>} auth - The user's authentication details
+     * @param {string} biometricsId - The biometrics ID obtained from verification.
+     * @returns {Promise<void>}
+     */
+    registerPasskey({ biometricsId, ...auth }: {
+        biometricsId: string;
+    } & (Auth<'email'> | Auth<'phone'>)): Promise<void>;
+    /**
+     * Logs in the user using their authentication credentials.
+     * @param {AuthParams} params - The authentication parameters.
+     * @returns {Promise<void>}
+     */
+    login({ ...auth }: Auth<'email'> | Auth<'phone'>): Promise<void>;
+}

package/dist/{react-native → esm/react-native}/ParaMobile.js

@@ -21,7 +21,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 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 { extractAuthInfo, PublicKeyStatus } from '@getpara/user-management-client';
 import { setEnv } from '../config.js';
 import base64url from 'base64url';
 import { webcrypto } from 'crypto';
@@ -116,7 +116,7 @@ export class ParaMobile extends ParaCore {
             const userHandle = new Uint8Array(32);
             webcrypto.getRandomValues(userHandle);
             const userHandleEncoded = base64url.encode(userHandle);
-            const displayIdentifier = 'email' in auth ? auth.email : `${auth.countryCode}${auth.phone}`;
+            const { identifier: displayIdentifier } = extractAuthInfo(auth, { isRequired: true });
             const requestJson = {
                 authenticatorSelection: {
                     authenticatorAttachment: 'platform',
@@ -180,7 +180,8 @@ export class ParaMobile extends ParaCore {
         return __awaiter(this, void 0, void 0, function* () {
             var auth = __rest(_a, []);
             yield this.logout();
-            const { challenge, allowedPublicKeys } = yield this.ctx.client.getWebChallenge(auth);
+            const authInfo = extractAuthInfo(auth, { isRequired: true });
+            const { challenge, allowedPublicKeys } = yield this.ctx.client.getWebChallenge(authInfo.auth);
             const requestJson = {
                 challenge,
                 timeout: 60000,

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

@@ -0,0 +1,50 @@
+import { PlatformUtils, TPregenIdentifierType } from '@getpara/web-sdk';
+import { Ctx } from '@getpara/web-sdk';
+import { SignatureRes } from '@getpara/web-sdk';
+import { BackupKitEmailProps, WalletType } from '@getpara/user-management-client';
+import { AsyncStorage } from '../AsyncStorage.js';
+import { KeychainStorage } from '../KeychainStorage.js';
+export declare class ReactNativeUtils implements PlatformUtils {
+    disableProviderModal?: boolean | undefined;
+    localStorage: AsyncStorage;
+    sessionStorage: AsyncStorage;
+    secureStorage: KeychainStorage;
+    isSyncStorage: boolean;
+    generateBlumPrimes(_ctx: Ctx): Promise<{
+        p: string;
+        q: string;
+    }>;
+    keygen(ctx: Ctx, userId: string, type: Exclude<WalletType, WalletType.SOLANA>, _secretKey: string | null, _sessionCookie: string, _emailProps?: BackupKitEmailProps | undefined): Promise<{
+        signer: string;
+        walletId: string;
+    }>;
+    refresh(_ctx: Ctx, _sessionCookie: string, _userId: string, _walletId: string, _share: string, _oldPartnerId?: string, _newPartnerId?: string): Promise<{
+        signer: string;
+    }>;
+    preKeygen(_ctx: Ctx, _partnerId: string, _email: string, _secretKey: string | null, _sessionCookie: string): Promise<{
+        signer: string;
+        walletId: string;
+    }>;
+    getPrivateKey(_ctx: Ctx, _userId: string, _walletId: string, _share: string, _sessionCookie: string): Promise<string>;
+    openPopup(_popupUrl: string): any;
+    private baseSignTransaction;
+    sendTransaction(ctx: Ctx, userId: string, walletId: string, share: string, rlpEncodedTxBase64: string, chainId: string, _sessionCookie: string, isDKLS?: boolean): Promise<SignatureRes>;
+    signHash(_address: string, _hash: string): Promise<{
+        v: number;
+        r: Buffer;
+        s: Buffer;
+    }>;
+    signMessage(ctx: Ctx, userId: string, walletId: string, share: string, messageBase64: string, // base64 message
+    _sessionCookie: string, isDKLS?: boolean): Promise<SignatureRes>;
+    signTransaction(ctx: Ctx, userId: string, walletId: string, share: string, rlpEncodedTxBase64: string, // base64 encoding of rlp encoded tx
+    chainId: string, _sessionCookie: string, isDKLS?: boolean): Promise<SignatureRes>;
+    ed25519Keygen(ctx: Ctx, userId: string, _sessionCookie: string, _emailProps?: BackupKitEmailProps): Promise<{
+        signer: string;
+        walletId: string;
+    }>;
+    ed25519PreKeygen(ctx: Ctx, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, _sessionCookie: string): Promise<{
+        signer: string;
+        walletId: string;
+    }>;
+    ed25519Sign(ctx: Ctx, userId: string, walletId: string, share: string, base64Bytes: string, _sessionCookie: string): Promise<SignatureRes>;
+}

package/dist/esm/shim.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{shim.js → esm/shim.js}

@@ -47,3 +47,5 @@ import { Buffer } from '@craftzdog/react-native-buffer';
 if (typeof global.Buffer === 'undefined') {
     global.Buffer = Buffer;
 }
+// 6) React Native URL polyfill
+import 'react-native-url-polyfill/auto';

package/dist/types/AsyncStorage.d.ts

@@ -0,0 +1,10 @@
+import { StorageUtils } from '@getpara/web-sdk';
+/**
+ * Implements `StorageUtils` using React Native Async Storage.
+ */
+export declare class AsyncStorage implements StorageUtils {
+    clear(prefix: string): Promise<void>;
+    get(key: string): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+    set(key: string, value: string): Promise<void>;
+}

package/dist/types/KeychainStorage.d.ts

@@ -0,0 +1,10 @@
+import { StorageUtils } from '@getpara/web-sdk';
+/**
+ * Implements `StorageUtils` using React Native `Keychain`.
+ */
+export declare class KeychainStorage implements StorageUtils {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(prefix: string): Promise<void>;
+}

package/dist/types/config.d.ts

@@ -0,0 +1,7 @@
+import { Environment } from '@getpara/web-sdk';
+export declare function getBaseMPCNetworkWSUrl(env: Environment): string;
+export declare let userManagementServer: string;
+export declare let portalBase: string;
+export declare let mpcNetworkWSServer: string;
+export declare function setEnv(env: Environment): void;
+export declare const DEBUG_MODE_ENABLED = false;

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from '@getpara/web-sdk';
+export { ParaMobile } from './react-native/ParaMobile.js';

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

@@ -0,0 +1,52 @@
+import { ConstructorOpts, ParaCore, Environment, PlatformUtils } from '@getpara/web-sdk';
+import { Auth } from '@getpara/user-management-client';
+/**
+ * Represents a mobile implementation of the Para SDK.
+ * @extends ParaCore
+ *
+ * @example
+ * const para = new ParaMobile(Environment.BETA, "api_key");
+ */
+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 {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 getPlatformUtils(): PlatformUtils;
+    /**
+     * Verifies an email and returns the biometrics ID.
+     * @param {string} verificationCode - The verification code sent to the email.
+     * @returns {Promise<string>} The biometrics ID.
+     */
+    verifyEmailBiometricsId({ verificationCode }: {
+        verificationCode: string;
+    }): Promise<string>;
+    /**
+     * Verifies a phone number and returns the biometrics ID.
+     * @param {string} verificationCode - The verification code sent to the phone.
+     * @returns {Promise<string>} The biometrics ID.
+     */
+    verifyPhoneBiometricsId({ verificationCode }: {
+        verificationCode: string;
+    }): Promise<string>;
+    /**
+     * Registers a passkey for the user.
+     * @param {Auth<'email'> | Auth<'phone'>} auth - The user's authentication details
+     * @param {string} biometricsId - The biometrics ID obtained from verification.
+     * @returns {Promise<void>}
+     */
+    registerPasskey({ biometricsId, ...auth }: {
+        biometricsId: string;
+    } & (Auth<'email'> | Auth<'phone'>)): Promise<void>;
+    /**
+     * Logs in the user using their authentication credentials.
+     * @param {AuthParams} params - The authentication parameters.
+     * @returns {Promise<void>}
+     */
+    login({ ...auth }: Auth<'email'> | Auth<'phone'>): Promise<void>;
+}

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

@@ -0,0 +1,50 @@
+import { PlatformUtils, TPregenIdentifierType } from '@getpara/web-sdk';
+import { Ctx } from '@getpara/web-sdk';
+import { SignatureRes } from '@getpara/web-sdk';
+import { BackupKitEmailProps, WalletType } from '@getpara/user-management-client';
+import { AsyncStorage } from '../AsyncStorage.js';
+import { KeychainStorage } from '../KeychainStorage.js';
+export declare class ReactNativeUtils implements PlatformUtils {
+    disableProviderModal?: boolean | undefined;
+    localStorage: AsyncStorage;
+    sessionStorage: AsyncStorage;
+    secureStorage: KeychainStorage;
+    isSyncStorage: boolean;
+    generateBlumPrimes(_ctx: Ctx): Promise<{
+        p: string;
+        q: string;
+    }>;
+    keygen(ctx: Ctx, userId: string, type: Exclude<WalletType, WalletType.SOLANA>, _secretKey: string | null, _sessionCookie: string, _emailProps?: BackupKitEmailProps | undefined): Promise<{
+        signer: string;
+        walletId: string;
+    }>;
+    refresh(_ctx: Ctx, _sessionCookie: string, _userId: string, _walletId: string, _share: string, _oldPartnerId?: string, _newPartnerId?: string): Promise<{
+        signer: string;
+    }>;
+    preKeygen(_ctx: Ctx, _partnerId: string, _email: string, _secretKey: string | null, _sessionCookie: string): Promise<{
+        signer: string;
+        walletId: string;
+    }>;
+    getPrivateKey(_ctx: Ctx, _userId: string, _walletId: string, _share: string, _sessionCookie: string): Promise<string>;
+    openPopup(_popupUrl: string): any;
+    private baseSignTransaction;
+    sendTransaction(ctx: Ctx, userId: string, walletId: string, share: string, rlpEncodedTxBase64: string, chainId: string, _sessionCookie: string, isDKLS?: boolean): Promise<SignatureRes>;
+    signHash(_address: string, _hash: string): Promise<{
+        v: number;
+        r: Buffer;
+        s: Buffer;
+    }>;
+    signMessage(ctx: Ctx, userId: string, walletId: string, share: string, messageBase64: string, // base64 message
+    _sessionCookie: string, isDKLS?: boolean): Promise<SignatureRes>;
+    signTransaction(ctx: Ctx, userId: string, walletId: string, share: string, rlpEncodedTxBase64: string, // base64 encoding of rlp encoded tx
+    chainId: string, _sessionCookie: string, isDKLS?: boolean): Promise<SignatureRes>;
+    ed25519Keygen(ctx: Ctx, userId: string, _sessionCookie: string, _emailProps?: BackupKitEmailProps): Promise<{
+        signer: string;
+        walletId: string;
+    }>;
+    ed25519PreKeygen(ctx: Ctx, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, _sessionCookie: string): Promise<{
+        signer: string;
+        walletId: string;
+    }>;
+    ed25519Sign(ctx: Ctx, userId: string, walletId: string, share: string, base64Bytes: string, _sessionCookie: string): Promise<SignatureRes>;
+}

package/dist/types/shim.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,12 +1,9 @@
 {
   "name": "@getpara/react-native-wallet",
-  "version": "1.0.2-dev.6",
-  "description": "Para Wallet for React Native",
-  "homepage": "https://getpara.com",
-  "author": "Para Team <hello@getpara.com> (https://getpara.com)",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "version": "1.0.2-dev.7",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
   "files": [
     "dist",
     "src",
@@ -17,8 +14,21 @@
     "signer.xcframework",
     "signer.aar"
   ],
+  "exports": {
+    ".": {
+      "react-native": "./dist/cjs/index.js",
+      "default": "./dist/esm/index.js"
+    },
+    "./shim": {
+      "react-native": "./dist/cjs/shim.js",
+      "default": "./dist/esm/shim.js"
+    }
+  },
   "scripts": {
-    "build": "rm -rf dist && tsc",
+    "build": "yarn build:cjs && yarn build:esm && yarn build:types",
+    "build:cjs": "rm -rf dist/cjs && tsc --module commonjs --outDir dist/cjs && echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json",
+    "build:esm": "rm -rf dist/esm && tsc --module es6 --outDir dist/esm && echo '{\"type\":\"module\"}' > dist/esm/package.json",
+    "build:types": "rm -rf dist/types && tsc --module es6 --declarationDir dist/types --emitDeclarationOnly --declaration",
     "compile-signer": "bash ./scripts/compileSigner.sh"
   },
   "dependencies": {

package/src/react-native/ParaMobile.ts

@@ -20,7 +20,7 @@ import {
   PasskeyGetRequest,
   PasskeyGetResult,
 } from 'react-native-passkey';
-import { Auth, PublicKeyStatus, WalletScheme } from '@getpara/user-management-client';
+import { Auth, extractAuthInfo, PublicKeyStatus, WalletScheme } from '@getpara/user-management-client';
 import { setEnv } from '../config.js';
 import base64url from 'base64url';
 import { webcrypto } from 'crypto';
@@ -113,7 +113,7 @@ export class ParaMobile extends ParaCore {
     webcrypto.getRandomValues(userHandle);
     const userHandleEncoded = base64url.encode(userHandle as any);
 
-    const displayIdentifier = 'email' in auth ? auth.email : `${auth.countryCode}${auth.phone}`;
+    const { identifier: displayIdentifier } = extractAuthInfo(auth, { isRequired: true });
 
     const requestJson: PasskeyCreateRequest = {
       authenticatorSelection: {
@@ -187,7 +187,10 @@ export class ParaMobile extends ParaCore {
    */
   async login({ ...auth }: Auth<'email'> | Auth<'phone'>): Promise<void> {
     await this.logout();
-    const { challenge, allowedPublicKeys } = await this.ctx.client.getWebChallenge(auth);
+
+    const authInfo = extractAuthInfo(auth, { isRequired: true });
+
+    const { challenge, allowedPublicKeys } = await this.ctx.client.getWebChallenge(authInfo.auth);
 
     const requestJson: PasskeyGetRequest = {
       challenge,

package/src/shim.js

@@ -57,3 +57,6 @@ import { Buffer } from '@craftzdog/react-native-buffer';
 if (typeof global.Buffer === 'undefined') {
   global.Buffer = Buffer;
 }
+
+// 6) React Native URL polyfill
+import 'react-native-url-polyfill/auto';