@bounded-sh/client 0.0.59 → 0.0.61

package/dist/index.d.ts

@@ -30,8 +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 { 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-uu8hKP-p.js');
+var index = require('./index-C_L497w1.js');
 var core = require('@bounded-sh/core');
 require('react');
 
@@ -40,6 +40,8 @@ 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 { 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 { 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-L2R6C5Vl.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-D-8IAEy-.mjs → index.native-BIUs8t7F.mjs}

@@ -3686,6 +3686,7 @@ const OIDC_NO_WALLET = 'This login has no embedded wallet. Enable `"auth": { "wa
     'then sign from a user gesture.';
 const PKCE_STORE_KEY = 'bounded.oidc.pkce';
 const STORED_AUTH_METHOD_KEY$1 = 'bounded_last_auth_method';
+const ISSUER_SESSION_KIND_KEY$1 = 'bounded_issuer_session_kind';
 // Active session store (Web on web, RN on React Native) — selected by config,
 // 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.
@@ -4192,6 +4193,13 @@ async function exchangeCode(code, verifier, redirectUri) {
         getPlatform().storage.setItem(STORED_AUTH_METHOD_KEY$1, 'email');
     }
     catch ( /* storage unavailable */_b) { /* storage unavailable */ }
+    // OIDC login does establish the issuer's Better Auth browser cookie. Record
+    // that fact separately from the provider name so logout clears the cookie
+    // and returns through the registered app origin.
+    try {
+        getPlatform().storage.setItem(ISSUER_SESSION_KIND_KEY$1, 'hosted');
+    }
+    catch ( /* storage unavailable */_c) { /* storage unavailable */ }
     setCurrentUser(user);
     setAuthProviderInstance(oidcProviderSingleton);
     return user;
@@ -4208,6 +4216,7 @@ const objectIdentityKeys = new WeakMap();
 let nextObjectIdentityKey = 1;
 // --- localStorage helpers: track which auth method created the active session ---
 const STORED_AUTH_METHOD_KEY = 'bounded_last_auth_method';
+const ISSUER_SESSION_KIND_KEY = 'bounded_issuer_session_kind';
 function getStoredAuthMethod() {
     try {
         return getPlatform().storage.getItem(STORED_AUTH_METHOD_KEY);
@@ -4224,11 +4233,25 @@ function setStoredAuthMethod(method) {
         else {
             getPlatform().storage.removeItem(STORED_AUTH_METHOD_KEY);
         }
+        // Non-email providers cannot own a Better Auth browser session. Clear
+        // any prior hosted/inline classification when the active provider is
+        // replaced or the session is removed.
+        if (method !== 'email') {
+            getPlatform().storage.removeItem(ISSUER_SESSION_KIND_KEY);
+        }
     }
     catch (_a) {
         // storage might not be available
     }
 }
+function getIssuerSessionKind() {
+    try {
+        return getPlatform().storage.getItem(ISSUER_SESSION_KIND_KEY);
+    }
+    catch (_a) {
+        return null;
+    }
+}
 function getStoredIdToken() {
     try {
         return getActiveSessionManager().getIdToken();
@@ -4453,7 +4476,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-deB_ADc5.mjs')).EmailAuthProvider();
+            currentAuthProvider = new (await import('./email-auth-provider-Cb4VKA1E.mjs')).EmailAuthProvider();
             break;
         case "wallet":
         case "phantom": {
@@ -4472,7 +4495,7 @@ async function getAuthProvider(config) {
             if (!isWalletLoginEnabled(config)) {
                 throw walletLoginNotEnabledError(authMethod);
             }
-            const { InjectedWalletProvider } = await import('./injected-wallet-provider-CNYAynIB.mjs');
+            const { InjectedWalletProvider } = await import('./injected-wallet-provider-ZkPzVj5W.mjs');
             currentAuthProvider = new InjectedWalletProvider(resolveInjectedWalletConfig(config), rpcUrl, configuredNetwork);
             break;
         }
@@ -4485,7 +4508,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-CJsLX16m.mjs');
+            const { InjectedEvmWalletProvider } = await import('./injected-evm-wallet-provider-DnOrVMDX.mjs');
             currentAuthProvider = new InjectedEvmWalletProvider(evmWalletConfig);
             break;
         }
@@ -4513,7 +4536,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-D9wbogwi.mjs')).GuestAuthProvider();
+            currentAuthProvider = new (await import('./guest-auth-provider-BBPpydtM.mjs')).GuestAuthProvider();
             break;
     }
     if (!currentAuthProvider) {
@@ -4569,7 +4592,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-D9wbogwi.mjs')).GuestAuthProvider();
+    const provider = new (await import('./guest-auth-provider-BBPpydtM.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
@@ -4754,7 +4777,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 {
@@ -4777,12 +4800,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 /
@@ -4807,17 +4845,20 @@ async function logout$1(options) {
     const sm = 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 revokeSession(refreshToken, sessionIssuer !== null && sessionIssuer !== void 0 ? sessionIssuer : undefined);
-    // Hosted sessions ('email' covers the whole hosted surface: email OTP +
-    // social + the OIDC redirect/popup flows) are the ones with an issuer
-    // cookie; wallet and guest sessions have nothing hosted to end.
-    // Check the STORED marker as well as the in-memory method: the hosted
-    // OIDC flows (loginWithPopup / completeLoginFromRedirect) write the
-    // 'email' marker via exchangeCode() but never touch currentAuthMethod,
-    // which stays 'guest'/explicit even after a hosted upgrade. Worst case of
-    // a false positive is a harmless idempotent issuer bounce.
-    const wasHosted = currentAuthMethod === 'email' || getStoredAuthMethod() === 'email';
+    // Only OIDC-hosted sessions own an issuer browser cookie. Turnkey-native
+    // email OTP is also an email auth method, but it mints the app session
+    // inline and has no issuer cookie to clear. Use the explicit session-kind
+    // marker when present. The auth-method fallback preserves correct logout
+    // behavior for hosted sessions created by older SDK versions.
+    const issuerSessionKind = getIssuerSessionKind();
+    const wasHosted = issuerSessionKind === 'hosted'
+        || (issuerSessionKind === null
+            && (currentAuthMethod === 'email' || getStoredAuthMethod() === 'email'));
     await currentAuthProvider.logout();
     setStoredAuthMethod(null);
     currentAuthProvider = null;
@@ -4827,7 +4868,7 @@ async function logout$1(options) {
         const issuerBase = sessionIssuer
             || (await 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)
@@ -5810,30 +5851,117 @@ async function deserializeTransaction(tx) {
 // 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;
+}
 /**
- * Open Coinbase Onramp for the signed-in user. Resolves when the popup closes.
+ * 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, _b, _c;
+    var _a;
     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');
+    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;
@@ -5846,21 +5974,17 @@ async function onramp(options = {}) {
     }
     let session;
     try {
-        const res = await fetch(`${window.location.origin}/__bounded/onramp/session`, {
+        const res = await authedFetch('/__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 } : {}))),
+            headers: { 'content-type': 'application/json' },
+            body: sessionBody(options),
         });
         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 */ }
+            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 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}` : ''})`);
+            throw new Error(`onramp: session mint failed (${res.status}${detail ? `: ${detail}` : ''})`);
         }
         session = (await res.json());
     }
@@ -5868,40 +5992,47 @@ async function onramp(options = {}) {
         try {
             popup === null || popup === void 0 ? void 0 : popup.close();
         }
-        catch ( /* ignore */_e) { /* ignore */ }
+        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 (_f) {
+        catch (_c) {
             try {
                 popup.location.href = session.url;
             }
-            catch (_g) {
+            catch (_d) {
                 try {
                     popup.close();
                 }
-                catch ( /* ignore */_h) { /* ignore */ }
-                throw new Error('onramp(): popup failed to navigate - retry with { newTab: true }');
+                catch ( /* ignore */_e) { /* ignore */ }
+                throw new Error('onramp: popup failed to navigate - retry with { newTab: true }');
             }
         }
-        return await new Promise((resolve) => {
+        await new Promise((resolve) => {
             const timer = setInterval(() => {
                 if (popup.closed) {
                     clearInterval(timer);
-                    resolve({ status: 'closed', address: session.address, asset: session.asset });
+                    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.
+    // 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 { status: 'opened', address: session.address, asset: session.asset };
+        throw new Error('onramp: window.open was blocked - call onramp() from a click handler');
+    return Object.assign(Object.assign({}, base), { status: 'opened' });
 }
 
 /**
@@ -6287,5 +6418,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, 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
+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, onrampQuote as I, onrampStatus as J, setPlatform as K, builds as L, BuildsApiError as M, NON_TERMINAL_STATES as N, OffchainAuthProvider as O, PrivyExpoProvider as P, PARK_REASONS as Q, RUN_STATES as R, FAILURE_REASONS as S, TERMINAL_STATES as T, BUILD_REVIEW_CAPABILITY_SCHEMA as U, BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA as V, BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA as W, 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-BIUs8t7F.mjs.map