@augustdigital/sdk 9.9.0 → 9.10.1

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;
@@ -29074,6 +29169,7 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                                                                  summary: (vaultAddress: IAddress) => string;
                                                                                                                  withdrawals: (chain: string, vaultAddress: IAddress) => string;
                                                                                                                  debank: (vaultAddress: IAddress) => string;
+                                                                                                                 octav: (vaultAddress: IAddress) => string;
                                                                                                                  userHistory: (vaultAddress: IAddress, wallet: IAddress) => string;
                                                                                                                  archivedVaults: string;
                                                                                                              };

package/lib/services/octavfi/fetcher.d.ts

@@ -1,9 +1,33 @@
+import type { IAddress, IWSMonitorHeaders } from '../../types';
 import type { IOctavfiPortfolio } from './types';
 /**
- * Fetches portfolio data from Octavfi API.
- * Note: The API currently doesn't support multiple addresses in a single request,
- * so individual requests are made for each address.
- * @param addresses - Array of addresses to fetch data for.
- * @returns Array of portfolio data (may be empty if all requests fail).
+ * Response of the August API's vault-level Octav endpoint.
+ *
+ * Keys are the vault's Solana operator addresses (case-sensitive base58).
+ * Values are the operator's raw Octav portfolio, or an `{ error }` object when
+ * the backend holds no usable portfolio for that operator.
  */
-export declare function fetchOctavfiPortfolios(addresses: string[]): Promise<IOctavfiPortfolio[]>;
+export type IVaultOctavResponse = Record<string, IOctavfiPortfolio | {
+    error: string;
+}>;
+/**
+ * Fetch the Octav portfolios of every Solana operator of a vault in a single
+ * request to the August public API.
+ *
+ * The API serves these from a cache that a backend cron refreshes, so this
+ * function never calls Octav and needs no Octav credentials. It makes exactly
+ * one HTTP request per call and never throws.
+ *
+ * @param vaultAddress - Vault address: EVM hex or Solana base58.
+ * @param headers - Optional monitoring headers forwarded with the request.
+ * @returns Dictionary of operator address to portfolio or error on a 200 or
+ *   207 (partial success) response; `false` on any other status or when the
+ *   request fails.
+ *
+ * @example
+ * ```ts
+ * const response = await fetchVaultOctavResponse(vaultAddress);
+ * const portfolio = response ? response[borrower] : undefined;
+ * ```
+ */
+export declare function fetchVaultOctavResponse(vaultAddress: IAddress, headers?: IWSMonitorHeaders): Promise<IVaultOctavResponse | false>;

package/lib/services/octavfi/fetcher.js

@@ -1,103 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchOctavfiPortfolios = fetchOctavfiPortfolios;
-const ethers_1 = require("ethers");
-const utils_1 = require("../../adapters/solana/utils");
+exports.fetchVaultOctavResponse = fetchVaultOctavResponse;
 const core_1 = require("../../core");
-const BASE_URL = 'https://api.octav.fi';
-const OCTAVFI_API_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJodHRwczovL2hhc3VyYS5pby9qd3QvY2xhaW1zIjp7IngtaGFzdXJhLWRlZmF1bHQtcm9sZSI6InVzZXIiLCJ4LWhhc3VyYS1hbGxvd2VkLXJvbGVzIjpbInVzZXIiXSwieC1oYXN1cmEtdXNlci1pZCI6ImF1Z3VzdDEyMjM0In19.zaMUtrtdC82uaDh6XSZrsneEcKO3PFOE6FyX3G-MR6c';
 /**
- * Filters addresses to only include EVM and Solana wallet addresses.
- * Excludes Sui addresses and other non-supported address formats.
+ * Fetch the Octav portfolios of every Solana operator of a vault in a single
+ * request to the August public API.
  *
- * @param addresses - Array of addresses to filter
- * @returns Array containing only EVM and Solana addresses
- */
-function filterEvmAndSolanaAddresses(addresses) {
-    return addresses.filter((address) => {
-        if (!address || typeof address !== 'string')
-            return false;
-        if ((0, ethers_1.isAddress)(address)) {
-            return true;
-        }
-        if (utils_1.SolanaUtils.isSolanaAddress(address)) {
-            return true;
-        }
-        core_1.Logger.log.info('filterEvmAndSolanaAddresses.excluded', { address });
-        return false;
-    });
-}
-/**
- * Fetches portfolio data for a single address from Octavfi API.
- * @param address - Single address to fetch data for.
- * @returns Portfolio data or null if request fails.
+ * The API serves these from a cache that a backend cron refreshes, so this
+ * function never calls Octav and needs no Octav credentials. It makes exactly
+ * one HTTP request per call and never throws.
+ *
+ * @param vaultAddress - Vault address: EVM hex or Solana base58.
+ * @param headers - Optional monitoring headers forwarded with the request.
+ * @returns Dictionary of operator address to portfolio or error on a 200 or
+ *   207 (partial success) response; `false` on any other status or when the
+ *   request fails.
+ *
+ * @example
+ * ```ts
+ * const response = await fetchVaultOctavResponse(vaultAddress);
+ * const portfolio = response ? response[borrower] : undefined;
+ * ```
  */
-async function fetchSinglePortfolio(address) {
+async function fetchVaultOctavResponse(vaultAddress, headers) {
     try {
-        const response = await fetch(`${BASE_URL}/v1/portfolio?addresses=${address}`, {
-            method: 'GET',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${OCTAVFI_API_KEY}`,
-            },
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            core_1.Logger.log.error('fetchSinglePortfolio', new Error(`HTTP ${response.status} ${response.statusText}: ${errorText}`), {
-                address,
-                status: response.status,
-                statusText: response.statusText,
-            });
-            return null;
-        }
-        const data = await response.json();
-        if (!data || typeof data !== 'object') {
-            core_1.Logger.log.error('fetchSinglePortfolio.unexpected-type', new Error(`unexpected response type: ${typeof data}`), { address });
-            return null;
+        const response = await (0, core_1.fetchAugustPublic)(core_1.WEBSERVER_ENDPOINTS.public.tokenizedVault.octav(vaultAddress), { headers: headers });
+        if (response.status === 200 || response.status === 207) {
+            return (await response.json());
         }
-        if (data.error) {
-            core_1.Logger.log.error('fetchSinglePortfolio.api-error', new Error(String(data.error)), { address });
-            return null;
-        }
-        // Handle nested array response: [[portfolio]] or [portfolio] or portfolio
-        let portfolio = data;
-        if (Array.isArray(data)) {
-            if (data.length > 0 && Array.isArray(data[0])) {
-                // Nested array: [[portfolio]]
-                portfolio = data[0][0];
-            }
-            else if (data.length > 0) {
-                // Single array: [portfolio]
-                portfolio = data[0];
-            }
-            else {
-                return null;
-            }
-        }
-        // Return raw Octavfi data (transformation should happen separately when needed)
-        return portfolio;
-    }
-    catch (error) {
-        core_1.Logger.log.error('fetchSinglePortfolio', error, { address });
-        return null;
+        core_1.Logger.log.error('fetchVaultOctavResponse', new Error(`HTTP ${response.status} ${response.statusText}`), { status: response.status, statusText: response.statusText });
+        return false;
     }
-}
-/**
- * Fetches portfolio data from Octavfi API.
- * Note: The API currently doesn't support multiple addresses in a single request,
- * so individual requests are made for each address.
- * @param addresses - Array of addresses to fetch data for.
- * @returns Array of portfolio data (may be empty if all requests fail).
- */
-async function fetchOctavfiPortfolios(addresses) {
-    const filteredAddresses = filterEvmAndSolanaAddresses(addresses);
-    if (filteredAddresses.length === 0) {
-        return [];
+    catch (e) {
+        core_1.Logger.log.error('fetchVaultOctavResponse', e);
+        return false;
     }
-    // Fetch portfolios for each address in parallel
-    const portfolioPromises = filteredAddresses.map((address) => fetchSinglePortfolio(address));
-    const portfolios = await Promise.all(portfolioPromises);
-    // Filter out null results (failed requests)
-    return portfolios.filter((portfolio) => portfolio !== null);
 }
 //# sourceMappingURL=fetcher.js.map

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.0",
+  "version": "9.10.1",
   "main": "lib/index.js",
   "types": "lib/sdk.d.ts",
   "keywords": [