@augustdigital/sdk 8.19.0 → 8.21.0

package/lib/adapters/solana/index.d.ts

@@ -7,7 +7,7 @@ import * as SolanaConstants from './constants';
 import * as SolanaGetters from './getters';
 import * as SolanaActions from './vault.actions';
 import type { AnchorProvider, web3 } from '@coral-xyz/anchor';
-import { Connection, PublicKey, type Transaction } from '@solana/web3.js';
+import { type Commitment, Connection, PublicKey, type Transaction } from '@solana/web3.js';
 import type { ISolanaNetwork, ISolanaRpcEndpoint } from './types';
 import type { SendTransactionOptions } from '@solana/wallet-adapter-base';
 export declare const Solana: {
@@ -61,11 +61,11 @@ export declare const Solana: {
         fetchUserTokenBalance: ({ connection, publicKey, depositMint, }: {
             publicKey: PublicKey | string;
             depositMint?: PublicKey | string;
-        } & import("./types").ISolanaConnectionOptions) => Promise<any>;
+        } & import("./types").ISolanaConnectionOptions) => Promise<string>;
         fetchUserShareBalance: ({ connection, publicKey, shareMint, }: {
             publicKey: PublicKey | string;
             shareMint?: PublicKey | string;
-        } & import("./types").ISolanaConnectionOptions) => Promise<any>;
+        } & import("./types").ISolanaConnectionOptions) => Promise<number>;
         fetchUserShareBalanceRaw: ({ connection, publicKey, shareMint, }: {
             publicKey: PublicKey | string;
             shareMint?: PublicKey | string;
@@ -119,7 +119,23 @@ declare class SolanaAdapter {
     private _network;
     private _connection;
     private _provider;
-    constructor(endpoint: ISolanaRpcEndpoint, network?: ISolanaNetwork);
+    /**
+     * @param commitment - Commitment for every read this adapter makes *and* for
+     *   the confirmation of every write, so the two always describe the same
+     *   chain state — the vault handlers take it from this same `Connection`.
+     *
+     *   Defaults to `'finalized'`, which is what this adapter has always used in
+     *   practice: it previously passed no commitment at all, so both reads and
+     *   confirmations fell through to the RPC's own `'finalized'` default. The
+     *   default is stated explicitly now rather than inherited, but it is
+     *   unchanged.
+     *
+     *   Pass `'confirmed'` for a markedly faster round trip — seconds rather
+     *   than tens of seconds — accepting that the state you act on can still, in
+     *   principle, be rolled back. Also settable as the `commitment` field of
+     *   the `solana` config passed to `AugustSDK`.
+     */
+    constructor(endpoint: ISolanaRpcEndpoint, network?: ISolanaNetwork, commitment?: Commitment);
     get endpoint(): `https://${string}`;
     get network(): ISolanaNetwork;
     get connection(): web3.Connection;
@@ -171,8 +187,8 @@ declare class SolanaAdapter {
         image: string;
     }>;
     getTokenSymbol(mintAddress: string | PublicKey): Promise<string>;
-    fetchUserTokenBalance(publicKey: PublicKey | string, depositMint: PublicKey | string): Promise<any>;
-    fetchUserShareBalance(publicKey: PublicKey | string, shareMint: PublicKey | string): Promise<any>;
+    fetchUserTokenBalance(publicKey: PublicKey | string, depositMint: PublicKey | string): Promise<string>;
+    fetchUserShareBalance(publicKey: PublicKey | string, shareMint: PublicKey | string): Promise<number>;
     /**
      * BigInt-safe variant of {@link fetchUserShareBalance}. Returns the raw u64
      * `amount` (as a base-units string) plus the mint's `decimals` (or `null`
@@ -212,13 +228,31 @@ declare class SolanaAdapter {
     /**
      * Deposit funds into a Solana August vault.
      * @param depositAmount  `bigint` (raw on-chain units) or `number` (UI amount).
+     * @param sendTransaction - **Ignored; scheduled for removal (AUGUST-7221).**
+     *   Share-account creation is now prepended to the deposit instruction, so
+     *   the SDK sends no second transaction and never invokes this callback —
+     *   signing goes through the provider's wallet.
+     *
+     *   **Pass `undefined` here; do not delete the argument.** It sits *before*
+     *   `vaultAddress`, so removing it shifts your vault address into this slot
+     *   and leaves `vaultAddress` undefined — which silently falls back to the
+     *   legacy single-vault PDA derivation and targets a different vault.
      */
-    vaultDeposit(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, depositAmount: number | bigint, sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
+    vaultDeposit(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, depositAmount: number | bigint, sendTransaction?: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
     /**
      * Redeem vault shares from a Solana August vault.
      * @param redeemShares  `bigint` (raw share units) or `number` (UI amount).
+     * @param sendTransaction - **Ignored; scheduled for removal (AUGUST-7221).**
+     *   Payout- and fee-recipient-account creation is now prepended to the redeem
+     *   instruction, so the SDK sends no second transaction and never invokes
+     *   this callback — signing goes through the provider's wallet.
+     *
+     *   **Pass `undefined` here; do not delete the argument.** It sits *before*
+     *   `vaultAddress`, so removing it shifts your vault address into this slot
+     *   and leaves `vaultAddress` undefined — which silently falls back to the
+     *   legacy single-vault PDA derivation and targets a different vault.
      */
-    vaultRedeem(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, redeemShares: number | bigint, sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
+    vaultRedeem(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, redeemShares: number | bigint, sendTransaction?: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
     /**
      * Canonical program id for a program type on this adapter's network.
      *

package/lib/adapters/solana/index.js

@@ -68,10 +68,29 @@ class SolanaAdapter {
     _network;
     _connection;
     _provider;
-    constructor(endpoint, network = utils_1.SolanaUtils.fallbackNetwork) {
+    /**
+     * @param commitment - Commitment for every read this adapter makes *and* for
+     *   the confirmation of every write, so the two always describe the same
+     *   chain state — the vault handlers take it from this same `Connection`.
+     *
+     *   Defaults to `'finalized'`, which is what this adapter has always used in
+     *   practice: it previously passed no commitment at all, so both reads and
+     *   confirmations fell through to the RPC's own `'finalized'` default. The
+     *   default is stated explicitly now rather than inherited, but it is
+     *   unchanged.
+     *
+     *   Pass `'confirmed'` for a markedly faster round trip — seconds rather
+     *   than tens of seconds — accepting that the state you act on can still, in
+     *   principle, be rolled back. Also settable as the `commitment` field of
+     *   the `solana` config passed to `AugustSDK`.
+     */
+    constructor(endpoint, network = utils_1.SolanaUtils.fallbackNetwork, commitment = 'finalized') {
         this._endpoint = endpoint;
         this._network = network;
-        const connection = new web3_js_1.Connection(endpoint);
+        // Explicit rather than inherited: left unset, web3.js omits the parameter
+        // and the RPC applies its own default, which is the same 'finalized' —
+        // but then nothing ties it to the commitment writes confirm at.
+        const connection = new web3_js_1.Connection(endpoint, commitment);
         this._connection = connection;
         this._provider = utils_1.SolanaUtils.getReadOnlyProvider({
             network: this._network,
@@ -238,6 +257,15 @@ class SolanaAdapter {
     /**
      * Deposit funds into a Solana August vault.
      * @param depositAmount  `bigint` (raw on-chain units) or `number` (UI amount).
+     * @param sendTransaction - **Ignored; scheduled for removal (AUGUST-7221).**
+     *   Share-account creation is now prepended to the deposit instruction, so
+     *   the SDK sends no second transaction and never invokes this callback —
+     *   signing goes through the provider's wallet.
+     *
+     *   **Pass `undefined` here; do not delete the argument.** It sits *before*
+     *   `vaultAddress`, so removing it shifts your vault address into this slot
+     *   and leaves `vaultAddress` undefined — which silently falls back to the
+     *   legacy single-vault PDA derivation and targets a different vault.
      */
     async vaultDeposit(vaultProgramId, idl, publicKey, depositAmount, sendTransaction, vaultAddress) {
         return await (0, vault_actions_1.handleSolanaDeposit)({
@@ -255,6 +283,15 @@ class SolanaAdapter {
     /**
      * Redeem vault shares from a Solana August vault.
      * @param redeemShares  `bigint` (raw share units) or `number` (UI amount).
+     * @param sendTransaction - **Ignored; scheduled for removal (AUGUST-7221).**
+     *   Payout- and fee-recipient-account creation is now prepended to the redeem
+     *   instruction, so the SDK sends no second transaction and never invokes
+     *   this callback — signing goes through the provider's wallet.
+     *
+     *   **Pass `undefined` here; do not delete the argument.** It sits *before*
+     *   `vaultAddress`, so removing it shifts your vault address into this slot
+     *   and leaves `vaultAddress` undefined — which silently falls back to the
+     *   legacy single-vault PDA derivation and targets a different vault.
      */
     async vaultRedeem(vaultProgramId, idl, publicKey, redeemShares, sendTransaction, vaultAddress) {
         return await (0, vault_actions_1.handleSolanaRedeem)({

package/lib/adapters/solana/utils.d.ts

@@ -1,5 +1,5 @@
 import { AnchorProvider, BN, Program, type web3 } from '@coral-xyz/anchor';
-import { PublicKey, type Transaction } from '@solana/web3.js';
+import { PublicKey, type ParsedAccountData, type Transaction } from '@solana/web3.js';
 import type { ISolanaConnectionOptions, ISolanaVaultState } from './types';
 declare function getExplorerLink({ signature, type, network, }: {
     signature: string;
@@ -58,14 +58,65 @@ declare function getToken({ mintAddress, endpoint, connection, }: {
 declare function getTokenSymbol({ endpoint, mintAddress, }: {
     mintAddress: string | PublicKey;
 } & ISolanaConnectionOptions): Promise<string | null>;
+/**
+ * A wallet's token account of record for one mint: the account holding the
+ * largest balance.
+ *
+ * **This is the single selection rule for the whole Solana adapter.** Reads
+ * (balances shown in a UI) and writes (the account a transfer actually names)
+ * must agree on which account represents the user, or the two describe
+ * different money: a balance read from account A while a deposit mints into
+ * account B looks, to the user, like a successful transaction that never
+ * arrived. Every reader in this file and both vault handlers call this, so the
+ * rule cannot drift.
+ *
+ * Largest-balance rather than "the first account the RPC returned":
+ * `getParsedTokenAccountsByOwner` guarantees no ordering, so taking `[0]` can
+ * select an empty leftover while the user's funds sit in a sibling account —
+ * which fails on-chain as an insufficient-funds revert *after* they sign.
+ *
+ * **Spendable accounts win over frozen ones**, regardless of balance: a token
+ * issuer can freeze an account, and neither a transfer out of nor a transfer
+ * into a frozen account can succeed. Picking the richest account outright would
+ * hand a frozen one to the program and revert with SPL `0x11` after the user
+ * signs, while a perfectly usable sibling sat next to it. When *every* account
+ * is frozen the richest frozen one is still returned, flagged — a reader should
+ * show that balance, because the user does own it, and a writer should refuse
+ * before asking for a signature.
+ *
+ * Internal to the adapter: exported for `vault.actions.ts`, deliberately not
+ * re-exported on `SolanaUtils`. It takes a raw RPC response shape, which is not
+ * a contract worth freezing on the public surface.
+ *
+ * @param accounts - The `.value` array from `getParsedTokenAccountsByOwner`.
+ * @returns The selected account with its raw balance, decimals, the RPC's own
+ *   `uiAmount`, and whether it is frozen — or `undefined` when the wallet owns
+ *   no account for the mint.
+ * @throws AugustSDKError when an account's balance cannot be read. An
+ *   unreadable balance is *unknown*, not zero — scoring it zero would silently
+ *   demote a funded account below a dust one and reinstate the `[0]` behaviour
+ *   this function exists to prevent.
+ */
+export declare function selectRichestTokenAccount(accounts: {
+    pubkey: PublicKey;
+    account: {
+        data: ParsedAccountData | Buffer;
+    };
+}[]): {
+    pubkey: PublicKey;
+    amount: bigint;
+    decimals: number | null;
+    uiAmount: number | null;
+    frozen: boolean;
+} | undefined;
 declare function fetchUserTokenBalance({ connection, publicKey, depositMint, }: {
     publicKey: PublicKey | string;
     depositMint?: PublicKey | string;
-} & ISolanaConnectionOptions): Promise<any>;
+} & ISolanaConnectionOptions): Promise<string>;
 declare function fetchUserShareBalance({ connection, publicKey, shareMint, }: {
     publicKey: PublicKey | string;
     shareMint?: PublicKey | string;
-} & ISolanaConnectionOptions): Promise<any>;
+} & ISolanaConnectionOptions): Promise<number>;
 /**
  * Same on-chain lookup as `fetchUserShareBalance`, but returns the raw u64
  * `amount` string and the mint's `decimals` — or `null` when the scale can't

package/lib/adapters/solana/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaUtils = exports.isSolanaAddress = void 0;
+exports.selectRichestTokenAccount = selectRichestTokenAccount;
 exports.uiAmountToRawBn = uiAmountToRawBn;
 const anchor_1 = require("@coral-xyz/anchor");
 const web3_js_1 = require("@solana/web3.js");
@@ -103,7 +104,11 @@ function getProvider({ connection, publicKey, signTransaction, }) {
             const signedTransactions = await Promise.all(txs.map(async (tx) => signTransaction(tx)));
             return signedTransactions;
         },
-    }, { commitment: 'confirmed' });
+    }, 
+    // Inherited from the connection, not hard-coded: a caller who configured
+    // the adapter for 'finalized' must not have writes issued through
+    // `getProgram(...).methods…rpc()` confirm at something weaker.
+    { commitment: connection.commitment ?? 'finalized' });
 }
 // Read-only provider for data fetching without wallet connection
 function getReadOnlyProvider({ connection }) {
@@ -117,8 +122,10 @@ function getReadOnlyProvider({ connection }) {
             throw new core_1.AugustValidationError('INVALID_INPUT', 'Cannot sign transactions with read-only provider');
         },
     };
+    // See `getProvider` — the connection is the single source of truth for
+    // commitment, so reads through this provider match reads made directly.
     return new anchor_1.AnchorProvider(connection, dummyWallet, {
-        commitment: 'confirmed',
+        commitment: connection.commitment ?? 'finalized',
     });
 }
 // ============================================================================
@@ -440,6 +447,87 @@ async function getTokenSymbol({ endpoint, mintAddress, }) {
         return null;
     }
 }
+/**
+ * A wallet's token account of record for one mint: the account holding the
+ * largest balance.
+ *
+ * **This is the single selection rule for the whole Solana adapter.** Reads
+ * (balances shown in a UI) and writes (the account a transfer actually names)
+ * must agree on which account represents the user, or the two describe
+ * different money: a balance read from account A while a deposit mints into
+ * account B looks, to the user, like a successful transaction that never
+ * arrived. Every reader in this file and both vault handlers call this, so the
+ * rule cannot drift.
+ *
+ * Largest-balance rather than "the first account the RPC returned":
+ * `getParsedTokenAccountsByOwner` guarantees no ordering, so taking `[0]` can
+ * select an empty leftover while the user's funds sit in a sibling account —
+ * which fails on-chain as an insufficient-funds revert *after* they sign.
+ *
+ * **Spendable accounts win over frozen ones**, regardless of balance: a token
+ * issuer can freeze an account, and neither a transfer out of nor a transfer
+ * into a frozen account can succeed. Picking the richest account outright would
+ * hand a frozen one to the program and revert with SPL `0x11` after the user
+ * signs, while a perfectly usable sibling sat next to it. When *every* account
+ * is frozen the richest frozen one is still returned, flagged — a reader should
+ * show that balance, because the user does own it, and a writer should refuse
+ * before asking for a signature.
+ *
+ * Internal to the adapter: exported for `vault.actions.ts`, deliberately not
+ * re-exported on `SolanaUtils`. It takes a raw RPC response shape, which is not
+ * a contract worth freezing on the public surface.
+ *
+ * @param accounts - The `.value` array from `getParsedTokenAccountsByOwner`.
+ * @returns The selected account with its raw balance, decimals, the RPC's own
+ *   `uiAmount`, and whether it is frozen — or `undefined` when the wallet owns
+ *   no account for the mint.
+ * @throws AugustSDKError when an account's balance cannot be read. An
+ *   unreadable balance is *unknown*, not zero — scoring it zero would silently
+ *   demote a funded account below a dust one and reinstate the `[0]` behaviour
+ *   this function exists to prevent.
+ */
+function selectRichestTokenAccount(accounts) {
+    const parsed = accounts.map((entry) => {
+        const info = entry.account.data?.parsed?.info;
+        const tokenAmount = info?.tokenAmount;
+        const raw = tokenAmount?.amount;
+        // A u64 string is the only shape the RPC promises here. Anything else
+        // (a base64 `data` the node could not jsonParse, a reshaping proxy) means
+        // we do not know this balance.
+        if (typeof raw !== 'string' || !/^\d+$/.test(raw)) {
+            throw new core_1.AugustSDKError('UNKNOWN', `Could not read the balance of token account ${entry.pubkey.toBase58()}. ` +
+                'The RPC returned an unrecognized response; please retry or switch RPC.', {
+                context: {
+                    account: entry.pubkey.toBase58(),
+                    rawAmount: String(raw),
+                },
+            });
+        }
+        return {
+            pubkey: entry.pubkey,
+            amount: BigInt(raw),
+            decimals: typeof tokenAmount?.decimals === 'number' ? tokenAmount.decimals : null,
+            // Passed through from the RPC rather than recomputed from `amount`, so
+            // the lossy float these legacy readers return is not made lossier.
+            uiAmount: typeof tokenAmount?.uiAmount === 'number' ? tokenAmount.uiAmount : null,
+            frozen: info?.state === 'frozen',
+        };
+    });
+    const richest = (candidates) => candidates.reduce((best, candidate) => {
+        if (!best)
+            return candidate;
+        if (candidate.amount !== best.amount)
+            return candidate.amount > best.amount ? candidate : best;
+        // Equal balances: break the tie on the address. Falling back to "whichever
+        // the RPC listed first" would leave exactly the ordering dependence this
+        // function exists to remove — harmless while the balances match, but it
+        // means two calls can name different accounts for the same wallet.
+        return candidate.pubkey.toBase58() < best.pubkey.toBase58()
+            ? candidate
+            : best;
+    }, undefined);
+    return richest(parsed.filter((a) => !a.frozen)) ?? richest(parsed);
+}
 async function fetchUserTokenBalance({ connection, publicKey, depositMint, }) {
     if (!publicKey || !depositMint)
         return '0';
@@ -449,12 +537,9 @@ async function fetchUserTokenBalance({ connection, publicKey, depositMint, }) {
         const tokenAccounts = await connection.getParsedTokenAccountsByOwner(_publicKey, {
             mint: _depositMint,
         });
-        if (tokenAccounts.value.length > 0) {
-            const balance = tokenAccounts?.value?.[0]?.account.data.parsed.info.tokenAmount
-                .uiAmount;
-            return balance?.toString() || '0';
-        }
-        return '0';
+        // Same rule the write path uses — see `selectRichestTokenAccount`.
+        const richest = selectRichestTokenAccount(tokenAccounts.value);
+        return richest?.uiAmount?.toString() || '0';
     }
     catch (e) {
         const error = e;
@@ -473,12 +558,9 @@ async function fetchUserShareBalance({ connection, publicKey, shareMint, }) {
         const shareAccounts = await connection.getParsedTokenAccountsByOwner(_publicKey, {
             mint: _shareMint,
         });
-        if (shareAccounts.value.length > 0) {
-            const balance = shareAccounts?.value?.[0]?.account.data.parsed.info.tokenAmount
-                .uiAmount;
-            return balance ?? 0;
-        }
-        return 0;
+        // Same rule the write path uses — see `selectRichestTokenAccount`.
+        const richest = selectRichestTokenAccount(shareAccounts.value);
+        return richest?.uiAmount ?? 0;
     }
     catch (e) {
         const error = e;
@@ -519,12 +601,13 @@ async function fetchUserShareBalanceRaw({ connection, publicKey, shareMint, }) {
         const shareAccounts = await connection.getParsedTokenAccountsByOwner(_publicKey, {
             mint: _shareMint,
         });
-        const tokenAmount = shareAccounts?.value?.[0]?.account?.data?.parsed?.info?.tokenAmount;
-        if (!tokenAmount)
+        // Same rule the write path uses — see `selectRichestTokenAccount`.
+        const richest = selectRichestTokenAccount(shareAccounts?.value ?? []);
+        if (!richest)
             return { amount: '0', decimals: null };
         return {
-            amount: String(tokenAmount.amount ?? '0'),
-            decimals: typeof tokenAmount.decimals === 'number' ? tokenAmount.decimals : null,
+            amount: richest.amount.toString(),
+            decimals: richest.decimals,
         };
     }
     catch (e) {

package/lib/adapters/solana/vault.actions.d.ts

@@ -1,5 +1,5 @@
 import { type web3 } from '@coral-xyz/anchor';
-import { type Connection, PublicKey, Transaction } from '@solana/web3.js';
+import { type Connection, PublicKey, type Transaction } from '@solana/web3.js';
 import type { ISolanaConnectionOptions } from './types';
 import type { SendTransactionOptions } from '@solana/wallet-adapter-base';
 /**
@@ -26,18 +26,33 @@ export declare function describeSolanaError(e: unknown): string;
  * @param depositAmount  `bigint` is treated as raw on-chain units (preferred
  *   — no JS-float round-trip). `number` is treated as a UI amount and
  *   scaled by the deposit mint's decimals via {@link uiAmountToRawBn}.
- * @throws AugustValidationError on missing wallet/programId or invalid amount.
+ * @throws AugustValidationError on missing wallet/programId or invalid amount,
+ *   or when the wallet's deposit-mint balance is below `depositAmount`.
+ * @throws AugustSDKError when a candidate token account's balance cannot be
+ *   read, or wrapping any downstream failure (`cause` preserved).
+ * @remarks **Side effects.** Submits exactly one transaction, signed by the
+ *   provider's wallet. When the wallet has no share account, that transaction
+ *   also creates one, and `publicKey` pays its rent — roughly 0.00204 SOL,
+ *   non-refundable while the account stays open — on top of the network fee.
+ *   Callers should ensure the wallet holds enough SOL for both before
+ *   prompting the user to sign.
  * @remarks The on-chain `deposit` instruction has no `min_shares_out`
  *   parameter; slippage cannot be enforced on-chain until the program ships
  *   that argument.
  */
-export declare function handleSolanaDeposit({ provider, connection, network, vaultProgramId, vaultAddress, depositAmount, publicKey, sendTransaction, idl, }: {
+export declare function handleSolanaDeposit({ provider, connection, network, vaultProgramId, vaultAddress, depositAmount, publicKey, idl, }: {
     vaultProgramId: PublicKey | string;
     vaultAddress?: PublicKey | string;
     idl: any;
     publicKey: PublicKey | string;
     depositAmount: number | bigint;
-    sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>;
+    /**
+     * @deprecated Accepted and ignored. Share-account creation is now prepended
+     * to the deposit instruction, so there is no longer a second transaction to
+     * send. Kept so existing callers keep compiling; will be removed in the next
+     * major.
+     */
+    sendTransaction?: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>;
 } & ISolanaConnectionOptions): Promise<any>;
 /**
  * Redeem vault shares back into the underlying mint on a Solana August vault.
@@ -45,13 +60,28 @@ export declare function handleSolanaDeposit({ provider, connection, network, vau
  * @param redeemShares  `bigint` is treated as raw share-token units;
  *   `number` is treated as a UI amount. See {@link handleSolanaDeposit} for
  *   the same caveat about the missing on-chain slippage guard.
- * @throws AugustValidationError on missing wallet/programId or invalid amount.
+ * @throws AugustValidationError on missing wallet/programId or invalid amount,
+ *   or when the wallet holds fewer shares than `redeemShares`.
+ * @throws AugustSDKError when a candidate token account's balance cannot be
+ *   read, or wrapping any downstream failure (`cause` preserved).
+ * @remarks **Side effects.** Submits exactly one transaction, signed by the
+ *   provider's wallet. That transaction also creates the payout account when
+ *   the wallet has none, and the vault's fee-recipient account when *it* has
+ *   none — `publicKey` pays rent for both, roughly 0.00204 SOL each and
+ *   non-refundable, on top of the network fee. Callers should ensure the
+ *   wallet holds enough SOL for all of it before prompting the user to sign.
  */
-export declare function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultAddress, publicKey, redeemShares, sendTransaction, idl, }: {
+export declare function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultAddress, publicKey, redeemShares, idl, }: {
     idl: any;
     vaultProgramId: PublicKey | string;
     vaultAddress?: PublicKey | string;
     publicKey: PublicKey | string;
     redeemShares: number | bigint;
-    sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>;
+    /**
+     * @deprecated Accepted and ignored. Payout- and fee-recipient-account
+     * creation is now prepended to the redeem instruction, so there is no longer
+     * a second transaction to send. Kept so existing callers keep compiling;
+     * will be removed in the next major.
+     */
+    sendTransaction?: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>;
 } & ISolanaConnectionOptions): Promise<any>;