@bounded-sh/client 0.0.58 → 0.0.60

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, onrampQuote, onrampStatus } from "./onramp";
+export type { OnrampOptions, OnrampResult, OnrampQuoteInfo, OnrampTransaction } 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-iu8vB4ye.js');
 var core = require('@bounded-sh/core');
 require('react');
 
@@ -39,6 +39,9 @@ exports.loginWithWallet = index.loginWithWallet;
 exports.logout = index.logout;
 exports.onAuthLoadingChanged = index.onAuthLoadingChanged;
 exports.onAuthStateChanged = index.onAuthStateChanged;
+exports.onramp = index.onramp;
+exports.onrampQuote = index.onrampQuote;
+exports.onrampStatus = index.onrampStatus;
 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 { a2 as BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA, a1 as BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA, a0 as BUILD_REVIEW_CAPABILITY_SCHEMA, W as BuildsApiError, $ as FAILURE_REASONS, X as NON_TERMINAL_STATES, S as OffchainAuthProvider, _ as PARK_REASONS, T as PrivyExpoProvider, Z as RUN_STATES, Y as TERMINAL_STATES, I as apps, V 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, P as onrampQuote, Q as onrampStatus, D as openBoundedWidget, U as requestEip6963Providers, R as setPlatform, w as signInAnonymously, K as signSolanaMessageViaTurnkey, M as startTurnkeyEmailLogin, F as useAuth, H as useBuildRun, G as useQuery } from './index-CQtGkKVd.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-hu3o3zXU.js → index.native-CDfx0N6p.js}

@@ -3475,7 +3475,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) {
@@ -3535,7 +3535,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';
@@ -3711,7 +3711,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 = core.getActiveSessionManager;
-function hasDOM() {
+function hasDOM$1() {
     return typeof window !== 'undefined' && typeof document !== 'undefined';
 }
 function decodeJwt(token) {
@@ -3742,7 +3742,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);
     },
@@ -3851,7 +3851,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();
@@ -3959,7 +3959,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
@@ -3975,7 +3975,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');
@@ -4021,7 +4021,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
@@ -4161,7 +4161,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');
@@ -4362,15 +4362,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).
-    core.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 core.WebSessionManager.clearSession();
     try {
-        core.ReactNativeSessionManager.clearSession();
+        await core.ReactNativeSessionManager.clearSession();
     }
     catch ( /* not configured on web */_a) { /* not configured on web */ }
     setStoredAuthMethod(null);
@@ -4469,7 +4474,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 Promise.resolve().then(function () { return require('./email-auth-provider-BlJI-8w9.js'); })).EmailAuthProvider();
+            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./email-auth-provider-BCEdcnRu.js'); })).EmailAuthProvider();
             break;
         case "wallet":
         case "phantom": {
@@ -4488,7 +4493,7 @@ async function getAuthProvider(config) {
             if (!isWalletLoginEnabled(config)) {
                 throw walletLoginNotEnabledError(authMethod);
             }
-            const { InjectedWalletProvider } = await Promise.resolve().then(function () { return require('./injected-wallet-provider-7ep-jcal.js'); });
+            const { InjectedWalletProvider } = await Promise.resolve().then(function () { return require('./injected-wallet-provider-TPx8Wzvq.js'); });
             currentAuthProvider = new InjectedWalletProvider(resolveInjectedWalletConfig(config), rpcUrl, configuredNetwork);
             break;
         }
@@ -4501,7 +4506,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 Promise.resolve().then(function () { return require('./injected-evm-wallet-provider-Xbt2CUPi.js'); });
+            const { InjectedEvmWalletProvider } = await Promise.resolve().then(function () { return require('./injected-evm-wallet-provider-CGa692L1.js'); });
             currentAuthProvider = new InjectedEvmWalletProvider(evmWalletConfig);
             break;
         }
@@ -4529,7 +4534,7 @@ async function getAuthProvider(config) {
             break;
         case "guest":
             // Anonymous auth: a device-local ed25519 keypair signs the challenge.
-            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider-BRjJV8Zq.js'); })).GuestAuthProvider();
+            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider-CrRreOyf.js'); })).GuestAuthProvider();
             break;
     }
     if (!currentAuthProvider) {
@@ -4585,7 +4590,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 Promise.resolve().then(function () { return require('./guest-auth-provider-BRjJV8Zq.js'); })).GuestAuthProvider();
+    const provider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider-CrRreOyf.js'); })).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
@@ -4627,7 +4632,7 @@ async function signInAnonymously() {
             }
             catch (_b) {
                 try {
-                    core.getActiveSessionManager().clearSession();
+                    await core.getActiveSessionManager().clearSession();
                 }
                 catch ( /* fail closed below */_c) { /* fail closed below */ }
             }
@@ -4770,7 +4775,7 @@ function getCurrentAuthMethod() {
 // allowlist here: on a trusted origin we end the issuer session with a
 // top-level bounce; anywhere else (custom domains, http dev) we keep the
 // local-only logout instead of stranding the user on the issuer origin.
-function issuerLogoutBounceUrl(issuerBase) {
+function issuerLogoutBounceUrl(issuerBase, idTokenHint) {
     if (typeof window === 'undefined' || typeof document === 'undefined')
         return null; // RN/Node: no shared cookie jar to clear this way
     try {
@@ -4793,12 +4798,27 @@ function issuerLogoutBounceUrl(issuerBase) {
         if (!trusted)
             return null;
         const base = issuerBase.replace(/\/$/, '');
-        return `${base}/logout?redirect_uri=${encodeURIComponent(here.href)}`;
+        // #228: send the id_token_hint so the issuer can bind the post-logout redirect to this
+        // session + app + registered origin. Without it the issuer safely falls back to its own
+        // origin (it no longer trusts a bare suffix match), so the return-to-app bounce is a no-op.
+        const hint = idTokenHint ? `&id_token_hint=${encodeURIComponent(idTokenHint)}` : '';
+        return `${base}/logout?redirect_uri=${encodeURIComponent(here.href)}${hint}`;
     }
     catch (_b) {
         return null;
     }
 }
+// #228 helper, deliberately OUTSIDE logout(): the logout body is source-guarded
+// against any `catch` so a revokeSession failure can never be swallowed, and a
+// missing id token is the one benign absence worth tolerating here.
+function idTokenHintOrNull(sm) {
+    try {
+        return sm.getIdToken();
+    }
+    catch (_a) {
+        return null; /* no id token to hint with */
+    }
+}
 async function logout$1(options) {
     // Re-initialize the provider if it was cleared by a prior logout — the exact mirror
     // of login()'s self-heal above. A hosted popup/redirect login (loginWithPopup /
@@ -4823,6 +4843,9 @@ async function logout$1(options) {
     const sm = core.getActiveSessionManager();
     const refreshToken = sm.getRefreshToken();
     const sessionIssuer = sm.getIssuer();
+    // #228: capture the id token NOW, before currentAuthProvider.logout() clears the session, so we
+    // can hand it to the issuer /logout as an id_token_hint (which binds the post-logout redirect).
+    const idTokenHint = idTokenHintOrNull(sm);
     if (refreshToken)
         await core.revokeSession(refreshToken, sessionIssuer !== null && sessionIssuer !== void 0 ? sessionIssuer : undefined);
     // Hosted sessions ('email' covers the whole hosted surface: email OTP +
@@ -4843,7 +4866,7 @@ async function logout$1(options) {
         const issuerBase = sessionIssuer
             || (await core.getConfig()).humanAuthApiUrl
             || 'https://auth.bounded.sh';
-        const bounce = issuerLogoutBounceUrl(issuerBase);
+        const bounce = issuerLogoutBounceUrl(issuerBase, idTokenHint);
         // Local state is already cleared, so even if the navigation is stopped
         // (tab close, extension) the app-side logout has fully happened.
         if (bounce)
@@ -4851,6 +4874,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;
+    core.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 —
@@ -4908,6 +4947,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
@@ -4924,7 +4972,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);
@@ -5787,6 +5840,199 @@ 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.
+//
+// Amount semantics:
+//   amountUsd    - exact fiat in; the fee/output breakdown comes back as `quote`.
+//   minAmountOut - a FLOOR on crypto received. The platform quotes Coinbase's
+//     worst-fee payment method (card) and pads by `slippagePad` (default 1%),
+//     so cheaper methods overshoot the floor rather than undershooting it. The
+//     floor holds unless the market moves more than the pad while the user sits
+//     on the checkout screen - which is why completion is VERIFIED: after the
+//     popup closes we poll the platform's status leg and resolve with the
+//     actual filled amount when Coinbase reports it.
+//
+// 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';
+}
+async function authedFetch(path, init) {
+    const idToken = await getIdToken();
+    if (!idToken)
+        throw new Error('onramp: no active session - call login() first');
+    return fetch(`${window.location.origin}${path}`, Object.assign(Object.assign({}, init), { headers: Object.assign(Object.assign({}, init === null || init === void 0 ? void 0 : init.headers), { Authorization: `Bearer ${idToken}` }) }));
+}
+async function readError(res) {
+    var _a;
+    try {
+        return (_a = (await res.json()).error) !== null && _a !== void 0 ? _a : '';
+    }
+    catch (_b) {
+        return '';
+    }
+}
+function sessionBody(options, extra) {
+    return JSON.stringify(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (options.asset ? { asset: options.asset } : {})), (options.address ? { address: options.address } : {})), (options.amountUsd !== undefined ? { amountUsd: options.amountUsd } : {})), (options.minAmountOut !== undefined ? { minAmountOut: options.minAmountOut } : {})), (options.slippagePad !== undefined ? { slippagePad: options.slippagePad } : {})), extra));
+}
+function resolveAddress(options) {
+    var _a, _b;
+    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 }');
+    }
+    return address;
+}
+/**
+ * Preview a quote (fees + exact/floor output) WITHOUT opening any window or
+ * consuming a session. Show this to the user, then call onramp() to check out.
+ */
+async function onrampQuote(options = {}) {
+    if (!hasDOM())
+        throw new Error('onrampQuote is web-only');
+    resolveAddress(options);
+    const res = await authedFetch('/__bounded/onramp/session', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: sessionBody(options, { quoteOnly: true }),
+    });
+    if (!res.ok)
+        throw new Error(`onrampQuote: failed (${res.status}${await readError(res).then((e) => (e ? `: ${e}` : ''))})`);
+    return (await res.json());
+}
+/** The signed-in user's recent onramp transactions (newest first). */
+async function onrampStatus(sinceMs) {
+    if (!hasDOM())
+        throw new Error('onrampStatus is web-only');
+    const res = await authedFetch(`/__bounded/onramp/status${sinceMs ? `?since=${Math.floor(sinceMs)}` : ''}`);
+    if (!res.ok)
+        throw new Error(`onrampStatus: failed (${res.status})`);
+    return (await res.json()).transactions;
+}
+function isSuccess(t) {
+    return /SUCCESS|COMPLETED/i.test(t.status);
+}
+function isPending(t) {
+    return /PROGRESS|PENDING|CREATED/i.test(t.status);
+}
+async function verifyCompletion(openedAt, asset, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    // 60s of clock-skew slack on `since`: Coinbase stamps server-side.
+    const since = openedAt - 60000;
+    for (;;) {
+        let sawPending = false;
+        try {
+            const txs = await onrampStatus(since);
+            const done = txs.find((t) => isSuccess(t) && (t.asset === null || t.asset === asset));
+            if (done)
+                return done;
+            sawPending = txs.some(isPending);
+        }
+        catch ( /* transient - keep polling until the deadline */_a) { /* transient - keep polling until the deadline */ }
+        // No completed fill and nothing in flight: one grace poll cycle still
+        // runs (Coinbase's record can lag the redirect), but don't burn the
+        // full window when the user plainly abandoned checkout.
+        if (Date.now() >= deadline)
+            return null;
+        if (!sawPending && Date.now() >= openedAt + 12000 && Date.now() - openedAt > timeoutMs / 2)
+            return null;
+        await new Promise((r) => setTimeout(r, 3000));
+    }
+}
+/**
+ * Open Coinbase Onramp for the signed-in user. Resolves after the window
+ * closes, with completion VERIFIED against Coinbase when possible.
+ * Call from a click handler - popup blockers require user activation.
+ */
+async function onramp(options = {}) {
+    var _a;
+    if (!hasDOM())
+        throw new Error('onramp() is web-only');
+    resolveAddress(options);
+    // 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 authedFetch('/__bounded/onramp/session', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: sessionBody(options),
+        });
+        if (!res.ok) {
+            const detail = await readError(res);
+            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 */_b) { /* ignore */ }
+        throw error;
+    }
+    const openedAt = Date.now();
+    const base = Object.assign({ address: session.address, asset: session.asset }, (session.quote ? { quote: session.quote } : {}));
+    if (popup) {
+        try {
+            popup.location.replace(session.url);
+        }
+        catch (_c) {
+            try {
+                popup.location.href = session.url;
+            }
+            catch (_d) {
+                try {
+                    popup.close();
+                }
+                catch ( /* ignore */_e) { /* ignore */ }
+                throw new Error('onramp: popup failed to navigate - retry with { newTab: true }');
+            }
+        }
+        await new Promise((resolve) => {
+            const timer = setInterval(() => {
+                if (popup.closed) {
+                    clearInterval(timer);
+                    resolve();
+                }
+            }, 500);
+        });
+        const fill = await verifyCompletion(openedAt, session.asset, (_a = options.completionTimeoutMs) !== null && _a !== void 0 ? _a : 24000);
+        if (fill) {
+            return Object.assign(Object.assign(Object.assign(Object.assign({}, base), { status: 'completed' }), (fill.amountOut !== null ? { actualOut: fill.amountOut } : {})), (fill.txHash ? { txHash: fill.txHash } : {}));
+        }
+        return Object.assign(Object.assign({}, base), { status: 'closed' });
+    }
+    // New-tab path (popup was blocked or explicitly requested): cross-origin tab
+    // close is not observable, so resolve immediately; verify via onrampStatus().
+    const tab = window.open(session.url, '_blank');
+    if (!tab)
+        throw new Error('onramp: window.open was blocked - call onramp() from a click handler');
+    return Object.assign(Object.assign({}, base), { status: 'opened' });
+}
+
 /**
  * Extracts a human-readable error message from Solana transaction logs.
  */
@@ -5916,7 +6162,7 @@ class PrivyExpoProvider {
                 return { provider: this, address: session.address };
             }
             // Stale session — clear and continue to fresh login flow
-            core.getActiveSessionManager().clearSession();
+            await core.getActiveSessionManager().clearSession();
         }
         // Trigger Privy login
         const privyUser = await this.privyMethods.login();
@@ -6097,7 +6343,7 @@ class PrivyExpoProvider {
         if ((_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.isAuthenticated) {
             await this.privyMethods.logout();
         }
-        core.getActiveSessionManager().clearSession();
+        await core.getActiveSessionManager().clearSession();
     }
     async getNativeMethods() {
         return this.privyMethods;
@@ -6208,6 +6454,9 @@ exports.logout = logout;
 exports.normalizeSolanaRpcUrl = normalizeSolanaRpcUrl;
 exports.onAuthLoadingChanged = onAuthLoadingChanged;
 exports.onAuthStateChanged = onAuthStateChanged;
+exports.onramp = onramp;
+exports.onrampQuote = onrampQuote;
+exports.onrampStatus = onrampStatus;
 exports.resolveSolanaRpcUrl = resolveSolanaRpcUrl;
 exports.setAuthLoading = setAuthLoading;
 exports.setCurrentUser = setCurrentUser;
@@ -6216,4 +6465,4 @@ exports.signInAnonymously = signInAnonymously;
 exports.useAuth = useAuth;
 exports.useBuildRun = useBuildRun;
 exports.useQuery = useQuery;
-//# sourceMappingURL=index.native-hu3o3zXU.js.map
+//# sourceMappingURL=index.native-CDfx0N6p.js.map