@bounded-sh/client 0.0.58 → 0.0.59

package/dist/index.d.ts

@@ -30,6 +30,8 @@ export type { TurnkeySignResult, TurnkeyWallet } from "./auth/turnkey-signer-bri
 export { startTurnkeyEmailLogin } from "./auth/turnkey-auth";
 export type { TurnkeyEmailLoginHandle } from "./auth/turnkey-auth";
 export { getIdToken } from "./utils";
+export { onramp } from "./onramp";
+export type { OnrampOptions, OnrampResult } from "./onramp";
 export { setPlatform, getPlatform } from "./platform";
 export type { PlatformAdapter, StorageAdapter } from "./platform";
 export { OffchainAuthProvider, OffchainAuthProviderConfig, } from "./auth/providers/offchain-auth-provider";

package/dist/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-MKE9tHpl.js');
+var index = require('./index-uu8hKP-p.js');
 var core = require('@bounded-sh/core');
 require('react');
 
@@ -39,6 +39,7 @@ exports.loginWithWallet = index.loginWithWallet;
 exports.logout = index.logout;
 exports.onAuthLoadingChanged = index.onAuthLoadingChanged;
 exports.onAuthStateChanged = index.onAuthStateChanged;
+exports.onramp = index.onramp;
 exports.openBoundedWidget = index.openBoundedWidget;
 exports.requestEip6963Providers = index.requestEip6963Providers;
 exports.setPlatform = index.setPlatform;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { $ as BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA, _ as BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA, Z as BUILD_REVIEW_CAPABILITY_SCHEMA, T as BuildsApiError, Y as FAILURE_REASONS, U as NON_TERMINAL_STATES, P as OffchainAuthProvider, X as PARK_REASONS, Q as PrivyExpoProvider, W as RUN_STATES, V as TERMINAL_STATES, I as apps, S as builds, A as completeLoginFromRedirect, C as completeLoginInPopup, k as defaultInjectedEvmProvider, d as defaultInjectedProvider, J as deserializeTransaction, q as getAuthLoading, v as getAuthProvider, m as getCurrentUser, N as getIdToken, L as getOrCreateTurnkeyWallet, g as getPlatform, l as init, t as login, B as loginWithPopup, x as loginWithPrivy, z as loginWithRedirect, y as loginWithWallet, u as logout, p as onAuthLoadingChanged, o as onAuthStateChanged, D as openBoundedWidget, R as requestEip6963Providers, O as setPlatform, w as signInAnonymously, K as signSolanaMessageViaTurnkey, M as startTurnkeyEmailLogin, F as useAuth, H as useBuildRun, G as useQuery } from './index-DWodlTFG.mjs';
+export { a0 as BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA, $ as BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA, _ as BUILD_REVIEW_CAPABILITY_SCHEMA, U as BuildsApiError, Z as FAILURE_REASONS, V as NON_TERMINAL_STATES, Q as OffchainAuthProvider, Y as PARK_REASONS, R as PrivyExpoProvider, X as RUN_STATES, W as TERMINAL_STATES, I as apps, T as builds, A as completeLoginFromRedirect, C as completeLoginInPopup, k as defaultInjectedEvmProvider, d as defaultInjectedProvider, J as deserializeTransaction, q as getAuthLoading, v as getAuthProvider, m as getCurrentUser, N as getIdToken, L as getOrCreateTurnkeyWallet, g as getPlatform, l as init, t as login, B as loginWithPopup, x as loginWithPrivy, z as loginWithRedirect, y as loginWithWallet, u as logout, p as onAuthLoadingChanged, o as onAuthStateChanged, O as onramp, D as openBoundedWidget, S as requestEip6963Providers, P as setPlatform, w as signInAnonymously, K as signSolanaMessageViaTurnkey, M as startTurnkeyEmailLogin, F as useAuth, H as useBuildRun, G as useQuery } from './index-SHt4VZZV.mjs';
 export * from '@bounded-sh/core';
 export { BoundedDeclineError, DECLINE_EVENT_NAME, RATE_LIMIT_EVENT_NAME, ScopedClientReadOnlyError, aggregate, count, createClient, deriveDecline, dispatchDeclineEvent, dispatchRateLimitEvent, docId, get, getConfig, getFiles, getMany, queryAggregate, runExpression, runExpressionMany, runQuery, runQueryMany, search, set, setFile, setMany, signAndSubmitTransaction, signMessage, signTransaction, subscribe } from '@bounded-sh/core';
 import 'react';

package/dist/{index.native-CQiw9baS.mjs → index.native-D-8IAEy-.mjs}

@@ -1,4 +1,4 @@
-import { assertCanonicalBoundedRuntimeWriteCalldata, getActiveSessionManager, getConfig, WebSessionManager, ReactNativeSessionManager, revokeSession, init as init$1, reconnectWithNewAuth, deriveUserIdentityFromIdToken, subscribe, getIdToken as getIdToken$1, convertRemainingAccounts, buildSetDocumentsTransaction, genAuthNonce, genSolanaMessage, createSessionWithSignature } from '@bounded-sh/core';
+import { assertCanonicalBoundedRuntimeWriteCalldata, getActiveSessionManager, getConfig, WebSessionManager, ReactNativeSessionManager, revokeSession, init as init$1, onSessionCleared, reconnectWithNewAuth, deriveUserIdentityFromIdToken, subscribe, getIdToken as getIdToken$1, convertRemainingAccounts, buildSetDocumentsTransaction, genAuthNonce, genSolanaMessage, createSessionWithSignature } from '@bounded-sh/core';
 import * as React from 'react';
 
 /**
@@ -3454,7 +3454,7 @@ const EMBEDDED_WALLET_UNSUPPORTED = 'Unsupported for embedded smart wallets —
 const NO_EMBEDDED_WALLET = 'This login has no embedded wallet. Enable `"auth": { "wallets": true }` in ' +
     'the app policy so email logins get a non-custodial wallet (@user.address), ' +
     'then sign from a user gesture.';
-function hasDOM$1() {
+function hasDOM$2() {
     return typeof window !== 'undefined' && typeof document !== 'undefined';
 }
 function decodeJwt$1(token) {
@@ -3514,7 +3514,7 @@ let requestSeq = 0;
  * wallet's owner, and validates that the wallet address matches the account.
  */
 async function signViaSignerPopup(action) {
-    if (!hasDOM$1()) {
+    if (!hasDOM$2()) {
         throw new Error('Embedded-wallet signing is only available in the browser (popup-based).');
     }
     const isEvm = action.kind === 'evmTransaction';
@@ -3690,7 +3690,7 @@ const STORED_AUTH_METHOD_KEY$1 = 'bounded_last_auth_method';
 // not by `typeof window` (truthy on RN). OIDC redirect/popup is web-only, but the
 // session it mints is read back through this same selector everywhere.
 const sessionManager = getActiveSessionManager;
-function hasDOM() {
+function hasDOM$1() {
     return typeof window !== 'undefined' && typeof document !== 'undefined';
 }
 function decodeJwt(token) {
@@ -3721,7 +3721,7 @@ const oidcProviderSingleton = {
         const idToken = sessionManager().getIdToken();
         return idToken ? userFromIdToken(idToken) : null;
     },
-    async logout() { sessionManager().clearSession(); },
+    async logout() { await sessionManager().clearSession(); },
     async signMessage(_message) {
         throw new Error(hasEmbeddedWallet() ? EMBEDDED_WALLET_UNSUPPORTED : OIDC_NO_WALLET);
     },
@@ -3830,7 +3830,7 @@ async function buildAuthorize(opts) {
         throw new Error('appId is not configured (init the SDK with your appId)');
     // Web: default to the current page so callers don't have to pass redirectUri. Native has no
     // window — it MUST pass an https universal link (the system auth session needs a real URL).
-    const redirectUri = opts.redirectUri || (hasDOM() ? window.location.origin + window.location.pathname : undefined);
+    const redirectUri = opts.redirectUri || (hasDOM$1() ? window.location.origin + window.location.pathname : undefined);
     if (!redirectUri)
         throw new Error('redirectUri is required on React Native — pass the https universal link the app owner registered.');
     const { verifier, challenge } = await makePkce();
@@ -3938,7 +3938,7 @@ async function runNativeLogin(opts) {
 async function loginWithRedirect(opts) {
     if (isNative())
         return runNativeLogin(opts);
-    if (!hasDOM())
+    if (!hasDOM$1())
         throw new Error('loginWithRedirect requires a browser or a configured React Native platform');
     const { url, pkce } = await buildAuthorize(opts);
     // Stash the verifier + state so the redirect_uri page can finish the exchange. sessionStorage
@@ -3954,7 +3954,7 @@ async function loginWithRedirect(opts) {
  *  loginWithRedirect() (which resolves with the User), so there is no separate redirect
  *  page to finish from. Calling it on RN is harmless. */
 async function completeLoginFromRedirect() {
-    if (!hasDOM())
+    if (!hasDOM$1())
         return null;
     const url = new URL(window.location.href);
     const code = url.searchParams.get('code');
@@ -4000,7 +4000,7 @@ async function completeLoginFromRedirect() {
  *  redirect_uri page posts the code back. The redirect_uri page just calls the usual
  *  completeLoginFromRedirect() (which auto-detects the popup) — no separate call needed. */
 async function loginWithPopup(opts) {
-    if (!hasDOM())
+    if (!hasDOM$1())
         throw new Error('loginWithPopup is web-only — on React Native use loginWithRedirect()');
     // Open synchronously, before PKCE/config awaits consume the click's user-
     // activation window. Opening only after buildAuthorize() intermittently
@@ -4140,7 +4140,7 @@ async function loginWithPopup(opts) {
 /** Call this on the redirect_uri page when login was opened via loginWithPopup(): posts the
  *  code back to the opener and closes. (For the redirect variant use completeLoginFromRedirect.) */
 function completeLoginInPopup(openerOrigin) {
-    if (!hasDOM() || !window.opener)
+    if (!hasDOM$1() || !window.opener)
         return;
     const url = new URL(window.location.href);
     const code = url.searchParams.get('code');
@@ -4341,15 +4341,20 @@ function authProviderConfigKey(config) {
  * so both web (WebSessionManager) and RN (ReactNativeSessionManager) sessions
  * are properly cleared.
  */
-function clearIncompatibleSession() {
+async function clearIncompatibleSession() {
     if (getStoredAuthMethod() === currentAuthMethod) {
         return false;
     }
     // Clear both managers: on web the RN manager is a no-op (not configured),
     // and on RN the web manager is a no-op (no localStorage).
-    WebSessionManager.clearSession();
+    //
+    // AWAITED. Session removal is serialized through a cross-tab lock now, so a
+    // fire-and-forget call would let init() reach setCurrentUser while the old
+    // credential was still readable — and a request issued in that gap would
+    // authenticate as the session we are in the middle of discarding.
+    await WebSessionManager.clearSession();
     try {
-        ReactNativeSessionManager.clearSession();
+        await ReactNativeSessionManager.clearSession();
     }
     catch ( /* not configured on web */_a) { /* not configured on web */ }
     setStoredAuthMethod(null);
@@ -4448,7 +4453,7 @@ async function getAuthProvider(config) {
             // 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-CfNSS8Du.mjs')).EmailAuthProvider();
+            currentAuthProvider = new (await import('./email-auth-provider-deB_ADc5.mjs')).EmailAuthProvider();
             break;
         case "wallet":
         case "phantom": {
@@ -4467,7 +4472,7 @@ async function getAuthProvider(config) {
             if (!isWalletLoginEnabled(config)) {
                 throw walletLoginNotEnabledError(authMethod);
             }
-            const { InjectedWalletProvider } = await import('./injected-wallet-provider-Bps6a9IP.mjs');
+            const { InjectedWalletProvider } = await import('./injected-wallet-provider-CNYAynIB.mjs');
             currentAuthProvider = new InjectedWalletProvider(resolveInjectedWalletConfig(config), rpcUrl, configuredNetwork);
             break;
         }
@@ -4480,7 +4485,7 @@ async function getAuthProvider(config) {
             // 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-DCGnUedJ.mjs');
+            const { InjectedEvmWalletProvider } = await import('./injected-evm-wallet-provider-CJsLX16m.mjs');
             currentAuthProvider = new InjectedEvmWalletProvider(evmWalletConfig);
             break;
         }
@@ -4508,7 +4513,7 @@ async function getAuthProvider(config) {
             break;
         case "guest":
             // Anonymous auth: a device-local ed25519 keypair signs the challenge.
-            currentAuthProvider = new (await import('./guest-auth-provider-DxhZ5sWN.mjs')).GuestAuthProvider();
+            currentAuthProvider = new (await import('./guest-auth-provider-D9wbogwi.mjs')).GuestAuthProvider();
             break;
     }
     if (!currentAuthProvider) {
@@ -4564,7 +4569,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-DxhZ5sWN.mjs')).GuestAuthProvider();
+    const provider = new (await import('./guest-auth-provider-D9wbogwi.mjs')).GuestAuthProvider();
     setAuthLoading(true); // reflect "signing in…" while the guest keypair session is minted
     const commit = (user) => {
         // No await/interleaving inside this block: provider/method/config/marker
@@ -4606,7 +4611,7 @@ async function signInAnonymously() {
             }
             catch (_b) {
                 try {
-                    getActiveSessionManager().clearSession();
+                    await getActiveSessionManager().clearSession();
                 }
                 catch ( /* fail closed below */_c) { /* fail closed below */ }
             }
@@ -4830,6 +4835,22 @@ async function logout$1(options) {
     }
 }
 
+/**
+ * Subscribed once per process, not per init(): re-registering on every init would
+ * stack duplicate handlers on repeated initialization.
+ */
+let sessionClearedBridgeRegistered = false;
+function registerSessionClearedBridge() {
+    if (sessionClearedBridgeRegistered)
+        return;
+    sessionClearedBridgeRegistered = true;
+    onSessionCleared(() => {
+        // Core fires this only when storage was ACTUALLY cleared, never on a
+        // transient refresh failure that preserved the session — so this cannot
+        // sign anyone out over a network blip.
+        setCurrentUser(null);
+    });
+}
 /**
  * Read the active session's idToken synchronously from whichever store is live
  * for this runtime (WebSessionManager on web, ReactNativeSessionManager on RN —
@@ -4887,6 +4908,15 @@ async function init(newConfig) {
     // setting it here makes "no flash" the SDK's default behavior for every consumer.
     setAuthLoading(true);
     try {
+        // Bridge core's "the stored session is gone" signal into SDK auth state.
+        //
+        // Core cannot import this package, and a session can die deep inside a
+        // session manager (dead refresh token, rejected refresh, app-id mismatch).
+        // Before this, setCurrentUser(null) was only ever called by logout() and
+        // init(), so storage could be wiped while `currentUser` stayed populated —
+        // onAuthStateChanged never fired, and every consumer UI went on showing a
+        // connected wallet for a session the server no longer knew about.
+        registerSessionClearedBridge();
         // Get auth provider first
         authProviderInstance = await getAuthProvider(newConfig);
         // Initialize config with auth provider
@@ -4903,7 +4933,12 @@ async function init(newConfig) {
         let user = await authProviderInstance.restoreSession();
         // If a session exists but was created before auth method tracking (legacy session),
         // clear it to avoid mismatches when the app switches auth methods (e.g. email → phantom)
-        if (user && clearIncompatibleSession()) {
+        //
+        // AWAITED: the clear is serialized through a cross-tab lock now, and an
+        // unawaited call would return a Promise (always truthy) — nulling the user
+        // unconditionally AND letting setCurrentUser run while the old credential
+        // was still in storage.
+        if (user && await clearIncompatibleSession()) {
             user = null;
         }
         setCurrentUser(user);
@@ -5766,6 +5801,109 @@ async function deserializeTransaction(tx) {
     }
 }
 
+// bounded.onramp() - fund the signed-in user's wallet with Coinbase Onramp.
+//
+// Web-only. Opens Coinbase's hosted checkout (pay.coinbase.com) in a popup
+// (new-tab fallback) using a single-use session token minted by the Bounded
+// platform at POST <origin>/__bounded/onramp/session on the app's own origin.
+// The platform holds the Coinbase credential; the app never sees it. The
+// session is bound server-side to the caller's verified Bounded JWT, and the
+// destination defaults to that user's embedded wallet.
+//
+// Works on Bounded-served origins (<app>.bounded.page / custom domains). On a
+// local dev origin the session endpoint does not exist; we fail with a clear
+// error rather than guessing a host.
+function hasDOM() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+/**
+ * Open Coinbase Onramp for the signed-in user. Resolves when the popup closes.
+ * Call from a click handler - popup blockers require user activation.
+ */
+async function onramp(options = {}) {
+    var _a, _b, _c;
+    if (!hasDOM())
+        throw new Error('onramp() is web-only');
+    const user = getCurrentUser();
+    const address = (_b = (_a = options.address) !== null && _a !== void 0 ? _a : user === null || user === void 0 ? void 0 : user.address) !== null && _b !== void 0 ? _b : undefined;
+    if (!address) {
+        throw new Error(user
+            ? 'onramp(): the signed-in account has no wallet address - pass { address } explicitly'
+            : 'onramp(): no signed-in user - call login() first or pass { address }');
+    }
+    const idToken = await getIdToken();
+    if (!idToken)
+        throw new Error('onramp(): no active session - call login() first');
+    // Open the window synchronously so the click's user-activation window is not
+    // consumed by the fetch below (same hard-won pattern as loginWithPopup).
+    let popup = null;
+    if (!options.newTab) {
+        const w = options.width || 460;
+        const h = options.height || 720;
+        const left = window.screenX + (window.outerWidth - w) / 2;
+        const top = window.screenY + (window.outerHeight - h) / 2;
+        popup = window.open('', 'bounded-onramp', `width=${w},height=${h},left=${left},top=${top}`);
+    }
+    let session;
+    try {
+        const res = await fetch(`${window.location.origin}/__bounded/onramp/session`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${idToken}`, 'content-type': 'application/json' },
+            body: JSON.stringify(Object.assign(Object.assign(Object.assign({}, (options.asset ? { asset: options.asset } : {})), (options.address ? { address: options.address } : {})), (options.amountUsd !== undefined ? { amountUsd: options.amountUsd } : {}))),
+        });
+        if (!res.ok) {
+            let detail = '';
+            try {
+                detail = (_c = (await res.json()).error) !== null && _c !== void 0 ? _c : '';
+            }
+            catch ( /* keep status only */_d) { /* keep status only */ }
+            if (res.status === 404) {
+                throw new Error('onramp(): session endpoint not found - onramp works on Bounded-served origins (your deployed app URL), not local dev servers');
+            }
+            throw new Error(`onramp(): session mint failed (${res.status}${detail ? `: ${detail}` : ''})`);
+        }
+        session = (await res.json());
+    }
+    catch (error) {
+        try {
+            popup === null || popup === void 0 ? void 0 : popup.close();
+        }
+        catch ( /* ignore */_e) { /* ignore */ }
+        throw error;
+    }
+    if (popup) {
+        try {
+            popup.location.replace(session.url);
+        }
+        catch (_f) {
+            try {
+                popup.location.href = session.url;
+            }
+            catch (_g) {
+                try {
+                    popup.close();
+                }
+                catch ( /* ignore */_h) { /* ignore */ }
+                throw new Error('onramp(): popup failed to navigate - retry with { newTab: true }');
+            }
+        }
+        return await new Promise((resolve) => {
+            const timer = setInterval(() => {
+                if (popup.closed) {
+                    clearInterval(timer);
+                    resolve({ status: 'closed', address: session.address, asset: session.asset });
+                }
+            }, 500);
+        });
+    }
+    // New-tab path (popup was blocked or explicitly requested): cross-origin tab
+    // close is not observable, so resolve immediately.
+    const tab = window.open(session.url, '_blank');
+    if (!tab)
+        throw new Error('onramp(): window.open was blocked - call onramp() from a click handler');
+    return { status: 'opened', address: session.address, asset: session.asset };
+}
+
 /**
  * Extracts a human-readable error message from Solana transaction logs.
  */
@@ -5895,7 +6033,7 @@ class PrivyExpoProvider {
                 return { provider: this, address: session.address };
             }
             // Stale session — clear and continue to fresh login flow
-            getActiveSessionManager().clearSession();
+            await getActiveSessionManager().clearSession();
         }
         // Trigger Privy login
         const privyUser = await this.privyMethods.login();
@@ -6076,7 +6214,7 @@ class PrivyExpoProvider {
         if ((_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.isAuthenticated) {
             await this.privyMethods.logout();
         }
-        getActiveSessionManager().clearSession();
+        await getActiveSessionManager().clearSession();
     }
     async getNativeMethods() {
         return this.privyMethods;
@@ -6149,5 +6287,5 @@ class PrivyExpoProvider {
     }
 }
 
-export { useAuth as A, useQuery as B, useBuildRun as C, apps as D, EMBEDDED_WALLET_UNSUPPORTED as E, deserializeTransaction as F, getIdToken as G, setPlatform as H, builds as I, BuildsApiError as J, PARK_REASONS as K, FAILURE_REASONS as L, BUILD_REVIEW_CAPABILITY_SCHEMA as M, NON_TERMINAL_STATES as N, OffchainAuthProvider as O, PrivyExpoProvider as P, BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA as Q, RUN_STATES as R, BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA as S, TERMINAL_STATES as T, hasEmbeddedEvmWallet as a, embeddedSignAndSubmit as b, setAuthLoading as c, bufferExports as d, embeddedRunEvmTransaction as e, bs58 as f, getPlatform as g, hasEmbeddedWallet as h, confirmAndCheckTransaction as i, init as j, getCurrentUser as k, onAuthLoadingChanged as l, getAuthLoading as m, normalizeSolanaRpcUrl as n, onAuthStateChanged as o, login as p, logout as q, resolveSolanaRpcUrl as r, setCurrentUser as s, getAuthProvider as t, signInAnonymously as u, loginWithPrivy as v, loginWithRedirect as w, completeLoginFromRedirect as x, loginWithPopup as y, completeLoginInPopup as z };
-//# sourceMappingURL=index.native-CQiw9baS.mjs.map
+export { useAuth as A, useQuery as B, useBuildRun as C, apps as D, EMBEDDED_WALLET_UNSUPPORTED as E, deserializeTransaction as F, getIdToken as G, onramp as H, setPlatform as I, builds as J, BuildsApiError as K, PARK_REASONS as L, FAILURE_REASONS as M, NON_TERMINAL_STATES as N, OffchainAuthProvider as O, PrivyExpoProvider as P, BUILD_REVIEW_CAPABILITY_SCHEMA as Q, RUN_STATES as R, BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA as S, TERMINAL_STATES as T, BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA as U, hasEmbeddedEvmWallet as a, embeddedSignAndSubmit as b, setAuthLoading as c, bufferExports as d, embeddedRunEvmTransaction as e, bs58 as f, getPlatform as g, hasEmbeddedWallet as h, confirmAndCheckTransaction as i, init as j, getCurrentUser as k, onAuthLoadingChanged as l, getAuthLoading as m, normalizeSolanaRpcUrl as n, onAuthStateChanged as o, login as p, logout as q, resolveSolanaRpcUrl as r, setCurrentUser as s, getAuthProvider as t, signInAnonymously as u, loginWithPrivy as v, loginWithRedirect as w, completeLoginFromRedirect as x, loginWithPopup as y, completeLoginInPopup as z };
+//# sourceMappingURL=index.native-D-8IAEy-.mjs.map