@bounded-sh/core 0.0.118-openapps.0 → 0.0.118

package/dist/client/reconcile.d.ts

@@ -23,9 +23,9 @@ export type ReconcileSetResultOptions = {
 export type WaitForSetResultOptions = ReconcileSetResultOptions & {
     /** Total wall-clock bound. Default 60s. */
     timeoutMs?: number;
-    /** Maximum reconciliation attempts. Default 20. */
+    /** Maximum reconciliation attempts. Default 60. */
     maxAttempts?: number;
-    /** Delay between attempts. Default 3s. */
+    /** Delay between attempts. Default 1s. */
     pollIntervalMs?: number;
     /** Cancels the wait. The latest `submitted` receipt is returned, never discarded. */
     signal?: AbortSignal;

package/dist/client/solana-confirm.d.ts

@@ -0,0 +1,49 @@
+import type { SolanaWriteRpc } from '../types';
+/** A signature status as `getSignatureStatuses` reports it. */
+export interface SolanaSignatureStatus {
+    slot?: number;
+    err?: unknown;
+    confirmationStatus?: string | null;
+    confirmations?: number | null;
+}
+export type SolanaConfirmation = 
+/** Seen at `confirmed` or better; `status.err` says whether it succeeded. */
+{
+    landed: true;
+    status: SolanaSignatureStatus;
+    contextSlot?: number;
+}
+/** Not seen at `confirmed` before the fence closed, or the RPC never answered usefully. */
+ | {
+    landed: false;
+    reason: string;
+};
+export interface ConfirmSignatureOptions {
+    /** Delay between status reads. Default 1s. */
+    pollIntervalMs?: number;
+    /**
+     * Wall-clock ceiling. A healthy RPC always ends the wait at the blockhash expiry (about
+     * a minute); this bounds one whose block height never advances or that fails every read.
+     * Default 120s.
+     */
+    maxWaitMs?: number;
+}
+/**
+ * Whether a status is final enough to decide on. `processed` can still belong to a fork
+ * that is dropped, so only `confirmed` or `finalized` settle a write; an RPC that omits
+ * `confirmationStatus` reports a rooted transaction as `confirmations: null`.
+ */
+export declare function settledSignatureStatus(status: SolanaSignatureStatus | null | undefined): status is SolanaSignatureStatus;
+/**
+ * Poll the SAME signature until it is seen at `confirmed` or the blockhash fence closes.
+ * Never broadcasts. A `processed` status, even one carrying an error, is not a verdict and
+ * keeps the loop going. Once the confirmed block height passes `lastValidBlockHeight`, one
+ * history-searching read decides whether the transaction landed anyway; if not, the answer
+ * is "not seen" or "seen only below confirmed", never "never landed": only a finalized
+ * expiry proves that, which is `reconcileSetResult`'s job. Transient RPC failures retry the
+ * same signature.
+ */
+export declare function confirmSignature(rpc: SolanaWriteRpc, fence: {
+    signature: string;
+    lastValidBlockHeight: number;
+}, options?: ConfirmSignatureOptions): Promise<SolanaConfirmation>;

package/dist/client/solana-operations.d.ts

@@ -1,6 +1,6 @@
 export { getTransactionJson, SOLANA_MAX_SUPPORTED_TRANSACTION_VERSION } from './solana-transaction-read';
 import type { VersionedTransaction } from '@solana/web3.js';
-import type { AuthProvider, SolanaFence, SolanaTransactionResult } from '../types';
+import type { AuthProvider, SolanaFence, SolanaTransactionResult, SolanaWriteRpc } from '../types';
 import type { SetOptions } from './operations';
 /**
  * Minimal base58 encoder, used ONLY to derive a Solana transaction signature
@@ -43,6 +43,12 @@ export declare class BoundedOnchainRuleRejection extends Error {
     constructor(cause: unknown, extraLogs?: unknown);
 }
 export declare function errorText(error: unknown): string;
+/**
+ * The tagged failure for a transaction that LANDED and failed on-chain: a Bounded
+ * rule/invariant rejection when the logs say so, otherwise the raw error, with the
+ * program logs attached whenever the RPC can still read them.
+ */
+export declare function landedTransactionFailure(rpc: SolanaWriteRpc, signature: string, err: unknown): Promise<Error>;
 /**
  * One expected field operation, derived from the caller's request document.
  * `value`/`delta` are the JSON-round-tripped request values (what the server

package/dist/{index-C6ZW5Gt2.mjs → index-BXfRRAUZ.mjs}

@@ -4305,7 +4305,7 @@ class ServerSessionManager {
         const sessionConfig = (_a = this.sessionConfig) !== null && _a !== void 0 ? _a : undefined;
         /* fetch nonce from auth API (bound to the snapshotted app+issuer) */
         const nonce = await genAuthNonce(sessionConfig);
-        const { genSolanaMessage } = await import('./solana-message-CEjXjnaG.mjs');
+        const { genSolanaMessage } = await import('./solana-message-CjI0h27k.mjs');
         const message = await genSolanaMessage(address, nonce, sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.appId);
         /* sign the message */
         const sigBytes = nacl.sign.detached(new TextEncoder().encode(message), kp.secretKey);
@@ -7677,7 +7677,7 @@ async function doReconnectWithNewAuth() {
         console.warn('[WS v2] Failed to clear HTTP read cache on auth change:', error);
     }
     try {
-        const { reconnectRealtimeStoreWithNewAuth } = await import('./realtime-store-FUjGL_Z8.mjs');
+        const { reconnectRealtimeStoreWithNewAuth } = await import('./realtime-store-BreUReSo.mjs');
         await reconnectRealtimeStoreWithNewAuth();
     }
     catch (error) {
@@ -8896,7 +8896,7 @@ function buildRequestedDocuments(documents) {
 /** Best-effort readback, including a failure to load its lazy implementation. */
 async function attemptMirrorSync(paths, options, transactionSignature) {
     try {
-        const mirror = await import('./mirror-sync-kt9PzQen.mjs');
+        const mirror = await import('./mirror-sync-DoH9ewTo.mjs');
         return await mirror.attemptMirrorSync(paths, options, transactionSignature);
     }
     catch (error) {
@@ -9116,7 +9116,7 @@ async function setMany(many, options) {
                     if (typeof curTx.serializedTransaction !== 'string' || typeof curTx.poofnetIntentId !== 'string') {
                         throw new Error('Unsupported 202 transaction shape: a poofnet write needs serializedTransaction and poofnetIntentId');
                     }
-                    const { signPoofnetTransaction, buildExpectedWriteIntent } = await import('./solana-operations-5WjFwhnt.mjs');
+                    const { signPoofnetTransaction, buildExpectedWriteIntent } = await import('./solana-operations-CD6pks4-.mjs');
                     const signedTransaction = await signPoofnetTransaction(curTx.serializedTransaction, authProvider, options, buildExpectedWriteIntent(documents));
                     // Signing-only, exactly as on a real chain: signed and NOT committed.
                     if ((options === null || options === void 0 ? void 0 : options.shouldSubmitTx) === false) {
@@ -9154,7 +9154,7 @@ async function setMany(many, options) {
                             'Nothing was signed or submitted.');
                     }
                     const solanaChain = workerChain;
-                    const { handlePreBuiltTransaction, buildExpectedWriteIntent } = await import('./solana-operations-5WjFwhnt.mjs');
+                    const { handlePreBuiltTransaction, buildExpectedWriteIntent } = await import('./solana-operations-CD6pks4-.mjs');
                     // OA-0001: derive the expected intent from OUR OWN request (the one
                     // ground truth a tampered builder response cannot change) so the
                     // validator can reject any transaction whose operation semantics
@@ -9494,9 +9494,81 @@ var operations = /*#__PURE__*/Object.freeze({
     signTransaction: signTransaction
 });
 
+const DEFAULT_POLL_INTERVAL_MS$1 = 1000;
+const DEFAULT_MAX_WAIT_MS = 120000;
+/**
+ * Whether a status is final enough to decide on. `processed` can still belong to a fork
+ * that is dropped, so only `confirmed` or `finalized` settle a write; an RPC that omits
+ * `confirmationStatus` reports a rooted transaction as `confirmations: null`.
+ */
+function settledSignatureStatus(status) {
+    if (!status)
+        return false;
+    if (status.confirmationStatus === 'confirmed' || status.confirmationStatus === 'finalized')
+        return true;
+    return status.confirmationStatus == null && status.confirmations === null;
+}
+/**
+ * Poll the SAME signature until it is seen at `confirmed` or the blockhash fence closes.
+ * Never broadcasts. A `processed` status, even one carrying an error, is not a verdict and
+ * keeps the loop going. Once the confirmed block height passes `lastValidBlockHeight`, one
+ * history-searching read decides whether the transaction landed anyway; if not, the answer
+ * is "not seen" or "seen only below confirmed", never "never landed": only a finalized
+ * expiry proves that, which is `reconcileSetResult`'s job. Transient RPC failures retry the
+ * same signature.
+ */
+async function confirmSignature(rpc, fence, options = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    if (typeof rpc.getSignatureStatuses !== 'function' || typeof rpc.getBlockHeight !== 'function') {
+        // An injected RPC that cannot answer is reported at once, not retried for two minutes.
+        return { landed: false, reason: 'the configured Solana RPC cannot report signature statuses and block height' };
+    }
+    const pollIntervalMs = (_a = options.pollIntervalMs) !== null && _a !== void 0 ? _a : DEFAULT_POLL_INTERVAL_MS$1;
+    const maxWaitMs = (_b = options.maxWaitMs) !== null && _b !== void 0 ? _b : DEFAULT_MAX_WAIT_MS;
+    const startedAt = Date.now();
+    let lastFailure = null;
+    for (;;) {
+        try {
+            // Status first: a settled status decides on its own, and the height is read only
+            // while the transaction is still unseen, so a failing height read never discards
+            // a confirmation this tick already has.
+            const statuses = await rpc.getSignatureStatuses([fence.signature]);
+            const status = (_d = (_c = statuses === null || statuses === void 0 ? void 0 : statuses.value) === null || _c === void 0 ? void 0 : _c[0]) !== null && _d !== void 0 ? _d : null;
+            if (settledSignatureStatus(status))
+                return { landed: true, status, contextSlot: (_e = statuses === null || statuses === void 0 ? void 0 : statuses.context) === null || _e === void 0 ? void 0 : _e.slot };
+            const blockHeight = await rpc.getBlockHeight('confirmed');
+            if (blockHeight > fence.lastValidBlockHeight) {
+                const history = await rpc.getSignatureStatuses([fence.signature], { searchTransactionHistory: true });
+                const late = (_g = (_f = history === null || history === void 0 ? void 0 : history.value) === null || _f === void 0 ? void 0 : _f[0]) !== null && _g !== void 0 ? _g : null;
+                if (settledSignatureStatus(late))
+                    return { landed: true, status: late, contextSlot: (_h = history === null || history === void 0 ? void 0 : history.context) === null || _h === void 0 ? void 0 : _h.slot };
+                const seen = late ? `seen only at ${String((_j = late.confirmationStatus) !== null && _j !== void 0 ? _j : 'an unconfirmed')} commitment` : 'not seen at confirmed';
+                return {
+                    landed: false,
+                    reason: `${seen} before the blockhash expired (block height ${blockHeight} is past ${fence.lastValidBlockHeight})`,
+                };
+            }
+            lastFailure = null;
+        }
+        catch (error) {
+            // Transient: keep polling the same signature. The ceiling below bounds a dead RPC.
+            lastFailure = error instanceof Error ? error.message : String(error);
+        }
+        if (Date.now() - startedAt >= maxWaitMs) {
+            return {
+                landed: false,
+                reason: lastFailure
+                    ? `the RPC kept failing while the transaction was awaited: ${lastFailure}`
+                    : `not seen at confirmed within ${Math.round(maxWaitMs / 1000)}s and the block height never passed the blockhash fence`,
+            };
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+}
+
 const DEFAULT_TIMEOUT_MS = 60000;
-const DEFAULT_MAX_ATTEMPTS$1 = 20;
-const DEFAULT_POLL_INTERVAL_MS = 3000;
+const DEFAULT_MAX_ATTEMPTS$1 = 60;
+const DEFAULT_POLL_INTERVAL_MS = 1000;
 function errorText(error) {
     const message = error === null || error === void 0 ? void 0 : error.message;
     return typeof message === 'string' && message.length > 0 ? message : String(error);
@@ -9564,18 +9636,6 @@ async function resolveSolanaRpc(config, options) {
     const { Connection } = await import('@solana/web3.js');
     return new Connection(rpcUrl, 'confirmed');
 }
-/**
- * Whether a signature status is final enough to decide on. `processed` can still belong to a fork
- * that is dropped, so only `confirmed` or `finalized` settle a write; an RPC that omits
- * `confirmationStatus` reports a rooted transaction as `confirmations: null`.
- */
-function settledStatus(status) {
-    if (!status)
-        return false;
-    if (status.confirmationStatus === 'confirmed' || status.confirmationStatus === 'finalized')
-        return true;
-    return status.confirmationStatus == null && status.confirmations === null;
-}
 /**
  * Solana reconciliation NEVER broadcasts. It settles on a `confirmed` or `finalized` status only,
  * and reaches `expired_not_landed` only from the chain's own blockhash expiry: the FINALIZED block
@@ -9587,17 +9647,13 @@ function settledStatus(status) {
 async function reconcileSolana(receipt, config, options) {
     var _a, _b, _c, _d;
     const rpc = await resolveSolanaRpc(config, options);
-    if (typeof rpc.getSignatureStatuses !== 'function') {
-        return stillSubmitted(receipt, 'the configured Solana RPC cannot report signature statuses');
-    }
     // Expiry is read BEFORE the status, so an absence observed afterwards is an absence after the
     // fence closed for good. A finalized height past lastValidBlockHeight is final: the blockhash
     // can never become valid again.
     let finalizedHeight;
     let finalizedSlot;
     try {
-        if (typeof rpc.getBlockHeight === 'function')
-            finalizedHeight = await rpc.getBlockHeight('finalized');
+        finalizedHeight = await rpc.getBlockHeight('finalized');
         if (typeof rpc.getSlot === 'function')
             finalizedSlot = await rpc.getSlot('finalized');
     }
@@ -9616,7 +9672,7 @@ async function reconcileSolana(receipt, config, options) {
         return stillSubmitted(receipt, `signature status lookup failed: ${errorText(error)}`);
     }
     if (statusValue) {
-        if (!settledStatus(statusValue)) {
+        if (!settledSignatureStatus(statusValue)) {
             return stillSubmitted(receipt, `seen at ${String((_d = statusValue.confirmationStatus) !== null && _d !== void 0 ? _d : 'an unconfirmed')} commitment; waiting for confirmed`);
         }
         // Landed. A landed-but-failed transaction is a genuine failure, not `submitted`.
@@ -10986,7 +11042,7 @@ function toMillis(seconds) {
 
 /** SIWS message creation is async already, so its onchain module can be lazy. */
 async function genSolanaMessage(address, nonce) {
-    const implementation = await import('./solana-message-CEjXjnaG.mjs');
+    const implementation = await import('./solana-message-CjI0h27k.mjs');
     return implementation.genSolanaMessage(address, nonce);
 }
 
@@ -11535,5 +11591,5 @@ function defineLiveModule(mod) {
     return mod;
 }
 
-export { dispatchRateLimitEvent as $, waitForSetResult as A, isWriteNotApplied as B, writeNotAppliedPhase as C, subscribe as D, closeAllSubscriptions as E, clearCache as F, getCachedData as G, reconnectWithNewAuth as H, InsufficientBalanceError as I, createClient as J, exchangeAppToken as K, clearAppTokenCache as L, createAppTokenAuthHeaders as M, AppTokenExchangeError as N, setWithVenueGrant as O, resolveVenueRpcUrl as P, subscribeQuery as Q, closeAllQuerySubscriptions as R, ScopedClientReadOnlyError as S, canonicalizeArgs as T, canonicalizeResult as U, DEFAULT_QUERY_POLL_INTERVAL_MS as V, MIN_QUERY_POLL_INTERVAL_MS as W, BoundedDeclineError as X, deriveDecline as Y, dispatchDeclineEvent as Z, DECLINE_EVENT_NAME as _, markWriteNotApplied as a, RATE_LIMIT_EVENT_NAME as a0, hasActiveConnection as a1, increment as a2, serverTimestamp as a3, now as a4, toSeconds as a5, toMillis as a6, getIdToken as a7, deriveUserIdentityFromIdToken as a8, getSessionGeneration as a9, genSiweMessage as aA, normalizeEvmAddress as aB, toLowerEvmAddress as aC, functions as aD, invoke as aE, FunctionInvokeError as aF, live as aG, intent as aH, status as aI, subscribeView as aJ, LiveIntentError as aK, withEffects as aL, isEffectResult as aM, defineLiveModule as aN, EFFECT_INTENT_ADDRESS as aO, WebSessionManager as aa, ReactNativeSessionManager as ab, getActiveSessionManager as ac, onSessionCleared as ad, announceSessionChange as ae, onSessionChange as af, SESSION_SIGNAL_CHANNEL as ag, SessionEnvironmentError as ah, UNSUPPORTED_ENVIRONMENT_CODE as ai, AUTH_CHANGED_CODE as aj, AUTH_EXPIRED_CODE as ak, isAuthExpiredError as al, getFreshAuthToken as am, ServerSessionManager as an, createSessionWithSignature as ao, refreshSession as ap, revokeSession as aq, signSessionCreateMessage as ar, genAuthNonce as as, genSolanaMessage as at, createSolanaSignInRequest as au, createSolanaSignInMessageText as av, genSolanaSignInRequest as aw, genSolanaSignInMessage as ax, browserSignInDomain as ay, SOLANA_SIGN_IN_STATEMENT as az, bufferExports as b, getWebhookKeysUrl as c, getConfiguredAppId as d, get as e, getMany as f, getConfig as g, docId as h, init as i, setMany as j, setFile as k, getFiles as l, makeApiRequest as m, search as n, runQueryMany as o, runExpression as p, queryAggregate as q, runQuery as r, set as s, runExpressionMany as t, signMessage as u, signTransaction as v, signAndSubmitTransaction as w, count as x, aggregate as y, reconcileSetResult as z };
-//# sourceMappingURL=index-C6ZW5Gt2.mjs.map
+export { DECLINE_EVENT_NAME as $, reconcileSetResult as A, waitForSetResult as B, isWriteNotApplied as C, writeNotAppliedPhase as D, subscribe as E, closeAllSubscriptions as F, clearCache as G, getCachedData as H, InsufficientBalanceError as I, reconnectWithNewAuth as J, createClient as K, exchangeAppToken as L, clearAppTokenCache as M, createAppTokenAuthHeaders as N, AppTokenExchangeError as O, setWithVenueGrant as P, resolveVenueRpcUrl as Q, subscribeQuery as R, ScopedClientReadOnlyError as S, closeAllQuerySubscriptions as T, canonicalizeArgs as U, canonicalizeResult as V, DEFAULT_QUERY_POLL_INTERVAL_MS as W, MIN_QUERY_POLL_INTERVAL_MS as X, BoundedDeclineError as Y, deriveDecline as Z, dispatchDeclineEvent as _, markWriteNotApplied as a, dispatchRateLimitEvent as a0, RATE_LIMIT_EVENT_NAME as a1, hasActiveConnection as a2, increment as a3, serverTimestamp as a4, now as a5, toSeconds as a6, toMillis as a7, getIdToken as a8, deriveUserIdentityFromIdToken as a9, SOLANA_SIGN_IN_STATEMENT as aA, genSiweMessage as aB, normalizeEvmAddress as aC, toLowerEvmAddress as aD, functions as aE, invoke as aF, FunctionInvokeError as aG, live as aH, intent as aI, status as aJ, subscribeView as aK, LiveIntentError as aL, withEffects as aM, isEffectResult as aN, defineLiveModule as aO, EFFECT_INTENT_ADDRESS as aP, getSessionGeneration as aa, WebSessionManager as ab, ReactNativeSessionManager as ac, getActiveSessionManager as ad, onSessionCleared as ae, announceSessionChange as af, onSessionChange as ag, SESSION_SIGNAL_CHANNEL as ah, SessionEnvironmentError as ai, UNSUPPORTED_ENVIRONMENT_CODE as aj, AUTH_CHANGED_CODE as ak, AUTH_EXPIRED_CODE as al, isAuthExpiredError as am, getFreshAuthToken as an, ServerSessionManager as ao, createSessionWithSignature as ap, refreshSession as aq, revokeSession as ar, signSessionCreateMessage as as, genAuthNonce as at, genSolanaMessage as au, createSolanaSignInRequest as av, createSolanaSignInMessageText as aw, genSolanaSignInRequest as ax, genSolanaSignInMessage as ay, browserSignInDomain as az, bufferExports as b, confirmSignature as c, getWebhookKeysUrl as d, getConfiguredAppId as e, get as f, getConfig as g, getMany as h, init as i, docId as j, setMany as k, setFile as l, makeApiRequest as m, getFiles as n, search as o, runQueryMany as p, queryAggregate as q, runQuery as r, set as s, runExpression as t, runExpressionMany as u, signMessage as v, signTransaction as w, signAndSubmitTransaction as x, count as y, aggregate as z };
+//# sourceMappingURL=index-BXfRRAUZ.mjs.map