@getpara/react-native-wallet 0.1.0

package/dist/index.js

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

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

@@ -0,0 +1,49 @@
+import { ConstructorOpts, ParaCore, Environment, PlatformUtils } from '@getpara/web-sdk';
+import { webcrypto } from 'crypto';
+import { CountryCallingCode } from 'libphonenumber-js';
+/**
+ * Represents a mobile implementation of the Para SDK.
+ * @extends ParaCore
+ */
+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: 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: string): Promise<string>;
+    /**
+     * Registers a passkey for the user.
+     * @param {string} identifier - The user's email or phone number.
+     * @param {string} biometricsId - The biometrics ID obtained from verification.
+     * @param {webcrypto.Crypto} crypto - The Web Crypto API instance.
+     * @param {'email' | 'phone'} [identifierType='email'] - The type of identifier used.
+     * @param {CountryCallingCode} [countryCode] - The country calling code for phone numbers.
+     * @returns {Promise<void>}
+     */
+    registerPasskey(identifier: string, biometricsId: string, crypto: webcrypto.Crypto, identifierType?: 'email' | 'phone', countryCode?: CountryCallingCode): Promise<void>;
+    /**
+     * Logs in the user using either email or phone number.
+     * @param {string} [email] - The user's email address.
+     * @param {string} [phone] - The user's phone number.
+     * @param {CountryCallingCode} [countryCode] - The country calling code for phone numbers.
+     * @returns {Promise<Wallet[]>} An array of user wallets.
+     */
+    login(email?: string, phone?: string, countryCode?: CountryCallingCode): Promise<void>;
+}

package/dist/react-native/ParaMobile.js

@@ -0,0 +1,237 @@
+// Copyright (c) Para Labs Inc. All rights reserved.
+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 { 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 { extractAuth, PublicKeyStatus } from '@getpara/user-management-client';
+import { setEnv } from '../config.js';
+import base64url from 'base64url';
+const ES256_ALGORITHM = -7;
+const RS256_ALGORITHM = -257;
+/**
+ * Represents a mobile implementation of the Para SDK.
+ * @extends ParaCore
+ */
+export class ParaMobile extends ParaCore {
+    /**
+     * Creates an instance of ParaMobile.
+     * @param {Environment} env - The environment to use (DEV, SANDBOX, BETA, or PROD).
+     * @param {string} [apiKey] - The API key for authentication.
+     * @param {string} [relyingPartyId] - The relying party ID for WebAuthn.
+     * @param {ConstructorOpts} [opts] - Additional constructor options.
+     */
+    constructor(env, apiKey, relyingPartyId, opts) {
+        super(env, apiKey, opts);
+        setEnv(env);
+        if (relyingPartyId) {
+            this.relyingPartyId = relyingPartyId;
+        }
+        else {
+            switch (env) {
+                case Environment.DEV:
+                    throw new Error('relyingPartyId is required');
+                case Environment.SANDBOX:
+                    this.relyingPartyId = 'app.sandbox.usecapsule.com';
+                    break;
+                case Environment.BETA:
+                    this.relyingPartyId = 'app.beta.usecapsule.com';
+                    break;
+                case Environment.PROD:
+                    this.relyingPartyId = 'app.usecapsule.com';
+                    break;
+            }
+        }
+    }
+    getPlatformUtils() {
+        return new 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(verificationCode) {
+        const _super = Object.create(null, {
+            verifyEmail: { get: () => super.verifyEmail }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            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(verificationCode) {
+        const _super = Object.create(null, {
+            verifyPhone: { get: () => super.verifyPhone }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            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 {string} identifier - The user's email or phone number.
+     * @param {string} biometricsId - The biometrics ID obtained from verification.
+     * @param {webcrypto.Crypto} crypto - The Web Crypto API instance.
+     * @param {'email' | 'phone'} [identifierType='email'] - The type of identifier used.
+     * @param {CountryCallingCode} [countryCode] - The country calling code for phone numbers.
+     * @returns {Promise<void>}
+     */
+    registerPasskey(identifier_1, biometricsId_1, crypto_1) {
+        return __awaiter(this, arguments, void 0, function* (identifier, biometricsId, crypto, identifierType = 'email', countryCode) {
+            const userHandle = new Uint8Array(32);
+            crypto.getRandomValues(userHandle);
+            const userHandleEncoded = base64url.encode(userHandle);
+            const displayIdentifier = identifierType === 'email' ? identifier : `${countryCode}${identifier}`;
+            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.encode('somechallenge'),
+            };
+            const result = yield Passkey.create(requestJson);
+            let resultJson;
+            if (typeof result === 'string') {
+                resultJson = JSON.parse(result);
+            }
+            else {
+                resultJson = result;
+            }
+            const { cosePublicKey, clientDataJSON } = parseCredentialCreationRes(resultJson, ES256_ALGORITHM);
+            const keyPair = yield getAsymmetricKeyPair(this.ctx);
+            const publicKeyHex = getPublicKeyHex(keyPair);
+            const encryptionKeyHash = getSHA256HashHex(userHandleEncoded);
+            const encryptedPrivateKeyHex = yield 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: PublicKeyStatus.COMPLETE,
+            });
+            yield this.ctx.client.uploadEncryptedWalletPrivateKey(this.getUserId(), encryptedPrivateKeyHex, encryptionKeyHash, resultJson.id);
+        });
+    }
+    /**
+     * Logs in the user using either email or phone number.
+     * @param {string} [email] - The user's email address.
+     * @param {string} [phone] - The user's phone number.
+     * @param {CountryCallingCode} [countryCode] - The country calling code for phone numbers.
+     * @returns {Promise<Wallet[]>} An array of user wallets.
+     */
+    login(email, phone, countryCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.logout();
+            const auth = extractAuth({ email, phone, countryCode }, { optional: true });
+            const { challenge, allowedPublicKeys } = yield this.ctx.client.getWebChallenge(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 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 = getSHA256HashHex(resultJson.response.userHandle);
+            const { encryptedPrivateKeys } = yield this.ctx.client.getEncryptedWalletPrivateKeys(userId, encryptionKeyHash);
+            let decryptedShares;
+            if (encryptedPrivateKeys.length === 0) {
+                decryptedShares = yield getDerivedPrivateKeyAndDecrypt(this.ctx, resultJson.response.userHandle, encryptedSharesResult.data.keyShares);
+                const keyPair = yield getAsymmetricKeyPair(this.ctx, resultJson.response.userHandle);
+                const encryptedPrivateKeyHex = yield encryptPrivateKey(keyPair, resultJson.response.userHandle);
+                yield this.ctx.client.uploadEncryptedWalletPrivateKey(userId, encryptedPrivateKeyHex, encryptionKeyHash, resultJson.id);
+            }
+            else {
+                decryptedShares = yield 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);
+        });
+    }
+}

package/dist/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/react-native/ReactNativeUtils.js

@@ -0,0 +1,171 @@
+// Copyright (c) Capsule Labs Inc. All rights reserved.
+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 { KeyShareType, WalletScheme, WalletType } from '@getpara/user-management-client';
+import { NativeModules } from 'react-native';
+import { AsyncStorage } from '../AsyncStorage.js';
+import { KeychainStorage } from '../KeychainStorage.js';
+const { ParaSignerModule } = 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;
+    });
+}
+export class ReactNativeUtils {
+    constructor() {
+        this.localStorage = new AsyncStorage();
+        this.sessionStorage = new AsyncStorage();
+        this.secureStorage = new 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 ? WalletScheme.DKLS : 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, 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: WalletScheme.ED25519,
+                type: 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.createWalletPreGen({
+                pregenIdentifier,
+                pregenIdentifierType,
+                scheme: WalletScheme.ED25519,
+                type: 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, WalletScheme.ED25519);
+            const base64Sig = yield ParaSignerModule.ed25519Sign(protocolId, share, base64Bytes);
+            return { signature: base64Sig };
+        });
+    }
+}

package/dist/shim.d.ts

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

package/dist/shim.js

@@ -0,0 +1,49 @@
+// 1) Node-like crypto + Web Crypto API (subtle + getRandomValues)
+import crypto from 'react-native-quick-crypto';
+import { webcrypto } from 'crypto';
+import { Crypto } from '@peculiar/webcrypto';
+if (typeof global.crypto === 'undefined') {
+    // Attach Node-style crypto for randomFillSync, createHash, etc.
+    global.crypto = crypto;
+}
+// If `crypto.subtle` is missing, patch it with `@peculiar/webcrypto`
+if (!global.crypto.subtle) {
+    const peculiarCrypto = new Crypto();
+    global.crypto.subtle = peculiarCrypto.subtle;
+    global.crypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+}
+// Add getRandomValues to webcrypto from peculiar
+const peculiarCrypto = new Crypto();
+webcrypto.getRandomValues = peculiarCrypto.getRandomValues.bind(peculiarCrypto);
+// 2) Provide TextEncoder / TextDecoder
+import * as FSTED from '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
+import { atob, btoa } from 'react-native-quick-base64';
+if (typeof global.atob === 'undefined') {
+    global.atob = atob;
+}
+if (typeof global.btoa === 'undefined') {
+    global.btoa = btoa;
+}
+// 4) Patch node-forge with react-native-modpow for faster RSA ops
+import Forge from 'node-forge';
+import modPow from 'react-native-modpow';
+Forge.jsbn.BigInteger.prototype.modPow = function nativeModPow(e, m) {
+    const result = modPow({
+        target: this.toString(16),
+        value: e.toString(16),
+        modifier: m.toString(16),
+    });
+    return new Forge.jsbn.BigInteger(result, 16);
+};
+// 5) Provide global Buffer
+import { Buffer } from '@craftzdog/react-native-buffer';
+if (typeof global.Buffer === 'undefined') {
+    global.Buffer = Buffer;
+}

package/ios/ParaSignerModule.h

@@ -0,0 +1,12 @@
+// Copyright (c) Capsule Labs Inc. All rights reserved.
+
+//
+//  ParaSignerModule.h
+//
+//  Created by Michał Osadnik on 14/12/2022.
+//
+
+#import <React/RCTBridgeModule.h>
+
+@interface ParaSignerModule : NSObject <RCTBridgeModule>
+@end