@bounded-sh/core 0.0.107 → 0.0.108

package/dist/client/operations.d.ts

@@ -1,4 +1,4 @@
-import type { AuthProvider, MirrorSync, SetResult, SolanaWriteRpc } from '../types';
+import type { AuthProvider, 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. */
@@ -33,6 +33,14 @@ export type RequestOverrides = {
 };
 export type SetOptions = {
     shouldSubmitTx?: boolean;
+    /**
+     * Called with the signed transaction's `submitted` receipt immediately BEFORE
+     * it is broadcast (Solana lanes only). Persist it to reconcile the exact
+     * signature and fence with `reconcileSetResult` after a lost response or a
+     * reload; a write whose hook never ran was never sent. Throwing aborts the
+     * send, and the write then fails as not applied (`before_broadcast`).
+     */
+    onBroadcast?: (receipt: SolanaSubmittedSetResult) => void | Promise<void>;
     _overrides?: RequestOverrides;
 };
 /**

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, SolanaTransactionResult } from '../types';
+import type { AuthProvider, SolanaFence, SolanaTransactionResult } from '../types';
 import type { SetOptions } from './operations';
 /**
  * Minimal base58 encoder, used ONLY to derive a Solana transaction signature
@@ -136,9 +136,15 @@ export declare function validateServerTransactionSemantics(input: {
  */
 export declare const POOFNET_VOID_FEE_PAYER = "CAXES7Tt3KGsSw4A5knQXKKUJZWsrguu6PC7SDBL4oq2";
 export declare function signPoofnetTransaction(serializedTransaction: string, authProvider: AuthProvider, options: SetOptions | undefined, expectedIntent: ExpectedWriteIntent): Promise<string>;
+/** Receives a signed transaction's identity immediately before it is broadcast; a throw aborts the send. */
+export type BeforeBroadcast = (signed: {
+    transactionSignature: string;
+    signedTransaction: string;
+    fence: SolanaFence;
+}) => void | Promise<void>;
 export declare function handlePreBuiltTransaction(tx: {
     serializedTransaction: string;
     blockhash: string;
     lastValidBlockHeight: number;
     network: string;
-}, authProvider: AuthProvider, options: SetOptions | undefined, expectedIntent: ExpectedWriteIntent): Promise<SolanaTransactionResult>;
+}, authProvider: AuthProvider, options: SetOptions | undefined, expectedIntent: ExpectedWriteIntent, beforeBroadcast?: BeforeBroadcast): Promise<SolanaTransactionResult>;

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

@@ -1,9 +1,10 @@
 import type { AuthProvider, SolanaTransactionResult } from '../types';
 import type { SetOptions } from './operations';
+import type { BeforeBroadcast } from './solana-operations';
 import { type ExpectedWriteIntent } from './solana-operations';
 export declare function handlePreBuiltV1Transaction(tx: {
     serializedTransaction: string;
     blockhash: string;
     lastValidBlockHeight: number;
     network: string;
-}, authProvider: AuthProvider, options: SetOptions | undefined, expectedIntent: ExpectedWriteIntent): Promise<SolanaTransactionResult>;
+}, authProvider: AuthProvider, options: SetOptions | undefined, expectedIntent: ExpectedWriteIntent, beforeBroadcast?: BeforeBroadcast): Promise<SolanaTransactionResult>;

package/dist/client/write-outcome.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The one tag that says a failed write was definitively NOT applied.
+ *
+ * A thrown write is otherwise ambiguous to its caller: a lost response to a
+ * committed write and a wallet that declined to sign both arrive as an Error.
+ * Treating every throw as "maybe landed" wedges money flows on a pending state
+ * that can never resolve; treating every throw as "did not land" invites a
+ * second transfer beside one that did. So the SDK marks, at the exact point it
+ * knows, the throws where nothing was or ever can be applied, and leaves every
+ * other throw unmarked (ambiguous: reconcile by reading, never by resubmitting).
+ *
+ * - `before_broadcast`: failed before any bytes were sent (response validation,
+ *   blockhash refresh, the wallet declining or failing to sign, a caller's
+ *   `onBroadcast` hook refusing). Nothing was sent.
+ * - `broadcast_rejected`: the RPC definitively refused the signed bytes
+ *   (preflight simulation, invalid transaction). They never entered the network.
+ * - `failed_onchain`: the transaction landed and failed, so the write reverted.
+ *
+ * The tag is plain data on the thrown object (`writeOutcome` + `writePhase`),
+ * so it survives bundling, duplicated SDK copies and structured cloning, and
+ * the thrown error keeps its own class (e.g. `BoundedOnchainRuleRejection`).
+ */
+export type WriteNotAppliedPhase = 'before_broadcast' | 'broadcast_rejected' | 'failed_onchain';
+export type WriteNotAppliedTag = {
+    writeOutcome: 'not_applied';
+    writePhase: WriteNotAppliedPhase;
+};
+/** Tag `error` as definitively not applied. An already-tagged error keeps its (earlier, more precise) phase. */
+export declare function markWriteNotApplied<T>(error: T, phase: WriteNotAppliedPhase): T | (Error & WriteNotAppliedTag);
+/** The phase a write stopped at when it was definitively not applied, else `null` (ambiguous or not a write error). */
+export declare function writeNotAppliedPhase(error: unknown): WriteNotAppliedPhase | null;
+export declare function isWriteNotApplied(error: unknown): boolean;