@pooflabs/web 0.0.73 → 0.0.74

package/dist/solana-mobile-wallet-provider-DDqwl25J.js

@@ -0,0 +1,579 @@
+'use strict';
+
+var index = require('./index-Bdcc5821.js');
+var index_native = require('./index.native-muw49g7i.js');
+var web3_js = require('@solana/web3.js');
+var anchor = require('@coral-xyz/anchor');
+require('axios');
+require('react');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var anchor__namespace = /*#__PURE__*/_interopNamespaceDefault(anchor);
+
+const ED25519_SIGNATURE_LENGTH = 64;
+// Dynamically imported MWA protocol module
+let mwaProtocolModule = null;
+let mwaProtocolLoadPromise = null;
+async function loadMwaProtocol() {
+    if (mwaProtocolModule)
+        return;
+    if (typeof window === 'undefined')
+        return;
+    if (mwaProtocolLoadPromise)
+        return mwaProtocolLoadPromise;
+    mwaProtocolLoadPromise = (async () => {
+        try {
+            mwaProtocolModule = await Promise.resolve().then(function () { return require('./index.browser-B8vmX-tI.js'); });
+        }
+        catch (e) {
+            console.warn('[SolanaMobileWallet] @solana-mobile/mobile-wallet-adapter-protocol-web3js not installed. Install it to enable Seeker wallet support.');
+            throw new Error('Missing @solana-mobile/mobile-wallet-adapter-protocol-web3js dependency');
+        }
+    })();
+    return mwaProtocolLoadPromise;
+}
+/**
+ * SolanaMobileWalletProvider implements the AuthProvider interface using the
+ * Solana Mobile Wallet Adapter (MWA) protocol's low-level `transact` API.
+ *
+ * This enables TaroBase dApps to work with any MWA-compliant wallet on Solana
+ * mobile devices (Seeker, Saga) — including the native Seed Vault Wallet,
+ * Phantom, Solflare, and any other wallet that implements the MWA protocol.
+ *
+ * By using `transact()` directly (instead of the wallet-adapter wrapper),
+ * login combines authorize + signMessage into a single wallet session —
+ * meaning one popup/approval instead of two.
+ */
+class SolanaMobileWalletProvider {
+    constructor(networkUrl = null, config = {}) {
+        // MWA authorization state
+        this.authToken = null;
+        this.walletUriBase = null;
+        this.base64Address = null;
+        this.authorizedPublicKey = null;
+        this.publicKeyObj = null;
+        this.networkUrl = networkUrl;
+        this.config = config;
+        if (typeof window === 'undefined') {
+            throw new Error('SolanaMobileWalletProvider can only be instantiated in a browser environment');
+        }
+        if (SolanaMobileWalletProvider.instance) {
+            return SolanaMobileWalletProvider.instance;
+        }
+        this.appIdentity = config.appIdentity || {
+            name: 'TaroBase App',
+            uri: index_native.getPlatform().getLocationOrigin(),
+        };
+        this.chain = `solana:${config.cluster || 'mainnet-beta'}`;
+        SolanaMobileWalletProvider.instance = this;
+    }
+    static getInstance(networkUrl, config) {
+        if (!SolanaMobileWalletProvider.instance) {
+            new SolanaMobileWalletProvider(networkUrl, config);
+        }
+        return SolanaMobileWalletProvider.instance;
+    }
+    /** Config for transact() — routes to the same wallet if we've already authorized */
+    getAssociationConfig() {
+        if (this.walletUriBase) {
+            return { baseUri: this.walletUriBase };
+        }
+        return undefined;
+    }
+    /** Reauthorize within a transact callback using a stored auth_token */
+    async reauthorizeWallet(wallet) {
+        if (!this.authToken) {
+            // No existing auth — do a fresh authorize
+            const authResult = await wallet.authorize({
+                identity: this.appIdentity,
+                chain: this.chain,
+            });
+            this.storeAuthResult(authResult);
+            return authResult;
+        }
+        try {
+            const authResult = await wallet.reauthorize({
+                auth_token: this.authToken,
+                identity: this.appIdentity,
+            });
+            this.storeAuthResult(authResult);
+            return authResult;
+        }
+        catch (e) {
+            // Reauth failed (token expired, wallet reset, etc.) — try fresh authorize
+            console.warn('[SolanaMobileWallet] Reauthorization failed, attempting fresh authorize:', e === null || e === void 0 ? void 0 : e.message);
+            const authResult = await wallet.authorize({
+                identity: this.appIdentity,
+                chain: this.chain,
+            });
+            this.storeAuthResult(authResult);
+            return authResult;
+        }
+    }
+    /** Persist auth result from an authorize/reauthorize call */
+    storeAuthResult(authResult) {
+        var _a;
+        this.authToken = authResult.auth_token;
+        this.walletUriBase = authResult.wallet_uri_base;
+        if (((_a = authResult.accounts) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            const account = authResult.accounts[0];
+            this.base64Address = account.address;
+            // Decode base64 address → PublicKey → base58
+            const addressBytes = Uint8Array.from(index_native.getPlatform().atob(account.address), c => c.charCodeAt(0));
+            this.publicKeyObj = new web3_js.PublicKey(addressBytes);
+            this.authorizedPublicKey = this.publicKeyObj.toBase58();
+        }
+    }
+    async login() {
+        var _a, _b, _c, _d, _e;
+        index_native.setAuthLoading(true);
+        try {
+            await loadMwaProtocol();
+            const { transact } = mwaProtocolModule;
+            // Quick check: if we already have auth state and a valid session, skip
+            if (this.authorizedPublicKey) {
+                const existingSession = await index_native.WebSessionManager.getSession();
+                if (existingSession && existingSession.address === this.authorizedPublicKey) {
+                    const user = { provider: this, address: this.authorizedPublicKey };
+                    index_native.setCurrentUser(user);
+                    return user;
+                }
+            }
+            // Pre-fetch nonce from server while wallet is not yet connected
+            const nonce = await index_native.genAuthNonce();
+            // Single transact() call: authorize + signMessages — one wallet popup
+            const result = await transact(async (wallet) => {
+                // Step 1: Authorize — user approves the dApp
+                const authResult = await wallet.authorize({
+                    identity: this.appIdentity,
+                    chain: this.chain,
+                });
+                const base64Addr = authResult.accounts[0].address;
+                const addressBytes = Uint8Array.from(index_native.getPlatform().atob(base64Addr), c => c.charCodeAt(0));
+                const pubkey = new web3_js.PublicKey(addressBytes);
+                const base58Addr = pubkey.toBase58();
+                // Step 2: Sign the auth message — still in the same wallet session
+                const messageText = await index_native.genSolanaMessage(base58Addr, nonce);
+                const messageBytes = index_native.getPlatform().textEncode(messageText);
+                const signedMessages = await wallet.signMessages({
+                    addresses: [base64Addr],
+                    payloads: [messageBytes],
+                });
+                // The signed payload is [original message bytes][64-byte ed25519 signature]
+                const signedPayload = signedMessages[0];
+                const signatureBytes = signedPayload.slice(-ED25519_SIGNATURE_LENGTH);
+                return {
+                    base58Address: base58Addr,
+                    base64Address: base64Addr,
+                    publicKey: pubkey,
+                    signature: index.bufferExports.Buffer.from(signatureBytes).toString('base64'),
+                    messageText,
+                    authToken: authResult.auth_token,
+                    walletUriBase: authResult.wallet_uri_base,
+                };
+            }, this.getAssociationConfig());
+            // Store MWA auth state for reauthorization in subsequent transact() calls
+            this.authToken = result.authToken;
+            this.walletUriBase = result.walletUriBase;
+            this.base64Address = result.base64Address;
+            this.authorizedPublicKey = result.base58Address;
+            this.publicKeyObj = result.publicKey;
+            // Check if we already have a valid session for this address
+            const existingSession = await index_native.WebSessionManager.getSession();
+            if (existingSession && existingSession.address === result.base58Address) {
+                const user = { provider: this, address: result.base58Address };
+                index_native.setCurrentUser(user);
+                return user;
+            }
+            // Create new session on the server
+            const createSessionResult = await index_native.createSessionWithSignature(result.base58Address, result.messageText, result.signature);
+            await index_native.WebSessionManager.storeSession(result.base58Address, createSessionResult.accessToken, createSessionResult.idToken, createSessionResult.refreshToken);
+            // Mark auth method
+            try {
+                index_native.getPlatform().storage.setItem('tarobase_last_auth_method', 'mobile-wallet-adapter');
+            }
+            catch (_f) { }
+            const user = { provider: this, address: result.base58Address };
+            index_native.setCurrentUser(user);
+            return user;
+        }
+        catch (error) {
+            const isUserRejection = (error === null || error === void 0 ? void 0 : error.code) === 4001 ||
+                ((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes('user rejected')) ||
+                ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.toLowerCase().includes('user denied')) ||
+                ((_c = error === null || error === void 0 ? void 0 : error.message) === null || _c === void 0 ? void 0 : _c.toLowerCase().includes('user cancelled')) ||
+                ((_d = error === null || error === void 0 ? void 0 : error.message) === null || _d === void 0 ? void 0 : _d.toLowerCase().includes('user canceled')) ||
+                ((_e = error === null || error === void 0 ? void 0 : error.message) === null || _e === void 0 ? void 0 : _e.toLowerCase().includes('user declined'));
+            if (!isUserRejection) {
+                console.error('[SolanaMobileWallet] Login failed:', error);
+            }
+            throw error;
+        }
+        finally {
+            index_native.setAuthLoading(false);
+        }
+    }
+    async restoreSession() {
+        const session = await index_native.WebSessionManager.getSession();
+        if (session) {
+            this.authorizedPublicKey = session.address;
+            this.publicKeyObj = new web3_js.PublicKey(session.address);
+            return { provider: this, address: session.address };
+        }
+        return null;
+    }
+    async logout() {
+        // Deauthorize with the wallet if we have an auth_token
+        if (this.authToken) {
+            try {
+                await loadMwaProtocol();
+                const { transact } = mwaProtocolModule;
+                const authToken = this.authToken;
+                await transact(async (wallet) => {
+                    await wallet.deauthorize({ auth_token: authToken });
+                }, this.getAssociationConfig());
+            }
+            catch (error) {
+                console.error('[SolanaMobileWallet] Deauthorize error:', error);
+            }
+        }
+        this.authToken = null;
+        this.walletUriBase = null;
+        this.base64Address = null;
+        this.authorizedPublicKey = null;
+        this.publicKeyObj = null;
+        index_native.WebSessionManager.clearSession();
+        index_native.setCurrentUser(null);
+    }
+    async signMessage(message) {
+        var _a, _b;
+        if (!this.authorizedPublicKey || !this.base64Address) {
+            throw new Error('Not connected. Call login() first.');
+        }
+        await loadMwaProtocol();
+        const { transact } = mwaProtocolModule;
+        const base64Addr = this.base64Address;
+        try {
+            const signedMessages = await transact(async (wallet) => {
+                await this.reauthorizeWallet(wallet);
+                const messageBytes = index_native.getPlatform().textEncode(message);
+                return wallet.signMessages({
+                    addresses: [base64Addr],
+                    payloads: [messageBytes],
+                });
+            }, this.getAssociationConfig());
+            const signedPayload = signedMessages[0];
+            const signatureBytes = signedPayload.slice(-ED25519_SIGNATURE_LENGTH);
+            return index.bufferExports.Buffer.from(signatureBytes).toString('base64');
+        }
+        catch (error) {
+            if (((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('not connected')) || ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.includes('not authorized')) ||
+                (error === null || error === void 0 ? void 0 : error.code) === 'ERROR_AUTHORIZATION_FAILED') {
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+            throw new Error(`Failed to sign message: ${error.message}`);
+        }
+    }
+    async signTransaction(transaction) {
+        var _a, _b;
+        if (!this.publicKeyObj) {
+            throw new Error('Not connected. Call login() first.');
+        }
+        await loadMwaProtocol();
+        const { transact } = mwaProtocolModule;
+        // Ensure blockhash and fee payer are set before signing
+        const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
+        if (isLegacyTransaction) {
+            const legacyTx = transaction;
+            if (!legacyTx.recentBlockhash) {
+                const rpcUrl = this.getRpcUrl();
+                const connection = new web3_js.Connection(rpcUrl, 'confirmed');
+                const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+                legacyTx.recentBlockhash = blockhash;
+                legacyTx.lastValidBlockHeight = lastValidBlockHeight;
+            }
+            if (!legacyTx.feePayer && this.publicKeyObj) {
+                legacyTx.feePayer = this.publicKeyObj;
+            }
+        }
+        else {
+            const versionedTx = transaction;
+            if (!versionedTx.message.recentBlockhash) {
+                const rpcUrl = this.getRpcUrl();
+                const connection = new web3_js.Connection(rpcUrl, 'confirmed');
+                const { blockhash } = await connection.getLatestBlockhash('confirmed');
+                versionedTx.message.recentBlockhash = blockhash;
+            }
+        }
+        try {
+            const signedTransactions = await transact(async (wallet) => {
+                await this.reauthorizeWallet(wallet);
+                return wallet.signTransactions({ transactions: [transaction] });
+            }, this.getAssociationConfig());
+            return signedTransactions[0];
+        }
+        catch (error) {
+            if (((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('not connected')) || ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.includes('not authorized')) ||
+                (error === null || error === void 0 ? void 0 : error.code) === 'ERROR_AUTHORIZATION_FAILED') {
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+            throw new Error(`Failed to sign transaction: ${error.message}`);
+        }
+    }
+    async signAndSubmitTransaction(transaction, feePayer) {
+        var _a, _b, _c, _d, _e, _f;
+        if (!this.publicKeyObj) {
+            throw new Error('Not connected. Call login() first.');
+        }
+        await loadMwaProtocol();
+        const { transact } = mwaProtocolModule;
+        const rpcUrl = this.getRpcUrl();
+        const connection = new web3_js.Connection(rpcUrl, 'confirmed');
+        const isSurfnet = rpcUrl === index_native.SURFNET_RPC_URL;
+        try {
+            const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+            const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
+            if (isLegacyTransaction) {
+                const legacyTx = transaction;
+                legacyTx.recentBlockhash = blockhash;
+                legacyTx.lastValidBlockHeight = lastValidBlockHeight;
+                if (!legacyTx.feePayer) {
+                    if (feePayer) {
+                        legacyTx.feePayer = feePayer;
+                    }
+                    else if (this.publicKeyObj) {
+                        legacyTx.feePayer = this.publicKeyObj;
+                    }
+                }
+            }
+            else {
+                const versionedTx = transaction;
+                versionedTx.message.recentBlockhash = blockhash;
+            }
+            if (isSurfnet) {
+                // Surfnet: sign-only, then submit to our specific RPC
+                const signedTransactions = await transact(async (wallet) => {
+                    await this.reauthorizeWallet(wallet);
+                    return wallet.signTransactions({ transactions: [transaction] });
+                }, this.getAssociationConfig());
+                const signedTx = signedTransactions[0];
+                const signature = await connection.sendRawTransaction(signedTx.serialize(), {
+                    preflightCommitment: 'confirmed'
+                });
+                const confirmation = await connection.confirmTransaction({
+                    signature,
+                    blockhash,
+                    lastValidBlockHeight,
+                }, 'confirmed');
+                if (confirmation.value.err) {
+                    throw new Error(`Transaction failed: ${confirmation.value.err.toString()}`);
+                }
+                return signature;
+            }
+            // Non-surfnet: use signAndSendTransactions for wallet-optimized submission
+            const signatures = await transact(async (wallet) => {
+                await this.reauthorizeWallet(wallet);
+                return wallet.signAndSendTransactions({
+                    transactions: [transaction],
+                    commitment: 'confirmed',
+                });
+            }, this.getAssociationConfig());
+            const signature = signatures[0];
+            await index_native.confirmAndCheckTransaction(connection, signature);
+            return signature;
+        }
+        catch (error) {
+            if (((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('not connected')) || ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.includes('not authorized')) ||
+                (error === null || error === void 0 ? void 0 : error.code) === 'ERROR_AUTHORIZATION_FAILED') {
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+            const isUserRejection = (error === null || error === void 0 ? void 0 : error.code) === 4001 ||
+                ((_c = error === null || error === void 0 ? void 0 : error.message) === null || _c === void 0 ? void 0 : _c.toLowerCase().includes('user rejected')) ||
+                ((_d = error === null || error === void 0 ? void 0 : error.message) === null || _d === void 0 ? void 0 : _d.toLowerCase().includes('user denied')) ||
+                ((_e = error === null || error === void 0 ? void 0 : error.message) === null || _e === void 0 ? void 0 : _e.toLowerCase().includes('user cancelled')) ||
+                ((_f = error === null || error === void 0 ? void 0 : error.message) === null || _f === void 0 ? void 0 : _f.toLowerCase().includes('user canceled'));
+            if (!isUserRejection) {
+                console.error('[SolanaMobileWallet] Transaction failed:', error);
+            }
+            throw new Error(`Failed to execute transaction: ${error.message}`);
+        }
+    }
+    async runTransaction(_evmTransactionData, solTransactionData, options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (!solTransactionData) {
+            throw new Error('Solana transaction data is required for mobile wallet');
+        }
+        if (!this.publicKeyObj || !this.authorizedPublicKey) {
+            await this.login();
+        }
+        await loadMwaProtocol();
+        const { transact } = mwaProtocolModule;
+        const rpcUrl = this.getRpcUrl(solTransactionData.network);
+        const connection = new web3_js.Connection(rpcUrl, 'confirmed');
+        const isSurfnet = rpcUrl === index_native.SURFNET_RPC_URL;
+        try {
+            const publicKey = this.publicKeyObj;
+            const remainingAccounts = index_native.convertRemainingAccounts(solTransactionData.txArgs[0].remainingAccounts);
+            let app_id = solTransactionData.appId;
+            if (typeof window !== 'undefined' && window.CUSTOM_TAROBASE_APP_ID_HEADER) {
+                app_id = window.CUSTOM_TAROBASE_APP_ID_HEADER;
+            }
+            if (!app_id) {
+                throw new Error('App ID is required');
+            }
+            // Create a mock wallet adapter for Anchor (only publicKey is needed for building TX)
+            const mockWalletAdapter = {
+                publicKey,
+                signTransaction: async (tx) => tx,
+                signAllTransactions: async (txs) => txs,
+            };
+            const anchorProvider = new anchor__namespace.AnchorProvider(connection, mockWalletAdapter, anchor__namespace.AnchorProvider.defaultOptions());
+            const finalDeduped = [];
+            for (const acc of remainingAccounts) {
+                const existing = finalDeduped.find((d) => d.pubkey.equals(acc.pubkey));
+                if (existing) {
+                    existing.isSigner = existing.isSigner || acc.isSigner;
+                    existing.isWritable = existing.isWritable || acc.isWritable;
+                }
+                else {
+                    finalDeduped.push(acc);
+                }
+            }
+            let tx;
+            if (solTransactionData.signedTransaction) {
+                tx = web3_js.VersionedTransaction.deserialize(index.bufferExports.Buffer.from(solTransactionData.signedTransaction, 'base64'));
+            }
+            else {
+                const result = await index_native.buildSetDocumentsTransaction(connection, solTransactionData.txArgs[0].idl, anchorProvider, publicKey, {
+                    app_id,
+                    documents: solTransactionData.txArgs[0].setDocumentData,
+                    delete_paths: solTransactionData.txArgs[0].deletePaths,
+                    txData: solTransactionData.txArgs[0].txData
+                }, finalDeduped, solTransactionData.lutKey, solTransactionData.preInstructions, false);
+                tx = result.tx;
+            }
+            if ((options === null || options === void 0 ? void 0 : options.shouldSubmitTx) === false) {
+                const [signedTx] = await transact(async (wallet) => {
+                    await this.reauthorizeWallet(wallet);
+                    return wallet.signTransactions({ transactions: [tx] });
+                }, this.getAssociationConfig());
+                return {
+                    signedTransaction: signedTx,
+                    blockNumber: 0,
+                    gasUsed: '0',
+                    data: ''
+                };
+            }
+            if (isSurfnet) {
+                // Surfnet: sign then submit manually to our RPC
+                const [signedTx] = await transact(async (wallet) => {
+                    await this.reauthorizeWallet(wallet);
+                    return wallet.signTransactions({ transactions: [tx] });
+                }, this.getAssociationConfig());
+                const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+                const signature = await connection.sendRawTransaction(signedTx.serialize(), {
+                    preflightCommitment: 'confirmed'
+                });
+                const confirmation = await connection.confirmTransaction({
+                    signature,
+                    blockhash,
+                    lastValidBlockHeight,
+                }, 'confirmed');
+                if (confirmation.value.err) {
+                    throw new Error(`Transaction failed: ${confirmation.value.err.toString()}`);
+                }
+                const txInfo = await connection.getParsedTransaction(signature, {
+                    maxSupportedTransactionVersion: 0,
+                    commitment: 'confirmed'
+                });
+                return {
+                    transactionSignature: signature,
+                    blockNumber: (txInfo === null || txInfo === void 0 ? void 0 : txInfo.slot) || 0,
+                    gasUsed: ((_a = txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta) === null || _a === void 0 ? void 0 : _a.fee.toString()) || '0',
+                    data: txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta,
+                };
+            }
+            // Non-surfnet: use signAndSendTransactions
+            const signatures = await transact(async (wallet) => {
+                await this.reauthorizeWallet(wallet);
+                return wallet.signAndSendTransactions({
+                    transactions: [tx],
+                    commitment: 'confirmed',
+                });
+            }, this.getAssociationConfig());
+            const signature = signatures[0];
+            const txInfo = await index_native.confirmAndCheckTransaction(connection, signature);
+            return {
+                transactionSignature: signature,
+                blockNumber: (txInfo === null || txInfo === void 0 ? void 0 : txInfo.slot) || 0,
+                gasUsed: ((_b = txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta) === null || _b === void 0 ? void 0 : _b.fee.toString()) || '0',
+                data: txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta,
+            };
+        }
+        catch (error) {
+            if (((_c = error === null || error === void 0 ? void 0 : error.message) === null || _c === void 0 ? void 0 : _c.includes('not connected')) || ((_d = error === null || error === void 0 ? void 0 : error.message) === null || _d === void 0 ? void 0 : _d.includes('not authorized')) ||
+                (error === null || error === void 0 ? void 0 : error.code) === 'ERROR_AUTHORIZATION_FAILED') {
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+            const isUserRejection = (error === null || error === void 0 ? void 0 : error.code) === 4001 ||
+                ((_e = error === null || error === void 0 ? void 0 : error.message) === null || _e === void 0 ? void 0 : _e.toLowerCase().includes('user rejected')) ||
+                ((_f = error === null || error === void 0 ? void 0 : error.message) === null || _f === void 0 ? void 0 : _f.toLowerCase().includes('user denied')) ||
+                ((_g = error === null || error === void 0 ? void 0 : error.message) === null || _g === void 0 ? void 0 : _g.toLowerCase().includes('user cancelled')) ||
+                ((_h = error === null || error === void 0 ? void 0 : error.message) === null || _h === void 0 ? void 0 : _h.toLowerCase().includes('user canceled'));
+            if (!isUserRejection) {
+                console.error('[SolanaMobileWallet] Transaction failed:', error);
+            }
+            throw new Error(`Failed to execute transaction: ${error.message}`);
+        }
+    }
+    async getNativeMethods() {
+        return {
+            authToken: this.authToken,
+            walletUriBase: this.walletUriBase,
+            publicKey: this.publicKeyObj,
+            base64Address: this.base64Address,
+        };
+    }
+    /* ----------------------------------------------------------- *
+     * Private Helpers
+     * ----------------------------------------------------------- */
+    getRpcUrl(network) {
+        if (this.networkUrl) {
+            return this.networkUrl;
+        }
+        if (network === 'solana_devnet') {
+            return index_native.SOLANA_DEVNET_RPC_URL;
+        }
+        else if (network === 'solana_mainnet') {
+            return index_native.SOLANA_MAINNET_RPC_URL;
+        }
+        else if (network === 'surfnet') {
+            return index_native.SURFNET_RPC_URL;
+        }
+        return index_native.SOLANA_MAINNET_RPC_URL;
+    }
+}
+SolanaMobileWalletProvider.instance = null;
+
+exports.SolanaMobileWalletProvider = SolanaMobileWalletProvider;
+//# sourceMappingURL=solana-mobile-wallet-provider-DDqwl25J.js.map

package/dist/solana-mobile-wallet-provider-DDqwl25J.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solana-mobile-wallet-provider-DDqwl25J.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,12 +1,19 @@
 {
     "name": "@pooflabs/web",
-    "version": "0.0.73",
+    "version": "0.0.74",
     "description": "JavaScript SDK for Tarobase API",
     "main": "./dist/index.js",
+    "react-native": "./dist/index.native.js",
     "module": "./dist/index.esm.js",
     "types": "./dist/index.d.ts",
     "exports": {
         ".": {
+            "react-native": {
+                "types": "./dist/index.native.d.ts",
+                "import": "./dist/index.native.esm.js",
+                "require": "./dist/index.native.js",
+                "default": "./dist/index.native.js"
+            },
             "types": "./dist/index.d.ts",
             "import": "./dist/index.esm.js",
             "require": "./dist/index.js",
@@ -32,7 +39,16 @@
     "license": "MIT",
     "peerDependencies": {
         "react": "^18 || ^19",
-        "react-dom": "^18 || ^19"
+        "react-dom": "^18 || ^19",
+        "react-native": ">=0.70"
+    },
+    "peerDependenciesMeta": {
+        "react-dom": {
+            "optional": true
+        },
+        "react-native": {
+            "optional": true
+        }
     },
     "devDependencies": {
         "@rollup/plugin-commonjs": "^28.0.1",
@@ -52,7 +68,7 @@
     "dependencies": {
         "@coral-xyz/anchor": "^0.31.1",
         "@phantom/react-sdk": "^1.0.2",
-        "@pooflabs/core": "0.0.38",
+        "@pooflabs/core": "0.0.40",
         "@privy-io/react-auth": "^3.10.1",
         "@solana-mobile/mobile-wallet-adapter-protocol-web3js": "^2.1.0",
         "@solana-mobile/wallet-adapter-mobile": "^2.0.0",