@augustdigital/sdk 9.9.1 → 9.10.1

package/lib/core/helpers/concurrency.js

@@ -10,6 +10,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapWithConcurrency = mapWithConcurrency;
+exports.withTimeout = withTimeout;
 /**
  * Map over `items` running at most `limit` tasks at a time.
  *
@@ -55,4 +56,24 @@ async function mapWithConcurrency(items, limit, task) {
     await Promise.all(Array.from({ length: width }, worker));
     return results;
 }
+/**
+ * Race a promise against a timeout so a hung call can't block indefinitely. The
+ * timer is always cleared, so a fast-resolving promise leaves nothing pending.
+ *
+ * @param promise - The call to bound. It keeps running after a timeout; only
+ *   the wait is abandoned.
+ * @param ms - Timeout in milliseconds. Values below 0 are treated as 0.
+ * @param label - Names the call in the rejection message.
+ * @returns What `promise` resolves to.
+ * @throws `Error("<label> timed out after <ms>ms")` on timeout, or whatever
+ *   `promise` rejects with.
+ * @internal
+ */
+function withTimeout(promise, ms, label) {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), Math.max(0, ms));
+    });
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
 //# sourceMappingURL=concurrency.js.map

package/lib/modules/vaults/getters.d.ts

@@ -311,6 +311,16 @@ export interface PnlHistoryConsistencyParams {
      * (subgraph deposits or LayerZero cross-chain deposits).
      */
     hasDeposits: boolean;
+    /**
+     * Whether the indexed deposits explain every share mint to the wallet (see
+     * {@link historyCoversMints}). Defaults to `true`.
+     */
+    mintsMatchHistory?: boolean;
+    /**
+     * Shares received by peer transfer, priced in raw base units (asset
+     * decimals) by {@link transferCostBasis}. Defaults to zero.
+     */
+    receivedByTransferRaw?: bigint;
     /** Total withdrawn, in raw base units (asset decimals). */
     totalWithdrawnRaw: bigint;
     /** Current on-chain position value, in raw base units (asset decimals). */
@@ -326,9 +336,14 @@ export interface PnlHistoryConsistencyParams {
  * position as pure profit — a plausible-looking but wrong number.
  *
  * This guard rejects exactly that state: a non-zero position with no recorded
- * deposits *and* no recorded withdrawals. Any of the following is treated as
- * consistent and passes:
+ * deposits, no shares received by transfer *and* no recorded withdrawals. It
+ * also rejects a non-zero position with no recorded deposits when a share mint
+ * to the wallet has no matching deposit (`mintsMatchHistory: false`): the mint
+ * proves a deposit the history failed to return, so neither a peer transfer
+ * nor a withdrawal makes the cost basis complete. Otherwise, any of the
+ * following is treated as consistent and passes:
  * - deposits are present (the normal, computable case);
+ * - shares were received by transfer and priced (see {@link transferCostBasis});
  * - withdrawals are present (a fully-exited-then-re-entered position is still
  *   computable — the withdrawal records prove history loaded);
  * - the current position is zero (the wallet never interacted or fully exited,
@@ -338,15 +353,17 @@ export interface PnlHistoryConsistencyParams {
  * path with no added latency.
  *
  * Shares received by a direct token transfer (never deposited, never withdrew)
- * reach this guard as deposits: {@link getVaultUserLifetimePnl} prices them
- * with {@link transferCostBasis} first. The guard still throws for such a
- * wallet when its transfers cannot be read or priced.
+ * reach this guard as `receivedByTransferRaw`: {@link getVaultUserLifetimePnl}
+ * prices them with {@link transferCostBasis} first. The guard still throws for
+ * such a wallet when its transfers cannot be read or priced, or when a share
+ * mint to it has no indexed deposit.
  *
  * @param params - See {@link PnlHistoryConsistencyParams}.
  * @returns `void` when the history is consistent.
  * @throws {@link AugustHistoryUnavailableError} with code `HISTORY_UNAVAILABLE`
- *   and `context: { vault, wallet }` when a non-zero position has neither
- *   deposits nor withdrawals recorded. The message carries the
+ *   and `context: { vault, wallet }` when a non-zero position has no deposits
+ *   recorded and either a share mint without a matching deposit or neither
+ *   received shares nor withdrawals. The message carries the
  *   `#getVaultUserLifetimePnl::<vault>::<wallet>` prefix so it groups with the
  *   other errors leaving the getter.
  * @example
@@ -355,12 +372,14 @@ export interface PnlHistoryConsistencyParams {
  *   vault,
  *   wallet,
  *   hasDeposits: depositsByAsset.size > 0,
+ *   mintsMatchHistory,
+ *   receivedByTransferRaw: costBasis.receivedByTransferRaw,
  *   totalWithdrawnRaw,
  *   currentPositionRaw: currentPositionValue.raw,
  * });
  * ```
  */
-export declare function assertPnlHistoryConsistent({ vault, wallet, hasDeposits, totalWithdrawnRaw, currentPositionRaw, }: PnlHistoryConsistencyParams): void;
+export declare function assertPnlHistoryConsistent({ vault, wallet, hasDeposits, mintsMatchHistory, receivedByTransferRaw, totalWithdrawnRaw, currentPositionRaw, }: PnlHistoryConsistencyParams): void;
 /** Inputs the lifetime-PnL price guard inspects. */
 export interface PnlTokenPriceParams {
     /** Vault contract address, used for the error message and context. */
@@ -728,7 +747,9 @@ export interface PnlCostBasis {
  *
  * A depositor whose history misses a mint ({@link historyCoversMints}) is the
  * exception: its transfers do not count, so the result matches what the getter
- * returned before transfers counted for depositors. On a LayerZero OVault the
+ * returned before transfers counted for depositors. A wallet with no deposit
+ * still gets a basis here when its history misses a mint, but
+ * {@link assertPnlHistoryConsistent} rejects it. On a LayerZero OVault the
  * caller leaves the hub composer and share OFT out of the transfers (see
  * {@link selectPeerTransfers}): the composer's deliveries are already counted
  * as LayerZero deposits, and shares bridged to a spoke chain still count in the
@@ -789,16 +810,18 @@ export declare function pnlCostBasis({ depositedRaw, withdrawnAssetsRaw, hasDepo
  * shares add to `totalDeposited` (and are reported again as
  * `receivedByTransfer`), sent shares add to `totalWithdrawn`. This holds
  * alongside indexed deposits, so a wallet that received shares and also
- * deposited is not credited with the received shares as profit. LayerZero
- * OVaults count transfers only when history holds no deposit, because their
- * composer delivers cross-chain deposits by transfer.
+ * deposited is not credited with the received shares as profit. On LayerZero
+ * OVaults, transfers from or to the hub composer and share OFT do not count,
+ * because the composer delivers cross-chain deposits by transfer and those
+ * are already counted as LayerZero deposits.
  *
  * Gaps in the indexed history: a share mint with no `Deposit` event counts as
  * a deposit of the assets in its `ReserveDeposit` event
  * ({@link selectReserveDeposits}; High Growth ETH emits it for Kelp gain-adapter
  * deposits), and a withdrawal request the vault logged twice counts once
  * ({@link countWithdrawalRequestsOnce}). Transfers fold in for a depositor only
- * once every mint is explained.
+ * once every mint is explained. A wallet with no indexed deposit and a mint
+ * that no deposit explains throws `HISTORY_UNAVAILABLE`.
  *
  * Tokenized Vault V2 redemptions carry only shares, so a settled one counts at
  * the assets the vault paid, or at the share ratio on its claim date when the
@@ -813,9 +836,8 @@ export declare function pnlCostBasis({ depositedRaw, withdrawnAssetsRaw, hasDepo
  * for a Tokenized Vault V2 wallet with redemption requests, a `lagDuration()`
  * read plus one backend timeseries request. A timeseries window with no usable
  * ratio (a closed vault whose history stopped earlier) is read again in full,
- * so the latest earlier day still prices it. For
- * non-LayerZero vaults the transfer query runs in parallel with the history
- * read; for LayerZero vaults it runs only when history holds no deposit.
+ * so the latest earlier day still prices it. The transfer query runs for
+ * every vault, in parallel with the history read.
  *
  * @param vault - Vault contract address
  * @param wallet - User wallet address
@@ -823,7 +845,8 @@ export declare function pnlCostBasis({ depositedRaw, withdrawnAssetsRaw, hasDepo
  * @returns Lifetime PnL data in both native token and USD
  * @throws {@link AugustHistoryUnavailableError} (`HISTORY_UNAVAILABLE`) when a
  *   live position has no indexed deposits, withdrawals or priceable share
- *   transfers.
+ *   transfers, or has no indexed deposit while a share mint to the wallet has
+ *   no matching deposit.
  * @throws {@link AugustPriceUnavailableError} (`PRICE_UNAVAILABLE`) when the
  *   underlying asset has no USD price, or `asset()` cannot be read.
  */

package/lib/modules/vaults/getters.js

@@ -2273,9 +2273,14 @@ async function getYieldLastRealizedOn({ vault, options, }) {
  * position as pure profit — a plausible-looking but wrong number.
  *
  * This guard rejects exactly that state: a non-zero position with no recorded
- * deposits *and* no recorded withdrawals. Any of the following is treated as
- * consistent and passes:
+ * deposits, no shares received by transfer *and* no recorded withdrawals. It
+ * also rejects a non-zero position with no recorded deposits when a share mint
+ * to the wallet has no matching deposit (`mintsMatchHistory: false`): the mint
+ * proves a deposit the history failed to return, so neither a peer transfer
+ * nor a withdrawal makes the cost basis complete. Otherwise, any of the
+ * following is treated as consistent and passes:
  * - deposits are present (the normal, computable case);
+ * - shares were received by transfer and priced (see {@link transferCostBasis});
  * - withdrawals are present (a fully-exited-then-re-entered position is still
  *   computable — the withdrawal records prove history loaded);
  * - the current position is zero (the wallet never interacted or fully exited,
@@ -2285,15 +2290,17 @@ async function getYieldLastRealizedOn({ vault, options, }) {
  * path with no added latency.
  *
  * Shares received by a direct token transfer (never deposited, never withdrew)
- * reach this guard as deposits: {@link getVaultUserLifetimePnl} prices them
- * with {@link transferCostBasis} first. The guard still throws for such a
- * wallet when its transfers cannot be read or priced.
+ * reach this guard as `receivedByTransferRaw`: {@link getVaultUserLifetimePnl}
+ * prices them with {@link transferCostBasis} first. The guard still throws for
+ * such a wallet when its transfers cannot be read or priced, or when a share
+ * mint to it has no indexed deposit.
  *
  * @param params - See {@link PnlHistoryConsistencyParams}.
  * @returns `void` when the history is consistent.
  * @throws {@link AugustHistoryUnavailableError} with code `HISTORY_UNAVAILABLE`
- *   and `context: { vault, wallet }` when a non-zero position has neither
- *   deposits nor withdrawals recorded. The message carries the
+ *   and `context: { vault, wallet }` when a non-zero position has no deposits
+ *   recorded and either a share mint without a matching deposit or neither
+ *   received shares nor withdrawals. The message carries the
  *   `#getVaultUserLifetimePnl::<vault>::<wallet>` prefix so it groups with the
  *   other errors leaving the getter.
  * @example
@@ -2302,16 +2309,23 @@ async function getYieldLastRealizedOn({ vault, options, }) {
  *   vault,
  *   wallet,
  *   hasDeposits: depositsByAsset.size > 0,
+ *   mintsMatchHistory,
+ *   receivedByTransferRaw: costBasis.receivedByTransferRaw,
  *   totalWithdrawnRaw,
  *   currentPositionRaw: currentPositionValue.raw,
  * });
  * ```
  */
-function assertPnlHistoryConsistent({ vault, wallet, hasDeposits, totalWithdrawnRaw, currentPositionRaw, }) {
-    const positionExists = currentPositionRaw > BigInt(0);
-    const noHistory = !hasDeposits && totalWithdrawnRaw === BigInt(0);
-    if (positionExists && noHistory) {
-        throw new errors_1.AugustHistoryUnavailableError(`#getVaultUserLifetimePnl::${vault}::${wallet}:transaction history unavailable — a live position exists but no deposits or withdrawals were indexed, so lifetime PnL cannot be computed without over-reporting the entire position as profit`, { context: { vault, wallet } });
+function assertPnlHistoryConsistent({ vault, wallet, hasDeposits, mintsMatchHistory = true, receivedByTransferRaw = BigInt(0), totalWithdrawnRaw, currentPositionRaw, }) {
+    if (currentPositionRaw <= BigInt(0) || hasDeposits)
+        return;
+    const missingDeposit = !mintsMatchHistory;
+    const noHistory = receivedByTransferRaw === BigInt(0) && totalWithdrawnRaw === BigInt(0);
+    if (missingDeposit || noHistory) {
+        const reason = missingDeposit
+            ? 'a share mint has no indexed deposit'
+            : 'no deposits or withdrawals were indexed';
+        throw new errors_1.AugustHistoryUnavailableError(`#getVaultUserLifetimePnl::${vault}::${wallet}:transaction history unavailable — a live position exists but ${reason}, so lifetime PnL cannot be computed without over-reporting the entire position as profit`, { context: { vault, wallet } });
     }
 }
 /**
@@ -2713,7 +2727,9 @@ function settleV2Redemptions({ history, lagDuration, ratios, now, }) {
  *
  * A depositor whose history misses a mint ({@link historyCoversMints}) is the
  * exception: its transfers do not count, so the result matches what the getter
- * returned before transfers counted for depositors. On a LayerZero OVault the
+ * returned before transfers counted for depositors. A wallet with no deposit
+ * still gets a basis here when its history misses a mint, but
+ * {@link assertPnlHistoryConsistent} rejects it. On a LayerZero OVault the
  * caller leaves the hub composer and share OFT out of the transfers (see
  * {@link selectPeerTransfers}): the composer's deliveries are already counted
  * as LayerZero deposits, and shares bridged to a spoke chain still count in the
@@ -2855,16 +2871,18 @@ async function readV2Redemptions(provider, vault, history, headers) {
  * shares add to `totalDeposited` (and are reported again as
  * `receivedByTransfer`), sent shares add to `totalWithdrawn`. This holds
  * alongside indexed deposits, so a wallet that received shares and also
- * deposited is not credited with the received shares as profit. LayerZero
- * OVaults count transfers only when history holds no deposit, because their
- * composer delivers cross-chain deposits by transfer.
+ * deposited is not credited with the received shares as profit. On LayerZero
+ * OVaults, transfers from or to the hub composer and share OFT do not count,
+ * because the composer delivers cross-chain deposits by transfer and those
+ * are already counted as LayerZero deposits.
  *
  * Gaps in the indexed history: a share mint with no `Deposit` event counts as
  * a deposit of the assets in its `ReserveDeposit` event
  * ({@link selectReserveDeposits}; High Growth ETH emits it for Kelp gain-adapter
  * deposits), and a withdrawal request the vault logged twice counts once
  * ({@link countWithdrawalRequestsOnce}). Transfers fold in for a depositor only
- * once every mint is explained.
+ * once every mint is explained. A wallet with no indexed deposit and a mint
+ * that no deposit explains throws `HISTORY_UNAVAILABLE`.
  *
  * Tokenized Vault V2 redemptions carry only shares, so a settled one counts at
  * the assets the vault paid, or at the share ratio on its claim date when the
@@ -2879,9 +2897,8 @@ async function readV2Redemptions(provider, vault, history, headers) {
  * for a Tokenized Vault V2 wallet with redemption requests, a `lagDuration()`
  * read plus one backend timeseries request. A timeseries window with no usable
  * ratio (a closed vault whose history stopped earlier) is read again in full,
- * so the latest earlier day still prices it. For
- * non-LayerZero vaults the transfer query runs in parallel with the history
- * read; for LayerZero vaults it runs only when history holds no deposit.
+ * so the latest earlier day still prices it. The transfer query runs for
+ * every vault, in parallel with the history read.
  *
  * @param vault - Vault contract address
  * @param wallet - User wallet address
@@ -2889,7 +2906,8 @@ async function readV2Redemptions(provider, vault, history, headers) {
  * @returns Lifetime PnL data in both native token and USD
  * @throws {@link AugustHistoryUnavailableError} (`HISTORY_UNAVAILABLE`) when a
  *   live position has no indexed deposits, withdrawals or priceable share
- *   transfers.
+ *   transfers, or has no indexed deposit while a share mint to the wallet has
+ *   no matching deposit.
  * @throws {@link AugustPriceUnavailableError} (`PRICE_UNAVAILABLE`) when the
  *   underlying asset has no USD price, or `asset()` cannot be read.
  */
@@ -3259,7 +3277,9 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
         assertPnlHistoryConsistent({
             vault,
             wallet,
-            hasDeposits: hasDeposits || costBasis.receivedByTransferRaw > BigInt(0),
+            hasDeposits,
+            mintsMatchHistory,
+            receivedByTransferRaw: costBasis.receivedByTransferRaw,
             totalWithdrawnRaw: costBasis.withdrawnAssetsRaw,
             currentPositionRaw: BigInt(currentPositionValue.raw),
         });

package/lib/sdk.d.ts

@@ -1,8 +1,9 @@
 import type { Abi } from 'abitype';
 import type { AbiParametersToPrimitiveTypes } from 'abitype';
-import type { AnchorProvider } from '@coral-xyz/anchor';
+import { AnchorProvider } from '@coral-xyz/anchor';
 import type { BaseContract } from 'ethers';
 import { Commitment } from '@solana/web3.js';
+import { ConfirmOptions } from '@solana/web3.js';
 import { Connection } from '@solana/web3.js';
 import type { ContractTransaction } from 'ethers';
 import type { ContractTransactionResponse } from 'ethers';
@@ -28,9 +29,12 @@ import type { Result } from 'ethers';
 import type { SendTransactionOptions } from '@solana/wallet-adapter-base';
 import type * as Sentry from '@sentry/browser';
 import { Signer } from 'ethers';
+import { Signer as Signer_2 } from '@solana/web3.js';
 import { Transaction } from '@solana/web3.js';
 import { TransactionReceipt } from 'ethers';
 import { TransactionResponse } from 'ethers';
+import { TransactionSignature } from '@solana/web3.js';
+import { VersionedTransaction } from '@solana/web3.js';
 import { Wallet } from 'ethers';
 import type { WalletClient } from 'viem';
 import { web3 } from '@coral-xyz/anchor';
@@ -15201,9 +15205,14 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
    * position as pure profit — a plausible-looking but wrong number.
    *
    * This guard rejects exactly that state: a non-zero position with no recorded
-   * deposits *and* no recorded withdrawals. Any of the following is treated as
-   * consistent and passes:
+   * deposits, no shares received by transfer *and* no recorded withdrawals. It
+   * also rejects a non-zero position with no recorded deposits when a share mint
+   * to the wallet has no matching deposit (`mintsMatchHistory: false`): the mint
+   * proves a deposit the history failed to return, so neither a peer transfer
+   * nor a withdrawal makes the cost basis complete. Otherwise, any of the
+   * following is treated as consistent and passes:
    * - deposits are present (the normal, computable case);
+   * - shares were received by transfer and priced (see {@link transferCostBasis});
    * - withdrawals are present (a fully-exited-then-re-entered position is still
    *   computable — the withdrawal records prove history loaded);
    * - the current position is zero (the wallet never interacted or fully exited,
@@ -15213,15 +15222,17 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
    * path with no added latency.
    *
    * Shares received by a direct token transfer (never deposited, never withdrew)
-   * reach this guard as deposits: {@link getVaultUserLifetimePnl} prices them
-   * with {@link transferCostBasis} first. The guard still throws for such a
-   * wallet when its transfers cannot be read or priced.
+   * reach this guard as `receivedByTransferRaw`: {@link getVaultUserLifetimePnl}
+   * prices them with {@link transferCostBasis} first. The guard still throws for
+   * such a wallet when its transfers cannot be read or priced, or when a share
+   * mint to it has no indexed deposit.
    *
    * @param params - See {@link PnlHistoryConsistencyParams}.
    * @returns `void` when the history is consistent.
    * @throws {@link AugustHistoryUnavailableError} with code `HISTORY_UNAVAILABLE`
-       *   and `context: { vault, wallet }` when a non-zero position has neither
-       *   deposits nor withdrawals recorded. The message carries the
+       *   and `context: { vault, wallet }` when a non-zero position has no deposits
+       *   recorded and either a share mint without a matching deposit or neither
+       *   received shares nor withdrawals. The message carries the
        *   `#getVaultUserLifetimePnl::<vault>::<wallet>` prefix so it groups with the
        *   other errors leaving the getter.
        * @example
@@ -15230,12 +15241,14 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
        *   vault,
        *   wallet,
        *   hasDeposits: depositsByAsset.size > 0,
+       *   mintsMatchHistory,
+       *   receivedByTransferRaw: costBasis.receivedByTransferRaw,
        *   totalWithdrawnRaw,
        *   currentPositionRaw: currentPositionValue.raw,
        * });
        * ```
        */
-   export declare function assertPnlHistoryConsistent({ vault, wallet, hasDeposits, totalWithdrawnRaw, currentPositionRaw, }: PnlHistoryConsistencyParams): void;
+   export declare function assertPnlHistoryConsistent({ vault, wallet, hasDeposits, mintsMatchHistory, receivedByTransferRaw, totalWithdrawnRaw, currentPositionRaw, }: PnlHistoryConsistencyParams): void;
 
    /**
     * Guard against converting lifetime PnL to USD with a fabricated price.
@@ -15922,7 +15935,7 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                 * ```
                 */
                /** Stable error codes attached to SDK errors. */
-               export declare type AugustErrorCode = 'AUTH_MISSING_KEY' | 'AUTH_INVALID_KEY' | 'AUTH_FORBIDDEN' | 'AUTH_UNAUTHORIZED' | 'INVALID_URL' | 'INVALID_INPUT' | 'INVALID_CHAIN' | 'INVALID_ADDRESS' | 'ACCOUNT_NOT_FUNDED' | 'NETWORK_ERROR' | 'TIMEOUT' | 'RATE_LIMITED' | 'SERVER_ERROR' | 'HISTORY_UNAVAILABLE' | 'PRICE_UNAVAILABLE' | 'UNKNOWN';
+               export declare type AugustErrorCode = 'AUTH_MISSING_KEY' | 'AUTH_INVALID_KEY' | 'AUTH_FORBIDDEN' | 'AUTH_UNAUTHORIZED' | 'INVALID_URL' | 'INVALID_INPUT' | 'INVALID_CHAIN' | 'INVALID_ADDRESS' | 'ACCOUNT_NOT_FUNDED' | 'NETWORK_ERROR' | 'TIMEOUT' | 'RATE_LIMITED' | 'SERVER_ERROR' | 'TRANSACTION_UNCONFIRMED' | 'HISTORY_UNAVAILABLE' | 'PRICE_UNAVAILABLE' | 'UNKNOWN';
 
                /** Options accepted by every SDK error constructor. */
                export declare interface AugustErrorOptions {
@@ -16863,6 +16876,35 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                         toJSON(): Record<string, unknown>;
                     }
 
+                    /**
+                     * A transaction was sent but its outcome could not be established
+                     * (`TRANSACTION_UNCONFIRMED`). It may have landed: check {@link signature}
+                     * before resubmitting, or a deposit or redeem can execute twice.
+                     * `context.reason` says what was seen (e.g. `expired_not_found`: the blockhash
+                     * expired and no lookup found it, so it very likely never landed).
+                     *
+                     * @example
+                     * ```ts
+                     * try {
+                     *   await sdk.solana.vaultDeposit(programId, idl, wallet, amount, undefined, vault);
+                     * } catch (err) {
+                     *   if (err instanceof AugustTransactionError) showPending(err.signature);
+                     *   else throw err;
+                     * }
+                     * ```
+                     */
+                    export declare class AugustTransactionError extends AugustSDKError {
+                        /** Signature of the transaction that was sent. */
+                        readonly signature: string;
+                        /**
+                         * @param message - Human-readable description, naming the signature.
+                         * @param signature - Signature of the transaction that was sent.
+                         * @param options - Standard SDK error options.
+                         */
+                        constructor(message: string, signature: string, options?: AugustErrorOptions);
+                        toJSON(): Record<string, unknown>;
+                    }
+
                     /** Caller-side input failed validation. */
                     export declare class AugustValidationError extends AugustSDKError {
                         constructor(code: Extract<AugustErrorCode, 'INVALID_URL' | 'INVALID_INPUT' | 'INVALID_CHAIN' | 'INVALID_ADDRESS' | 'ACCOUNT_NOT_FUNDED'>, message: string, options?: AugustErrorOptions);
@@ -17478,6 +17520,29 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                   */
                                  export declare function balanceOf(signer: IContractRunner, options: IBalanceOfOptions): Promise<bigint>;
 
+                                 /**
+                                  * `AnchorProvider` whose `sendAndConfirm` — what `program.methods…rpc()` calls —
+                                  * confirms with {@link confirmByBlockhash} instead of Anchor's signature-only
+                                  * WebSocket wait. Signing and Anchor's error translation are unchanged.
+                                  */
+                                 declare class BlockhashConfirmingProvider extends AnchorProvider {
+                                     /**
+                                      * Sign, send and confirm a transaction.
+                                      *
+                                      * @param tx - Transaction to send. Its blockhash (and fee payer, if unset)
+                                      *   are set here. A `VersionedTransaction` already carries a blockhash this
+                                      *   cannot learn the expiry of, so it takes Anchor's default path.
+                                      * @param signers - Extra signers besides the wallet.
+                                      * @param opts - Defaults to the provider's options.
+                                      * @returns The transaction signature.
+                                      * @throws See {@link confirmByBlockhash}; also whatever the wallet or
+                                      *   `sendRawTransaction` throws (user rejection, preflight failure).
+                                      * @remarks **RPC cost.** `getLatestBlockhash` + `sendRawTransaction`, then
+                                      *   the confirmation polls described on {@link confirmByBlockhash}.
+                                      */
+                                     sendAndConfirm(tx: Transaction | VersionedTransaction, signers?: Signer_2[], opts?: ConfirmOptions): Promise<TransactionSignature>;
+                                 }
+
                                  /**
                                   * Build an ERC-8021 schema-0 attribution suffix from builder codes.
                                   *
@@ -20179,16 +20244,18 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                      * shares add to `totalDeposited` (and are reported again as
                                                                      * `receivedByTransfer`), sent shares add to `totalWithdrawn`. This holds
                                                                      * alongside indexed deposits, so a wallet that received shares and also
-                                                                     * deposited is not credited with the received shares as profit. LayerZero
-                                                                     * OVaults count transfers only when history holds no deposit, because their
-                                                                     * composer delivers cross-chain deposits by transfer.
+                                                                     * deposited is not credited with the received shares as profit. On LayerZero
+                                                                     * OVaults, transfers from or to the hub composer and share OFT do not count,
+                                                                     * because the composer delivers cross-chain deposits by transfer and those
+                                                                     * are already counted as LayerZero deposits.
                                                                      *
                                                                      * Gaps in the indexed history: a share mint with no `Deposit` event counts as
                                                                      * a deposit of the assets in its `ReserveDeposit` event
                                                                      * ({@link selectReserveDeposits}; High Growth ETH emits it for Kelp gain-adapter
                                                                      * deposits), and a withdrawal request the vault logged twice counts once
                                                                      * ({@link countWithdrawalRequestsOnce}). Transfers fold in for a depositor only
-                                                                     * once every mint is explained.
+                                                                     * once every mint is explained. A wallet with no indexed deposit and a mint
+                                                                     * that no deposit explains throws `HISTORY_UNAVAILABLE`.
                                                                      *
                                                                      * Tokenized Vault V2 redemptions carry only shares, so a settled one counts at
                                                                      * the assets the vault paid, or at the share ratio on its claim date when the
@@ -20203,9 +20270,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                      * for a Tokenized Vault V2 wallet with redemption requests, a `lagDuration()`
                                                                      * read plus one backend timeseries request. A timeseries window with no usable
                                                                      * ratio (a closed vault whose history stopped earlier) is read again in full,
-                                                                     * so the latest earlier day still prices it. For
-                                                                     * non-LayerZero vaults the transfer query runs in parallel with the history
-                                                                     * read; for LayerZero vaults it runs only when history holds no deposit.
+                                                                     * so the latest earlier day still prices it. The transfer query runs for
+                                                                     * every vault, in parallel with the history read.
                                                                      *
                                                                      * @param vault - Vault contract address
                                                                      * @param wallet - User wallet address
@@ -20213,7 +20279,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                      * @returns Lifetime PnL data in both native token and USD
                                                                      * @throws {@link AugustHistoryUnavailableError} (`HISTORY_UNAVAILABLE`) when a
                                                                          *   live position has no indexed deposits, withdrawals or priceable share
-                                                                         *   transfers.
+                                                                         *   transfers, or has no indexed deposit while a share mint to the wallet has
+                                                                         *   no matching deposit.
                                                                          * @throws {@link AugustPriceUnavailableError} (`PRICE_UNAVAILABLE`) when the
                                                                              *   underlying asset has no USD price, or `asset()` cannot be read.
                                                                              */
@@ -20389,6 +20456,9 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                           *   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).
+                                                                          * @throws AugustTransactionError (`TRANSACTION_UNCONFIRMED`) when the
+                                                                          *   transaction was sent but its outcome could not be established; check
+                                                                          *   `signature` before resubmitting.
                                                                           * @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,
@@ -20437,6 +20507,9 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                           *   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).
+                                                                          * @throws AugustTransactionError (`TRANSACTION_UNCONFIRMED`) when the
+                                                                          *   transaction was sent but its outcome could not be established; check
+                                                                          *   `signature` before resubmitting.
                                                                           * @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
@@ -24884,9 +24957,10 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                          }
 
                                                                          /**
-                                                                          * One subaccount record from the admin-only `GET /subaccount` directory
-                                                                          * endpoint (backend `ISubaccountRead` schema). Nullable fields are optional
-                                                                          * metadata the operations team may not have filled in.
+                                                                          * One subaccount record (backend `ISubaccountRead` schema), as returned by the
+                                                                          * admin-only `GET /subaccount` directory, `GET /users/{address}/subaccounts`
+                                                                          * and `GET /org/subaccounts`. Nullable fields are optional metadata the
+                                                                          * operations team may not have filled in.
                                                                           */
                                                                          export declare interface IWSSubaccountListItem {
                                                                              id: string;
@@ -24908,6 +24982,15 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                              variant: string | null;
                                                                              default_fee_rate_in_bips: number | null;
                                                                              wallet_role: string | null;
+                                                                             /**
+                                                                              * Cached USD account value, refreshed out of band by an hourly backend job.
+                                                                              * A sort key and placeholder, not an authoritative NAV — read the live value
+                                                                              * from the subaccount summary. `null` before the job's first run; absent on
+                                                                              * backends that predate the field.
+                                                                              */
+                                                                             latest_account_value?: number | null;
+                                                                             /** Naive-UTC ISO timestamp of `latest_account_value`. */
+                                                                             account_value_updated_at?: string | null;
                                                                              chains: IWSSubaccountListChain[];
                                                                          }
 
@@ -25524,7 +25607,9 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                           *
                                                                           * A depositor whose history misses a mint ({@link historyCoversMints}) is the
                                                                           * exception: its transfers do not count, so the result matches what the getter
-                                                                          * returned before transfers counted for depositors. On a LayerZero OVault the
+                                                                          * returned before transfers counted for depositors. A wallet with no deposit
+                                                                          * still gets a basis here when its history misses a mint, but
+                                                                          * {@link assertPnlHistoryConsistent} rejects it. On a LayerZero OVault the
                                                                           * caller leaves the hub composer and share OFT out of the transfers (see
                                                                           * {@link selectPeerTransfers}): the composer's deliveries are already counted
                                                                           * as LayerZero deposits, and shares bridged to a spoke chain still count in the
@@ -25587,6 +25672,16 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                               * (subgraph deposits or LayerZero cross-chain deposits).
                                                                               */
                                                                              hasDeposits: boolean;
+                                                                             /**
+                                                                              * Whether the indexed deposits explain every share mint to the wallet (see
+                                                                              * {@link historyCoversMints}). Defaults to `true`.
+                                                                              */
+                                                                             mintsMatchHistory?: boolean;
+                                                                             /**
+                                                                              * Shares received by peer transfer, priced in raw base units (asset
+                                                                              * decimals) by {@link transferCostBasis}. Defaults to zero.
+                                                                              */
+                                                                             receivedByTransferRaw?: bigint;
                                                                              /** Total withdrawn, in raw base units (asset decimals). */
                                                                              totalWithdrawnRaw: bigint;
                                                                              /** Current on-chain position value, in raw base units (asset decimals). */
@@ -27174,7 +27269,7 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                                    getProvider: ({ connection, publicKey, signTransaction, }: {
                                                                                        publicKey: PublicKey;
                                                                                        signTransaction: (<T extends Transaction | web3.VersionedTransaction>(transaction: T) => Promise<T>) | undefined;
-                                                                                   } & ISolanaConnectionOptions) => AnchorProvider;
+                                                                                   } & ISolanaConnectionOptions) => BlockhashConfirmingProvider;
                                                                                    getReadOnlyProvider: ({ connection }: ISolanaConnectionOptions) => AnchorProvider;
                                                                                    deriveShareMintPda: (vaultProgramId: PublicKey | string) => web3.PublicKey;
                                                                                    deriveVaultStatePda: (vaultProgramId: PublicKey | string) => web3.PublicKey;

package/lib/types/sub-accounts.d.ts

@@ -9,9 +9,10 @@ export interface IWSSubaccountListChain {
     name: string;
 }
 /**
- * One subaccount record from the admin-only `GET /subaccount` directory
- * endpoint (backend `ISubaccountRead` schema). Nullable fields are optional
- * metadata the operations team may not have filled in.
+ * One subaccount record (backend `ISubaccountRead` schema), as returned by the
+ * admin-only `GET /subaccount` directory, `GET /users/{address}/subaccounts`
+ * and `GET /org/subaccounts`. Nullable fields are optional metadata the
+ * operations team may not have filled in.
  */
 export interface IWSSubaccountListItem {
     id: string;
@@ -33,6 +34,15 @@ export interface IWSSubaccountListItem {
     variant: string | null;
     default_fee_rate_in_bips: number | null;
     wallet_role: string | null;
+    /**
+     * Cached USD account value, refreshed out of band by an hourly backend job.
+     * A sort key and placeholder, not an authoritative NAV — read the live value
+     * from the subaccount summary. `null` before the job's first run; absent on
+     * backends that predate the field.
+     */
+    latest_account_value?: number | null;
+    /** Naive-UTC ISO timestamp of `latest_account_value`. */
+    account_value_updated_at?: string | null;
     chains: IWSSubaccountListChain[];
 }
 export interface IWSSubAccountHealthFactor {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@augustdigital/sdk",
-  "version": "9.9.1",
+  "version": "9.10.1",
   "main": "lib/index.js",
   "types": "lib/sdk.d.ts",
   "keywords": [