@bounded-sh/client 0.0.118-openapps.0 → 0.0.119

package/dist/{index-q9BHoxbM.mjs → index-BaXUWG8Q.mjs}

@@ -1,4 +1,4 @@
-import { getConfig, getActiveSessionManager, WebSessionManager, ReactNativeSessionManager, revokeSession, reconnectWithNewAuth, deriveUserIdentityFromIdToken, init as init$2, onSessionCleared, onSessionChange, subscribe, getFreshAuthToken, getSessionGeneration, getIdToken as getIdToken$1, getConfiguredAppId, setWithVenueGrant, writeNotAppliedPhase, waitForSetResult, reconcileSetResult, resolveVenueRpcUrl, genAuthNonce, genSolanaMessage, createSessionWithSignature } from '@bounded-sh/core';
+import { getConfig, getActiveSessionManager, confirmSignature, WebSessionManager, ReactNativeSessionManager, revokeSession, reconnectWithNewAuth, deriveUserIdentityFromIdToken, init as init$2, onSessionCleared, onSessionChange, subscribe, getFreshAuthToken, getSessionGeneration, getIdToken as getIdToken$1, getConfiguredAppId, setWithVenueGrant, writeNotAppliedPhase, waitForSetResult, reconcileSetResult, resolveVenueRpcUrl, genAuthNonce, genSolanaMessage, createSessionWithSignature } from '@bounded-sh/core';
 import * as React from 'react';
 
 function walletContextFromClaims(claims, baseUrl, expectedAppId, tenantOrigin) {
@@ -274,6 +274,10 @@ class OffchainAuthProvider {
     async signTransaction(tx) {
         return this.wrappedProvider.signTransaction(tx);
     }
+    async prepareToSign() {
+        var _a, _b, _c;
+        return (_c = (await ((_b = (_a = this.wrappedProvider).prepareToSign) === null || _b === void 0 ? void 0 : _b.call(_a)))) !== null && _c !== void 0 ? _c : 'ready';
+    }
     /**
      * Sign and submit transaction - not supported in poofnet environment.
      * See the real providers (PhantomWalletProvider, SolanaKeypairProvider)
@@ -4369,7 +4373,7 @@ async function runWidget(url, signerOrigin, ex, popupFallback) {
     const requestId = String(ex.request.requestId);
     // Serialize: the approve card is modal, and one warm frame handles one request at a time.
     const run = m.chain.then(() => new Promise((resolve, reject) => {
-        var _a;
+        var _a, _b;
         let settled = false;
         let usedFallback = false;
         (_a = ex.assertCurrent) === null || _a === void 0 ? void 0 : _a.call(ex);
@@ -4412,16 +4416,20 @@ async function runWidget(url, signerOrigin, ex, popupFallback) {
                 /* frame gone */
             }
         };
+        const dismiss = () => {
+            if (!ex.silent)
+                hideModal(m);
+        };
         const goFallback = () => {
             if (usedFallback || settled)
                 return;
             usedFallback = true;
-            hideModal(m);
+            dismiss();
             finish(() => popupFallback().then(resolve, reject));
         };
         m.onBackdrop = () => {
             cancelInFrame();
-            hideModal(m);
+            dismiss();
             finish(() => reject(new Error("cancelled")));
         };
         m.onIframeMessage = (d) => {
@@ -4436,17 +4444,18 @@ async function runWidget(url, signerOrigin, ex, popupFallback) {
             if (d.type === "bounded:turnkey:result" && d.requestId === requestId) {
                 const outcome = ex.onResult(d);
                 if ("error" in outcome) {
-                    hideModal(m);
+                    dismiss();
                     finish(() => reject(new Error(outcome.error)));
                     return;
                 }
                 if (outcome.done) {
-                    hideModal(m);
+                    dismiss();
                     finish(() => resolve(outcome.value));
                 }
             }
         };
-        showModal(m);
+        if (!ex.silent)
+            showModal(m);
         if (m.iframeReady)
             send();
         // If the frame never loads, degrade to the popup (best-effort - a post-load
@@ -4459,10 +4468,10 @@ async function runWidget(url, signerOrigin, ex, popupFallback) {
         ceilingTimer = window.setTimeout(() => {
             if (!settled) {
                 cancelInFrame();
-                hideModal(m);
+                dismiss();
                 finish(() => reject(new Error("Wallet approval timed out.")));
             }
-        }, 5 * 60 * 1000);
+        }, (_b = ex.ceilingMs) !== null && _b !== void 0 ? _b : 5 * 60 * 1000);
     }));
     m.chain = run.then(() => undefined, () => undefined);
     return run;
@@ -5044,6 +5053,59 @@ async function clearTurnkeySigningSession(idToken) {
 function hasTurnkeyWallet() {
     return activeTurnkeyAddress() !== null;
 }
+/** The signer frame could not take the exchange: it never loaded, or a page from before the request existed stays silent. */
+class SignerFrameUnavailable extends Error {
+    constructor() { super('The Bounded signer frame did not answer.'); }
+}
+/** How long a silent session probe may wait for the frame before the write goes on without it. */
+const SESSION_PROBE_MS = 8000;
+/**
+ * Make the wallet's 24-hour signing session live BEFORE a transaction exists. Without one the
+ * approve card must first collect an emailed code, which takes longer than a transaction's
+ * blockhash lifetime (about 33 seconds on mainnet in late 2026), so a transaction built before
+ * the code is dead by the time it is signed. A live session is found with nothing shown: the
+ * warm frame answers a silent probe, and it holds the session even where the browser blocks its
+ * storage. Only a lapsed session opens the card, which runs the code ceremony and closes without
+ * signing anything. Resolves `'established'` when that ceremony ran, else `'ready'`.
+ *
+ * Both exchanges run in the warm frame only, since it is the frame that signs next and a popup
+ * keeps its session to itself. Where the frame cannot answer (an embedder that blocks it, or a
+ * signer page from before this request existed), the write goes on the way it always did: the
+ * approve card collects the code itself, and an expired build is built again.
+ */
+async function ensureTurnkeySigningSession() {
+    if (!hasDOM$3())
+        throw new Error('Turnkey embedded-wallet signing is only available in the browser (trusted wallet UI).');
+    const context = await turnkeySignerPage();
+    context.assertCurrent();
+    if (hasWarmSignerFrame(context.key) && walletSessionState(context.key).status === 'ready')
+        return 'ready';
+    const { url, origin } = context;
+    const authorization = await fetchActionAuthorization('createWallet', context);
+    const frameOnly = () => Promise.reject(new SignerFrameUnavailable());
+    const exchange = (probeOnly) => ({
+        context: context.key, assertCurrent: context.assertCurrent,
+        request: Object.assign({ type: 'bounded:turnkey:session', requestId: `tksession_${Date.now()}_${++requestSeq}`, authorization }, (probeOnly ? { probeOnly: true } : {})),
+        onResult: (d) => d.ok ? { done: true, value: d } : { error: String(d.error || 'The signing session could not be established') },
+    });
+    const probed = await runWidget(url, origin, Object.assign(Object.assign({}, exchange(true)), { silent: true, ceilingMs: SESSION_PROBE_MS }), frameOnly)
+        .catch(() => null);
+    if (!probed)
+        return 'ready';
+    let result = probed;
+    if (result.ready !== true) {
+        try {
+            result = await runWidget(url, origin, exchange(false), frameOnly);
+        }
+        catch (error) {
+            if (error instanceof SignerFrameUnavailable)
+                return 'ready';
+            throw error;
+        }
+    }
+    setWalletSessionState(context.key, { status: 'ready', expiresAt: Number(result.signingSessionExpiresAt) });
+    return result.established === true ? 'established' : 'ready';
+}
 /**
  * Get-or-create the user's non-custodial Turnkey wallet, resolving with its stable
  * Solana address. Creation never prompts: on first use the signer silently provisions
@@ -5232,10 +5294,9 @@ async function signAndSubmitTransactionWithTurnkey(transaction, feePayer) {
     // has signed silently invalidates their signature - signTransactionWithTurnkey only ADDS the
     // Turnkey signature, it never re-signs the others. So only refresh the blockhash while the
     // transaction is still unsigned; once a real signature is present, preserve the caller's message
-    // verbatim and confirm against the blockhash it already carries.
-    const hasSignature = transactionHasSignature$1(transaction);
-    let confirmBlockhash = blockhash;
-    if (!hasSignature) {
+    // verbatim. The confirmation is fenced on the lifetime read above either way: for a pre-signed
+    // transaction that is a superset of the one its signers fenced on, never a shorter wait.
+    if (!transactionHasSignature$1(transaction)) {
         if (isLegacy) {
             const legacy = transaction;
             legacy.recentBlockhash = blockhash;
@@ -5251,19 +5312,17 @@ async function signAndSubmitTransactionWithTurnkey(transaction, feePayer) {
             transaction.message.recentBlockhash = blockhash;
         }
     }
-    else {
-        confirmBlockhash = (isLegacy
-            ? transaction.recentBlockhash
-            : transaction.message.recentBlockhash) || blockhash;
-    }
     const signed = await signTransactionWithTurnkey(transaction);
     const signature = await connection.sendRawTransaction(signed.serialize(), {
         skipPreflight: false,
         maxRetries: 3,
     });
-    const confirmation = await connection.confirmTransaction({ signature, blockhash: confirmBlockhash, lastValidBlockHeight }, 'confirmed');
-    if (confirmation.value.err) {
-        throw new Error(`Turnkey transaction failed: ${JSON.stringify(confirmation.value.err)}`);
+    const confirmation = await confirmSignature(connection, { signature, lastValidBlockHeight });
+    if (!confirmation.landed) {
+        throw new Error(`Turnkey transaction ${signature} was not confirmed: ${confirmation.reason}. Check its status before sending it again.`);
+    }
+    if (confirmation.status.err) {
+        throw new Error(`Turnkey transaction failed: ${JSON.stringify(confirmation.status.err)}`);
     }
     return signature;
 }
@@ -5279,6 +5338,7 @@ async function getTurnkeyWalletRecoveryUrl() {
 var turnkeySignerBridge = /*#__PURE__*/Object.freeze({
     __proto__: null,
     clearTurnkeySigningSession: clearTurnkeySigningSession,
+    ensureTurnkeySigningSession: ensureTurnkeySigningSession,
     getOrCreateTurnkeyWallet: getOrCreateTurnkeyWallet,
     getTurnkeyWalletRecoveryUrl: getTurnkeyWalletRecoveryUrl,
     getTurnkeyWalletSessionState: getTurnkeyWalletSessionState,
@@ -5362,6 +5422,11 @@ const oidcProviderSingleton = {
             throw new Error(OIDC_NO_WALLET);
         return signTransactionV1WithTurnkey(transaction);
     },
+    async prepareToSign() {
+        if (!hasTurnkeyWallet())
+            throw new Error(OIDC_NO_WALLET);
+        return ensureTurnkeySigningSession();
+    },
     supportedTransactionVersions() {
         return hasTurnkeyWallet() ? ['legacy', 0, 1] : ['legacy', 0];
     },
@@ -6475,7 +6540,7 @@ async function getAuthProvider(config, fromStorage = false) {
             // manager as legacy email sessions. Human login should be started
             // with loginWithRedirect(); this provider is kept as the restore and
             // logout surface for those sessions.
-            currentAuthProvider = new (await import('./email-auth-provider-C-SGTRZe.mjs')).EmailAuthProvider();
+            currentAuthProvider = new (await import('./email-auth-provider-DHq5_wtn.mjs')).EmailAuthProvider();
             break;
         case "phantom": {
             // First-class Solana WALLET LOGIN (the poof/TaroBase-style "connect
@@ -6517,7 +6582,7 @@ async function getAuthProvider(config, fromStorage = false) {
             // (bounded-login-widget.ts), so registration never counts as
             // evidence the user has a wallet.
             await ensureSolanaMobileWalletRegistered(config, configuredNetwork);
-            const { InjectedWalletProvider } = await import('./injected-wallet-provider-gmGZ254w.mjs');
+            const { InjectedWalletProvider } = await import('./injected-wallet-provider-jj9dqm2Z.mjs');
             currentAuthProvider = new InjectedWalletProvider(resolveInjectedWalletConfig(config), rpcUrl, configuredNetwork);
             break;
         }
@@ -6530,7 +6595,7 @@ async function getAuthProvider(config, fromStorage = false) {
             // Selecting authMethod:'evm-wallet' IS the opt-in — pass evmWalletConfig
             // to point at a specific wallet or set chainId/domain.
             const evmWalletConfig = ((_a = config.evmWalletConfig) !== null && _a !== void 0 ? _a : {});
-            const { InjectedEvmWalletProvider } = await import('./injected-evm-wallet-provider-AXc7Lmzk.mjs');
+            const { InjectedEvmWalletProvider } = await import('./injected-evm-wallet-provider-B4Kr6lnK.mjs');
             currentAuthProvider = new InjectedEvmWalletProvider(evmWalletConfig);
             break;
         }
@@ -6555,7 +6620,7 @@ async function getAuthProvider(config, fromStorage = false) {
             break;
         case "guest":
             // Anonymous auth: a device-local ed25519 keypair signs the challenge.
-            currentAuthProvider = new (await import('./guest-auth-provider-BwEXKnNK.mjs')).GuestAuthProvider();
+            currentAuthProvider = new (await import('./guest-auth-provider-DyP5UUg6.mjs')).GuestAuthProvider();
             break;
     }
     if (!currentAuthProvider) {
@@ -6617,7 +6682,7 @@ async function signInAnonymously() {
     // Lazy-load the guest provider so its ed25519/web3 dependencies stay out of
     // the main bundle for data-only apps. Specifier is a static string literal
     // so bundle-splitting can see it.
-    const provider = new (await import('./guest-auth-provider-BwEXKnNK.mjs')).GuestAuthProvider();
+    const provider = new (await import('./guest-auth-provider-DyP5UUg6.mjs')).GuestAuthProvider();
     setAuthLoading(true); // reflect "signing in…" while the guest keypair session is minted
     // adoptSessionProvider awaits only getConfig() (already resolved here) and then
     // runs every write - provider/method/config/marker/user - in one synchronous
@@ -6788,7 +6853,7 @@ function ensureSharedWalletLoginReady() {
     if (!sharedWalletReady) {
         sharedWalletReady = (async () => {
             await getConfig();
-            await import('./injected-wallet-provider-gmGZ254w.mjs');
+            await import('./injected-wallet-provider-jj9dqm2Z.mjs');
         })().catch((error) => {
             sharedWalletReady = null;
             throw error;
@@ -6893,7 +6958,7 @@ async function loginWithWallet(options) {
         await ensureSharedWalletLoginReady();
     else
         await ensureWalletLoginReady();
-    const { InjectedWalletProvider } = await import('./injected-wallet-provider-gmGZ254w.mjs');
+    const { InjectedWalletProvider } = await import('./injected-wallet-provider-jj9dqm2Z.mjs');
     // Keep the RAW wallet provider: the offchain wrapper forwards only a fixed
     // set of methods, so cleanup below must speak to the provider that actually
     // holds the config rather than to whatever is wrapping it.
@@ -11556,35 +11621,29 @@ async function getParsedTransactionCompat(connection, signature) {
     }
 }
 /**
- * Polls getSignatureStatuses until the transaction is confirmed, then checks for errors.
- * Throws if the transaction failed on-chain. Returns parsed transaction info on success.
+ * Waits for a broadcast signature by HTTPS status polling, fenced on the blockhash
+ * lifetime it was signed against (core's `confirmSignature`), then checks for an
+ * on-chain error. Throws if the transaction failed on-chain or was not seen before
+ * the fence closed. Returns parsed transaction info on success.
  */
-async function confirmAndCheckTransaction(connection, signature) {
+async function confirmAndCheckTransaction(connection, signature, lastValidBlockHeight) {
     var _a;
-    const maxAttempts = 15;
-    for (let i = 0; i < maxAttempts; i++) {
-        const { value } = await connection.getSignatureStatuses([signature]);
-        const status = value[0];
-        if (status) {
-            if (status.err) {
-                let logMessages;
-                try {
-                    const txInfo = await getParsedTransactionCompat(connection, signature);
-                    logMessages = (_a = txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta) === null || _a === void 0 ? void 0 : _a.logMessages;
-                }
-                catch (_b) {
-                    // Log retrieval is diagnostic only; the on-chain error is the verdict.
-                }
-                const errorMessage = extractTransactionError(status.err, logMessages);
-                throw new Error(`Transaction failed: ${errorMessage}`);
-            }
-            if (status.confirmationStatus === 'confirmed' || status.confirmationStatus === 'finalized') {
-                return await getParsedTransactionCompat(connection, signature);
-            }
+    const confirmation = await confirmSignature(connection, { signature, lastValidBlockHeight });
+    if (!confirmation.landed) {
+        throw new Error(`Transaction ${signature} was not confirmed: ${confirmation.reason}. Check its status before sending it again.`);
+    }
+    if (confirmation.status.err) {
+        let logMessages;
+        try {
+            const txInfo = await getParsedTransactionCompat(connection, signature);
+            logMessages = (_a = txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta) === null || _a === void 0 ? void 0 : _a.logMessages;
         }
-        await new Promise(resolve => setTimeout(resolve, 1000));
+        catch (_b) {
+            // Log retrieval is diagnostic only; the on-chain error is the verdict.
+        }
+        throw new Error(`Transaction failed: ${extractTransactionError(confirmation.status.err, logMessages)}`);
     }
-    throw new Error('Transaction confirmation timeout');
+    return getParsedTransactionCompat(connection, signature);
 }
 
 /**
@@ -11754,24 +11813,30 @@ class PrivyExpoProvider {
         // included), so refreshing the blockhash after any signer (sponsor / co-signer)
         // has signed silently invalidates their signature. Only refresh while the
         // transaction is still unsigned; once a real signature is present, submit the
-        // caller's transaction verbatim.
+        // caller's transaction verbatim. Either way the confirmation is fenced on a
+        // lifetime read now: for a pre-signed transaction that is a superset of the
+        // one its signers fenced on, never a shorter wait.
+        let lastValidBlockHeight;
         if (!transactionHasSignature(transaction)) {
+            const { blockhash, lastValidBlockHeight: freshLastValid } = await connection.getLatestBlockhash('confirmed');
+            lastValidBlockHeight = freshLastValid;
             const isLegacyTx = 'recentBlockhash' in transaction &&
                 !('message' in transaction && 'staticAccountKeys' in transaction.message);
             if (isLegacyTx) {
                 const legacyTx = transaction;
-                const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
                 legacyTx.recentBlockhash = blockhash;
                 legacyTx.lastValidBlockHeight = lastValidBlockHeight;
                 legacyTx.feePayer = feePayer || new PublicKey(wallet.address);
             }
             else {
                 const versionedTx = transaction;
-                const { blockhash } = await connection.getLatestBlockhash('confirmed');
                 versionedTx.message.recentBlockhash = blockhash;
             }
         }
-        const { signature } = await this.signAndSubmitInternal(transaction, wallet, connection);
+        else {
+            ({ lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed'));
+        }
+        const { signature } = await this.signAndSubmitInternal(transaction, wallet, connection, lastValidBlockHeight);
         return signature;
     }
     async restoreSession(beforeCommit) {
@@ -11842,11 +11907,11 @@ class PrivyExpoProvider {
                 `Sign in again before ${action}.`);
         }
     }
-    async signAndSubmitInternal(transaction, wallet, connection) {
+    async signAndSubmitInternal(transaction, wallet, connection, lastValidBlockHeight) {
         // Use Privy's combined sign+send
         const result = await wallet.signAndSendTransaction(transaction, connection);
         const signature = result.signature;
-        const txInfo = await confirmAndCheckTransaction(connection, signature);
+        const txInfo = await confirmAndCheckTransaction(connection, signature, lastValidBlockHeight);
         return { signature, txInfo };
     }
     // The constructor rpcUrl wins, then init()'s rpcUrl, then the platform RPC
@@ -12271,5 +12336,5 @@ function init(config = {}) {
     return init$1(resolved);
 }
 
-export { onramp as $, logout as A, getAuthProvider as B, signInAnonymously as C, loginWithPrivy as D, loginWithWallet as E, ensureWalletLoginReady as F, ensureSharedWalletLoginReady as G, preloadWalletLogin as H, loginWithRedirect as I, completeLoginFromRedirect as J, getLoginReturnError as K, loginWithPopup as L, openBoundedWidget as M, ensureSignedIn as N, useAuth as O, useQuery as P, useBuildRun as Q, apps as R, SELECTED_WALLET_UNAVAILABLE_ERR as S, signSolanaMessageViaTurnkey as T, getOrCreateTurnkeyWallet as U, openTurnkeyKeyExport as V, WalletConfigError as W, getTurnkeyWalletSessionState as X, getTurnkeyWalletRecoveryUrl as Y, startTurnkeyEmailLogin as Z, getIdToken as _, signMessageWithTurnkey as a, onrampQuote as a0, onrampStatus as a1, connect as a2, completeConnection as a3, getConnections as a4, disconnect as a5, ConnectionError as a6, fundVenueEscrow as a7, disputeVenueEscrow as a8, getVenueEscrow as a9, VenueEscrowError as aa, setPlatform as ab, OffchainAuthProvider as ac, PrivyExpoProvider as ad, requestEip6963Providers as ae, connectBroadcast as af, connectServiceSession as ag, builds as ah, BuildsApiError as ai, mediaAgentTools as aj, NON_TERMINAL_STATES as ak, TERMINAL_STATES as al, RUN_STATES as am, PARK_REASONS as an, FAILURE_REASONS as ao, BUILD_REVIEW_CAPABILITY_SCHEMA as ap, BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA as aq, BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA as ar, signTransactionWithTurnkey as b, signTransactionV1WithTurnkey as c, signAndSubmitTransactionWithTurnkey as d, bs58 as e, defaultInjectedProvider as f, getPlatform as g, hasTurnkeyWallet as h, firstStandardWalletProvider as i, setAuthLoading as j, supportsWalletSignIn as k, bufferExports as l, setStoredAuthMethod as m, normalizeSolanaRpcUrl as n, confirmAndCheckTransaction as o, defaultInjectedEvmProvider as p, init as q, resolveSolanaRpcUrl as r, setCurrentUser as s, transactionHasSignature as t, getCurrentUser as u, onAuthStateChanged as v, onAuthLoadingChanged as w, getAuthLoading as x, waitForAuthReady as y, login as z };
-//# sourceMappingURL=index-q9BHoxbM.mjs.map
+export { getIdToken as $, login as A, logout as B, getAuthProvider as C, signInAnonymously as D, loginWithPrivy as E, loginWithWallet as F, ensureWalletLoginReady as G, ensureSharedWalletLoginReady as H, preloadWalletLogin as I, loginWithRedirect as J, completeLoginFromRedirect as K, getLoginReturnError as L, loginWithPopup as M, openBoundedWidget as N, ensureSignedIn as O, useAuth as P, useQuery as Q, useBuildRun as R, SELECTED_WALLET_UNAVAILABLE_ERR as S, apps as T, signSolanaMessageViaTurnkey as U, getOrCreateTurnkeyWallet as V, WalletConfigError as W, openTurnkeyKeyExport as X, getTurnkeyWalletSessionState as Y, getTurnkeyWalletRecoveryUrl as Z, startTurnkeyEmailLogin as _, signMessageWithTurnkey as a, onramp as a0, onrampQuote as a1, onrampStatus as a2, connect as a3, completeConnection as a4, getConnections as a5, disconnect as a6, ConnectionError as a7, fundVenueEscrow as a8, disputeVenueEscrow as a9, getVenueEscrow as aa, VenueEscrowError as ab, setPlatform as ac, OffchainAuthProvider as ad, PrivyExpoProvider as ae, requestEip6963Providers as af, connectBroadcast as ag, connectServiceSession as ah, builds as ai, BuildsApiError as aj, mediaAgentTools as ak, NON_TERMINAL_STATES as al, TERMINAL_STATES as am, RUN_STATES as an, PARK_REASONS as ao, FAILURE_REASONS as ap, BUILD_REVIEW_CAPABILITY_SCHEMA as aq, BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA as ar, BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA as as, signTransactionWithTurnkey as b, signTransactionV1WithTurnkey as c, signAndSubmitTransactionWithTurnkey as d, ensureTurnkeySigningSession as e, bs58 as f, getPlatform as g, hasTurnkeyWallet as h, defaultInjectedProvider as i, firstStandardWalletProvider as j, setAuthLoading as k, supportsWalletSignIn as l, bufferExports as m, normalizeSolanaRpcUrl as n, setStoredAuthMethod as o, confirmAndCheckTransaction as p, defaultInjectedEvmProvider as q, resolveSolanaRpcUrl as r, setCurrentUser as s, transactionHasSignature as t, init as u, getCurrentUser as v, onAuthStateChanged as w, onAuthLoadingChanged as x, getAuthLoading as y, waitForAuthReady as z };
+//# sourceMappingURL=index-BaXUWG8Q.mjs.map