@bounded-sh/client 0.0.118 → 0.0.119

package/dist/index.d.ts

@@ -17,8 +17,9 @@ export type { HostedAuthMethod, OidcLoginOptions, PopupLoginOptions } from "./au
 export { openBoundedWidget } from "./auth/bounded-login-widget";
 export type { BoundedWidgetOptions } from "./auth/bounded-login-widget";
 export { ensureSignedIn } from "./auth/ensure-signed-in";
-export { get, getMany, docId, set, setMany, setFile, getFiles, search, queryAggregate, runQuery, runQueryMany, runExpression, runExpressionMany, signMessage, signTransaction, signAndSubmitTransaction, count, aggregate, type GetOptions, type SearchOptions, type SetOptions, type CountOptions, type AggregateOptions, type AggregateOperation, type AggregateResult, type AggregateSpec, type AggregateRow, type QueryAggregateOptions, } from "@bounded-sh/core";
+export { get, getMany, docId, set, setMany, setFile, getFiles, search, queryAggregate, runQuery, runQueryMany, runExpression, runExpressionMany, signMessage, signTransaction, signAndSubmitTransaction, prepareToSign, count, aggregate, type GetOptions, type SearchOptions, type SetOptions, type CountOptions, type AggregateOptions, type AggregateOperation, type AggregateResult, type AggregateSpec, type AggregateRow, type QueryAggregateOptions, } from "@bounded-sh/core";
 export type { GetOptions as BoundedGetOptions } from "@bounded-sh/core";
+export type { SignerReadiness } from "@bounded-sh/core";
 export { reconcileSetResult, waitForSetResult } from "@bounded-sh/core";
 export type { SetResult, SetEntry, SetDocuments, MirrorSync, SolanaFence, ChainTag, SolanaChainTag, CommittedSetResult, ConfirmedSetResult, SolanaConfirmedSetResult, SubmittedSetResult, SolanaSubmittedSetResult, SolanaExpiredNotLandedSetResult, SolanaSignedSetResult, TransactionResult, TransactionReconciliation, ReconcileSetResultOptions, WaitForSetResultOptions, FileUploadResult, FileDeleteResult, } from "@bounded-sh/core";
 export { subscribe } from "@bounded-sh/core";

package/dist/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-eMCWYiRe.js');
+var index = require('./index-B4_eKphx.js');
 var core = require('@bounded-sh/core');
 require('react');
 
@@ -148,6 +148,10 @@ Object.defineProperty(exports, "getMany", {
 	enumerable: true,
 	get: function () { return core.getMany; }
 });
+Object.defineProperty(exports, "prepareToSign", {
+	enumerable: true,
+	get: function () { return core.prepareToSign; }
+});
 Object.defineProperty(exports, "queryAggregate", {
 	enumerable: true,
 	get: function () { return core.queryAggregate; }

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,5 +1,5 @@
-export { ar as BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA, aq as BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA, ap as BUILD_REVIEW_CAPABILITY_SCHEMA, ai as BuildsApiError, a6 as ConnectionError, ao as FAILURE_REASONS, ak as NON_TERMINAL_STATES, ac as OffchainAuthProvider, an as PARK_REASONS, ad as PrivyExpoProvider, am as RUN_STATES, al as TERMINAL_STATES, aa as VenueEscrowError, W as WalletConfigError, R as apps, ah as builds, a3 as completeConnection, J as completeLoginFromRedirect, a2 as connect, af as connectBroadcast, ag as connectServiceSession, p as defaultInjectedEvmProvider, f as defaultInjectedProvider, a5 as disconnect, a8 as disputeVenueEscrow, G as ensureSharedWalletLoginReady, N as ensureSignedIn, F as ensureWalletLoginReady, a7 as fundVenueEscrow, x as getAuthLoading, B as getAuthProvider, a4 as getConnections, u as getCurrentUser, _ as getIdToken, K as getLoginReturnError, U as getOrCreateTurnkeyWallet, g as getPlatform, Y as getTurnkeyWalletRecoveryUrl, X as getTurnkeyWalletSessionState, a9 as getVenueEscrow, q as init, z as login, L as loginWithPopup, D as loginWithPrivy, I as loginWithRedirect, E as loginWithWallet, A as logout, aj as mediaAgentTools, w as onAuthLoadingChanged, v as onAuthStateChanged, $ as onramp, a0 as onrampQuote, a1 as onrampStatus, M as openBoundedWidget, V as openTurnkeyKeyExport, H as preloadWalletLogin, ae as requestEip6963Providers, ab as setPlatform, C as signInAnonymously, T as signSolanaMessageViaTurnkey, Z as startTurnkeyEmailLogin, k as supportsWalletSignIn, O as useAuth, Q as useBuildRun, P as useQuery, y as waitForAuthReady } from './index-xNGb1ROp.mjs';
+export { as as BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA, ar as BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA, aq as BUILD_REVIEW_CAPABILITY_SCHEMA, aj as BuildsApiError, a7 as ConnectionError, ap as FAILURE_REASONS, al as NON_TERMINAL_STATES, ad as OffchainAuthProvider, ao as PARK_REASONS, ae as PrivyExpoProvider, an as RUN_STATES, am as TERMINAL_STATES, ab as VenueEscrowError, W as WalletConfigError, T as apps, ai as builds, a4 as completeConnection, K as completeLoginFromRedirect, a3 as connect, ag as connectBroadcast, ah as connectServiceSession, q as defaultInjectedEvmProvider, i as defaultInjectedProvider, a6 as disconnect, a9 as disputeVenueEscrow, H as ensureSharedWalletLoginReady, O as ensureSignedIn, G as ensureWalletLoginReady, a8 as fundVenueEscrow, y as getAuthLoading, C as getAuthProvider, a5 as getConnections, v as getCurrentUser, $ as getIdToken, L as getLoginReturnError, V as getOrCreateTurnkeyWallet, g as getPlatform, Z as getTurnkeyWalletRecoveryUrl, Y as getTurnkeyWalletSessionState, aa as getVenueEscrow, u as init, A as login, M as loginWithPopup, E as loginWithPrivy, J as loginWithRedirect, F as loginWithWallet, B as logout, ak as mediaAgentTools, x as onAuthLoadingChanged, w as onAuthStateChanged, a0 as onramp, a1 as onrampQuote, a2 as onrampStatus, N as openBoundedWidget, X as openTurnkeyKeyExport, I as preloadWalletLogin, af as requestEip6963Providers, ac as setPlatform, D as signInAnonymously, U as signSolanaMessageViaTurnkey, _ as startTurnkeyEmailLogin, l as supportsWalletSignIn, P as useAuth, R as useBuildRun, Q as useQuery, z as waitForAuthReady } from './index-BaXUWG8Q.mjs';
 export * from '@bounded-sh/core';
-export { AppTokenExchangeError, BoundedDeclineError, DECLINE_EVENT_NAME, RATE_LIMIT_EVENT_NAME, ScopedClientReadOnlyError, aggregate, clearAppTokenCache, count, createAppTokenAuthHeaders, createClient, deriveDecline, dispatchDeclineEvent, dispatchRateLimitEvent, docId, exchangeAppToken, get, getConfig, getFiles, getMany, queryAggregate, reconcileSetResult, runExpression, runExpressionMany, runQuery, runQueryMany, search, set, setFile, setMany, signAndSubmitTransaction, signMessage, signTransaction, subscribe, waitForSetResult } from '@bounded-sh/core';
+export { AppTokenExchangeError, BoundedDeclineError, DECLINE_EVENT_NAME, RATE_LIMIT_EVENT_NAME, ScopedClientReadOnlyError, aggregate, clearAppTokenCache, count, createAppTokenAuthHeaders, createClient, deriveDecline, dispatchDeclineEvent, dispatchRateLimitEvent, docId, exchangeAppToken, get, getConfig, getFiles, getMany, prepareToSign, queryAggregate, reconcileSetResult, runExpression, runExpressionMany, runQuery, runQueryMany, search, set, setFile, setMany, signAndSubmitTransaction, signMessage, signTransaction, subscribe, waitForSetResult } from '@bounded-sh/core';
 import 'react';
 //# sourceMappingURL=index.mjs.map

package/dist/{index.native-ByI3rRu4.js → index.native-B-pjNetI.js}

@@ -56,7 +56,18 @@ function walletOperationGuard() {
             throw new Error('wallet_session_changed');
     };
 }
-function setWalletSessionState(key, state) { }
+// This realm owns one active SDK session and one retained signer frame.
+let activeWalletState;
+function setWalletSessionState(key, state) { activeWalletState = { key, state }; }
+function walletSessionState(key) {
+    if ((activeWalletState === null || activeWalletState === void 0 ? void 0 : activeWalletState.key) !== key)
+        return { status: 'verification-required' };
+    const state = activeWalletState.state;
+    if (state.status === 'ready' && (!Number.isFinite(state.expiresAt) || state.expiresAt <= Date.now())) {
+        return { status: 'verification-required', reason: 'wallet_session_expired' };
+    }
+    return state;
+}
 
 /**
  * Platform abstraction layer for React Native compatibility.
@@ -247,6 +258,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)
@@ -4164,6 +4179,11 @@ function detachWarmSignerIframe(origin) {
     detachIframe(modal);
     return true;
 }
+/** A removed frame cannot still supply its in-memory signing session. */
+function hasWarmSignerFrame(context) {
+    var _a;
+    return Boolean(((_a = modal === null || modal === void 0 ? void 0 : modal.iframe) === null || _a === void 0 ? void 0 : _a.isConnected) && modal.iframeContext === context);
+}
 function detachIframe(m) {
     if (m.iframe) {
         try {
@@ -4205,7 +4225,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);
@@ -4248,16 +4268,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) => {
@@ -4272,17 +4296,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
@@ -4295,10 +4320,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;
@@ -4800,6 +4825,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$2())
+        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';
+}
 /**
  * Open the Bounded Turnkey approval card and sign `message` (raw bytes) with the
  * user's Turnkey wallet, resolving with the ed25519 signature and wallet address.
@@ -4836,7 +4914,7 @@ async function signSolanaMessageViaTurnkey(message) {
                 // A top-level popup keeps its signing session in the signer origin's own storage, which the
                 // warm in-app frame (a partitioned context) cannot see, so it says nothing about that frame.
                 if (transport !== 'popup')
-                    setWalletSessionState(context.key, { expiresAt: Number(d.signingSessionExpiresAt) });
+                    setWalletSessionState(context.key, { status: 'ready', expiresAt: Number(d.signingSessionExpiresAt) });
                 return { done: true, value: { signature: fromHex(d.signatureHex), address: d.address, subOrgId: String(d.subOrgId || '') } };
             }
             // The hosted signer refuses a cross-app signature inside a frame. Never retry it from here:
@@ -4952,6 +5030,7 @@ async function signAndSubmitTransactionWithTurnkey(transaction, feePayer) {
 var turnkeySignerBridge = /*#__PURE__*/Object.freeze({
     __proto__: null,
     clearTurnkeySigningSession: clearTurnkeySigningSession,
+    ensureTurnkeySigningSession: ensureTurnkeySigningSession,
     hasTurnkeyWallet: hasTurnkeyWallet,
     signAndSubmitTransactionWithTurnkey: signAndSubmitTransactionWithTurnkey,
     signMessageWithTurnkey: signMessageWithTurnkey,
@@ -5031,6 +5110,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];
     },
@@ -6086,7 +6170,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 Promise.resolve().then(function () { return require('./email-auth-provider-C-qQ46kD.js'); })).EmailAuthProvider();
+            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./email-auth-provider-wOISnCic.js'); })).EmailAuthProvider();
             break;
         case "phantom": {
             // First-class Solana WALLET LOGIN (the poof/TaroBase-style "connect
@@ -6128,7 +6212,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 Promise.resolve().then(function () { return require('./injected-wallet-provider-zXw__lyf.js'); });
+            const { InjectedWalletProvider } = await Promise.resolve().then(function () { return require('./injected-wallet-provider-BsTfBAD4.js'); });
             currentAuthProvider = new InjectedWalletProvider(resolveInjectedWalletConfig(config), rpcUrl, configuredNetwork);
             break;
         }
@@ -6141,7 +6225,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 Promise.resolve().then(function () { return require('./injected-evm-wallet-provider-BMjQaUiB.js'); });
+            const { InjectedEvmWalletProvider } = await Promise.resolve().then(function () { return require('./injected-evm-wallet-provider-DQMYqPus.js'); });
             currentAuthProvider = new InjectedEvmWalletProvider(evmWalletConfig);
             break;
         }
@@ -6166,7 +6250,7 @@ async function getAuthProvider(config, fromStorage = false) {
             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-g5-T58yA.js'); })).GuestAuthProvider();
+            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider-xap-VQBP.js'); })).GuestAuthProvider();
             break;
     }
     if (!currentAuthProvider) {
@@ -6228,7 +6312,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-g5-T58yA.js'); })).GuestAuthProvider();
+    const provider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider-xap-VQBP.js'); })).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
@@ -6399,7 +6483,7 @@ function ensureSharedWalletLoginReady() {
     if (!sharedWalletReady) {
         sharedWalletReady = (async () => {
             await core.getConfig();
-            await Promise.resolve().then(function () { return require('./injected-wallet-provider-zXw__lyf.js'); });
+            await Promise.resolve().then(function () { return require('./injected-wallet-provider-BsTfBAD4.js'); });
         })().catch((error) => {
             sharedWalletReady = null;
             throw error;
@@ -8922,6 +9006,7 @@ exports.bufferExports = bufferExports;
 exports.builds = builds;
 exports.completeLoginFromRedirect = completeLoginFromRedirect;
 exports.confirmAndCheckTransaction = confirmAndCheckTransaction;
+exports.ensureTurnkeySigningSession = ensureTurnkeySigningSession;
 exports.getAuthLoading = getAuthLoading;
 exports.getAuthProvider = getAuthProvider;
 exports.getCurrentUser = getCurrentUser;
@@ -8963,4 +9048,4 @@ exports.useBuildRun = useBuildRun;
 exports.useQuery = useQuery;
 exports.waitForAuthReady = waitForAuthReady;
 exports.walletStandardFeatureName = walletStandardFeatureName;
-//# sourceMappingURL=index.native-ByI3rRu4.js.map
+//# sourceMappingURL=index.native-B-pjNetI.js.map