@pooflabs/web 0.0.73 → 0.0.74

package/dist/solana-mobile-wallet-provider-BZMvp9Qy.esm.js

@@ -0,0 +1,558 @@
+import { b as bufferExports } from './index-CrOVJFX9.esm.js';
+import { g as getPlatform, i as setAuthLoading, W as WebSessionManager, s as setCurrentUser, j as genAuthNonce, k as genSolanaMessage, l as createSessionWithSignature, e as confirmAndCheckTransaction, c as convertRemainingAccounts, b as buildSetDocumentsTransaction, a as SOLANA_DEVNET_RPC_URL, S as SOLANA_MAINNET_RPC_URL, h as SURFNET_RPC_URL } from './index.native-CzfZTw_J.esm.js';
+import { PublicKey, Connection, VersionedTransaction } from '@solana/web3.js';
+import * as anchor from '@coral-xyz/anchor';
+import 'axios';
+import 'react';
+
+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 import('./index.browser-D63nJFKg.esm.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: 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(getPlatform().atob(account.address), c => c.charCodeAt(0));
+            this.publicKeyObj = new PublicKey(addressBytes);
+            this.authorizedPublicKey = this.publicKeyObj.toBase58();
+        }
+    }
+    async login() {
+        var _a, _b, _c, _d, _e;
+        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 WebSessionManager.getSession();
+                if (existingSession && existingSession.address === this.authorizedPublicKey) {
+                    const user = { provider: this, address: this.authorizedPublicKey };
+                    setCurrentUser(user);
+                    return user;
+                }
+            }
+            // Pre-fetch nonce from server while wallet is not yet connected
+            const nonce = await 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(getPlatform().atob(base64Addr), c => c.charCodeAt(0));
+                const pubkey = new PublicKey(addressBytes);
+                const base58Addr = pubkey.toBase58();
+                // Step 2: Sign the auth message — still in the same wallet session
+                const messageText = await genSolanaMessage(base58Addr, nonce);
+                const messageBytes = 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: 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 WebSessionManager.getSession();
+            if (existingSession && existingSession.address === result.base58Address) {
+                const user = { provider: this, address: result.base58Address };
+                setCurrentUser(user);
+                return user;
+            }
+            // Create new session on the server
+            const createSessionResult = await createSessionWithSignature(result.base58Address, result.messageText, result.signature);
+            await WebSessionManager.storeSession(result.base58Address, createSessionResult.accessToken, createSessionResult.idToken, createSessionResult.refreshToken);
+            // Mark auth method
+            try {
+                getPlatform().storage.setItem('tarobase_last_auth_method', 'mobile-wallet-adapter');
+            }
+            catch (_f) { }
+            const user = { provider: this, address: result.base58Address };
+            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 {
+            setAuthLoading(false);
+        }
+    }
+    async restoreSession() {
+        const session = await WebSessionManager.getSession();
+        if (session) {
+            this.authorizedPublicKey = session.address;
+            this.publicKeyObj = new 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;
+        WebSessionManager.clearSession();
+        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 = getPlatform().textEncode(message);
+                return wallet.signMessages({
+                    addresses: [base64Addr],
+                    payloads: [messageBytes],
+                });
+            }, this.getAssociationConfig());
+            const signedPayload = signedMessages[0];
+            const signatureBytes = signedPayload.slice(-ED25519_SIGNATURE_LENGTH);
+            return 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 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 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 Connection(rpcUrl, 'confirmed');
+        const isSurfnet = rpcUrl === 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 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 Connection(rpcUrl, 'confirmed');
+        const isSurfnet = rpcUrl === SURFNET_RPC_URL;
+        try {
+            const publicKey = this.publicKeyObj;
+            const remainingAccounts = 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.AnchorProvider(connection, mockWalletAdapter, anchor.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 = VersionedTransaction.deserialize(bufferExports.Buffer.from(solTransactionData.signedTransaction, 'base64'));
+            }
+            else {
+                const result = await 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 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 SOLANA_DEVNET_RPC_URL;
+        }
+        else if (network === 'solana_mainnet') {
+            return SOLANA_MAINNET_RPC_URL;
+        }
+        else if (network === 'surfnet') {
+            return SURFNET_RPC_URL;
+        }
+        return SOLANA_MAINNET_RPC_URL;
+    }
+}
+SolanaMobileWalletProvider.instance = null;
+
+export { SolanaMobileWalletProvider };
+//# sourceMappingURL=solana-mobile-wallet-provider-BZMvp9Qy.esm.js.map

package/dist/solana-mobile-wallet-provider-BZMvp9Qy.esm.js.map

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