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

package/dist/client/operations.d.ts

@@ -1,4 +1,4 @@
-import type { AuthProvider, MirrorSync, SetResult, SolanaSubmittedSetResult, SolanaWriteRpc } from '../types';
+import type { AuthProvider, SignerReadiness, MirrorSync, SetResult, SolanaSubmittedSetResult, SolanaWriteRpc } from '../types';
 import { type ClientConfig } from './config';
 import type { PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
 /** Internal overrides for per-request auth and headers. */
@@ -47,6 +47,14 @@ export type GrantLane = {
 };
 export type SetOptions = {
     shouldSubmitTx?: boolean;
+    /**
+     * This write takes the wallet's signature (an onchain collection). The signer is then prepared
+     * BEFORE the transaction is built: a hosted embedded wallet whose 24-hour session has lapsed
+     * collects its emailed code first, so the code never runs inside the transaction's blockhash
+     * lifetime and no build is thrown away. Without it the SDK still copes, by building again after
+     * the code, at the cost of one sponsored build left to expire.
+     */
+    onchain?: boolean;
     /**
      * Called with the signed transaction's `submitted` receipt immediately BEFORE
      * it is broadcast (Solana lanes only). Persist it to reconcile the exact
@@ -389,6 +397,16 @@ export declare function setFile(path: string, file: File | null, options?: {
 }): Promise<FileUploadResult | FileDeleteResult>;
 export declare function signMessage(message: string): Promise<string>;
 export declare function signTransaction(transaction: Transaction | VersionedTransaction): Promise<Transaction | VersionedTransaction>;
+/**
+ * Make the signed-in wallet ready to sign without delay, BEFORE the transaction it will sign
+ * exists. A hosted embedded wallet whose 24-hour signing session has lapsed collects its emailed
+ * code here; a transaction built before that code is dead by the time it is signed, because a
+ * blockhash lives about 33 seconds on mainnet (late 2026) and the code takes longer. `set` and
+ * `setMany` do this themselves before a wallet signature; call it directly before a flow that
+ * builds and signs outside them, such as a permit approval. Resolves `'established'` when a
+ * ceremony ran, else `'ready'`; a wallet that holds its own key always answers `'ready'`.
+ */
+export declare function prepareToSign(): Promise<SignerReadiness>;
 export declare function signAndSubmitTransaction(transaction: Transaction | VersionedTransaction, feePayer?: PublicKey): Promise<string>;
 /** Refresh concrete paths, or index a confirmed transaction and read its requested paths. */
 export declare function syncItems(paths: string[], options?: SetOptions, transactionSignature?: string): Promise<any>;

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
@@ -19,6 +19,12 @@ export declare function encodeBase58(bytes: Uint8Array): string;
 /** true when the base64 wire is a SIMD-0385 v1 transaction (first byte 0x81). */
 export declare function isTransactionV1Base64(serializedTransaction: string): boolean;
 export declare function deriveTransactionSignature(signedTransaction: VersionedTransaction): string;
+/**
+ * The send was refused because the transaction's blockhash is no longer current: the RPC's
+ * preflight simulation names it, and no byte entered the network. The one send failure a
+ * fresh build cures, since the bytes were right and only their lifetime ran out.
+ */
+export declare function isExpiredBlockhashRejection(error: unknown): boolean;
 export declare function isDefinitiveSolanaSendFailure(error: unknown): boolean;
 /**
  * Whether a definitive Solana send/confirm failure is the BOUNDED PROGRAM
@@ -43,6 +49,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