> For the complete documentation index, see [llms.txt](https://docs.augustdigital.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.augustdigital.io/developers/typescript-sdk/api/augustvaults.md). # AugustVaults [SDK Reference](/developers/typescript-sdk/api.md) / AugustVaults ## AugustVaults The August Vaults Module. ### Classes #### AugustVaults Vault operations class handling multi-chain vault queries and user positions. Supports both EVM and Solana vaults with unified interface. **Extends** * `AugustBase` **Constructors** **Constructor** > **new AugustVaults**(`baseConfig`, `solana`, `sui`): [`AugustVaults`](#augustvaults) **Parameters** | Parameter | Type | | ------------ | -------------------------------------------------------------------- | | `baseConfig` | `IAugustBase` | | `solana` | [`default`](/developers/typescript-sdk/api/solanaadapter.md#default) | | `sui` | [`default`](/developers/typescript-sdk/api/suiadapter.md#default) | **Returns** [`AugustVaults`](#augustvaults) **Overrides** `AugustBase.constructor` **Properties** | Property | Modifier | Type | Description | Inherited from | | ---------------- | -------- | ------------------ | --------------------------------------------- | -------------------------- | | `activeNetwork?` | `public` | `IActiveNetwork` | - | `AugustBase.activeNetwork` | | `appName` | `public` | `string` | Validated app-name slug from the constructor. | `AugustBase.appName` | | `authorized` | `public` | `boolean` | - | `AugustBase.authorized` | | `keys` | `public` | `IKeys` | - | `AugustBase.keys` | | `monitoring` | `public` | `IMonitoring` | - | `AugustBase.monitoring` | | `providers` | `public` | `IProvidersConfig` | - | `AugustBase.providers` | **Methods** **clearWallet()** > **clearWallet**(): `void` Remove wallet address from SDK state and monitoring headers. **Returns** `void` **Inherited from** `AugustBase.clearWallet` **depositNative()** > **depositNative**(`signer`, `options`): `Promise`<`string`> **Parameters** | Parameter | Type | Description | | --------- | ----------------------- | ---------------------------------------------------------------------------------- | | `signer` | `Signer` \| `Wallet` | signer / wallet object | | `options` | `INativeDepositOptions` | object including wrapper contract address, receiver address (optional), and amount | **Returns** `Promise`<`string`> deposit tx hash **Description** deposit native token (ETH/AVAX/etc) into a vault using MultiAssetNativeDepositWrapper **fetchPointsLeaderboard()** > **fetchPointsLeaderboard**(`params?`): `Promise`<`any`> **`Function`** fetchPointsLeaderboard fetches the points leaderboard data **Parameters** | Parameter | Type | Description | | ----------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------- | | `params?` | { `page?`: `number`; `perPage?`: `number`; `sortBy?`: `"streakDays"` \| `"totalPoints"`; } | Optional parameters for pagination and sorting | | `params.page?` | `number` | - | | `params.perPage?` | `number` | - | | `params.sortBy?` | `"streakDays"` \| `"totalPoints"` | - | **Returns** `Promise`<`any`> Leaderboard response data **getStakingPositions()** > **getStakingPositions**(`wallet?`, `chainId?`): `Promise`<`IActiveStakingPosition`\[]> **`Function`** getStakingPositions gets all available reward staking positions **Parameters** | Parameter | Type | Description | | ---------- | ------------------- | ------------------------------------- | | `wallet?` | `` `0x${string}` `` | optionally passed user wallet address | | `chainId?` | `number` | optionally passed chainId | **Returns** `Promise`<`IActiveStakingPosition`\[]> all available staking positions for connected or passed network(s) **getSwapRouterEligibleVaults()** > **getSwapRouterEligibleVaults**(`chainId`, `options?`): `Promise`<`` `0x${string}` ``\[]> Resolve the vaults currently eligible for the any-token `SwapRouter` deposit surface on a chain — every vault the router has `enableVault`-ed whose on-chain registration is still live. Reconstructs the set from the router's `VaultEnabled` event history and re-checks `vaultInfo(vault).referenceAsset != 0` for each (the mapping is not enumerable). See [getSwapRouterEligibleVaults](#getswaproutereligiblevaults) for the full two-stage behavior and RPC cost. Uses this instance's configured provider for `chainId`; returns `[]` (no RPC) when no router is deployed there or no provider is configured. On-chain eligibility only — app-level policy (e.g. excluding vaults with their own OVault deposit flow) remains the caller's responsibility. **Parameters** | Parameter | Type | Description | | -------------------- | --------------------------- | ------------------------------------------------------------- | | `chainId` | `number` | EVM chain ID to resolve eligible vaults for. | | `options?` | { `fromBlock?`: `number`; } | Optional `fromBlock` to override the deploy-block scan floor. | | `options.fromBlock?` | `number` | - | **Returns** `Promise`<`` `0x${string}` ``\[]> Checksummed eligible vault addresses; `[]` when unavailable. **Throws** AugustSDKError when an `eth_getLogs` scan chunk fails. **Example** ```ts const vaults = await augustSdk.getSwapRouterEligibleVaults(1); ``` **getSwapRouterWhitelistedTokens()** > **getSwapRouterWhitelistedTokens**(`chainId`, `options?`): `Promise`<`` `0x${string}` ``\[]> Resolve the ERC-20 tokens currently whitelisted for the `SwapRouter` on a chain — the any-token set a deposit UI can offer as swap-and-deposit inputs, each verified `true` against the router's on-chain allowlist. Reconstructs the set from the router's `TokenEnabled` event history and re-checks `whitelistedTokens(token)` for each (the mapping is not enumerable). See [getSwapRouterWhitelistedTokens](#getswaprouterwhitelistedtokens) for the full two-stage behavior and RPC cost. Uses this instance's configured provider for `chainId`; returns `[]` (no RPC) when no router is deployed there or no provider is configured. **Parameters** | Parameter | Type | Description | | -------------------- | --------------------------- | ------------------------------------------------------------- | | `chainId` | `number` | EVM chain ID to resolve the allowlist for. | | `options?` | { `fromBlock?`: `number`; } | Optional `fromBlock` to override the deploy-block scan floor. | | `options.fromBlock?` | `number` | - | **Returns** `Promise`<`` `0x${string}` ``\[]> Checksummed whitelisted token addresses; `[]` when unavailable. Callers still exclude a target vault's natively-accepted assets (those deposit without a swap). **Throws** AugustSDKError when an `eth_getLogs` scan chunk fails. **Example** ```ts const tokens = await augustSdk.getSwapRouterWhitelistedTokens(1); ``` **getTotalDeposited()** > **getTotalDeposited**(`options?`): `Promise`<`number`> Calculate total deposited across all tokenized vaults by summing latest\_reported\_tvl. Uses the /tokenized\_vault endpoint which returns latest\_reported\_tvl in USD. **Parameters** | Parameter | Type | Description | | -------------------------- | --------------------------------------------------------------- | ----------------------------------------- | | `options?` | { `loadSnapshots?`: `boolean`; `loadSubaccounts?`: `boolean`; } | Optional configuration for loading vaults | | `options.loadSnapshots?` | `boolean` | - | | `options.loadSubaccounts?` | `boolean` | - | **Returns** `Promise`<`number`> Total deposited amount in USD (sum of all latest\_reported\_tvl values) **getUserHistory()** > **getUserHistory**(`__namedParameters`): `Promise`<`IVaultUserHistoryItem`\[]> **Parameters** | Parameter | Type | | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | `__namedParameters` | { `chainId?`: `number`; `options?`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault?`: `` `0x${string}` ``; `wallet`: `` `0x${string}` ``; } | | `__namedParameters.chainId?` | `number` | | `__namedParameters.options?` | [`IVaultBaseOptions`](#ivaultbaseoptions) | | `__namedParameters.vault?` | `` `0x${string}` `` | | `__namedParameters.wallet` | `` `0x${string}` `` | **Returns** `Promise`<`IVaultUserHistoryItem`\[]> **getUserPoints()** > **getUserPoints**(`userAddress`): `Promise`<`any`> **`Function`** getUserPoints fetches user points from the backend API **Parameters** | Parameter | Type | Description | | ------------- | ------------------- | ------------------- | | `userAddress` | `` `0x${string}` `` | User wallet address | **Returns** `Promise`<`any`> Points data from the backend API **getUserTransfers()** > **getUserTransfers**(`__namedParameters`): `Promise`<`object`\[]> **Parameters** | Parameter | Type | | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | `__namedParameters` | { `chainId?`: `number`; `options?`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault?`: `` `0x${string}` ``; `wallet`: `` `0x${string}` ``; } | | `__namedParameters.chainId?` | `number` | | `__namedParameters.options?` | [`IVaultBaseOptions`](#ivaultbaseoptions) | | `__namedParameters.vault?` | `` `0x${string}` `` | | `__namedParameters.wallet` | `` `0x${string}` `` | **Returns** `Promise`<`object`\[]> **getVault()** > **getVault**(`vault`): `Promise`<`IVault`> Fetch detailed data for a single vault with optional enrichment. Automatically includes loans and allocations unless explicitly disabled. **Parameters** | Parameter | Type | Description | | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------- | | `vault` | { `chainId?`: `number`; `loadSnapshots?`: `boolean`; `loadSubaccounts?`: `boolean`; `options?`: [`IVaultCustomOptions`](#ivaultcustomoptions); `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.chainId?` | `number` | - | | `vault.loadSnapshots?` | `boolean` | - | | `vault.loadSubaccounts?` | `boolean` | - | | `vault.options?` | [`IVaultCustomOptions`](#ivaultcustomoptions) | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVault`> Single vault object with optional position data **Throws** AugustValidationError (`INVALID_CHAIN`) when `chainId` is not a chain the SDK recognises, or is a supported EVM chain with no RPC URL configured on this SDK instance. **getVaultActivity()** > **getVaultActivity**(`params`): `Promise`<`IVaultUserHistoryItem`\[]> Fetch a vault's deposit/withdrawal activity across every participant. This is the vault-wide counterpart to [getUserHistory](#getuserhistory): instead of filtering the subgraph to one wallet, it returns every deposit, withdrawal-request, and processed-withdrawal event for the pool. Use it to answer flow questions ("how many deposits in the last 7 days", "net flow this week") that point-in-time TVL cannot. Rows are read from the Goldsky subgraph, paginated internally so busy vaults are not truncated at the 1000-row page cap. When `sinceTs` is supplied the reader stops paging once it passes the window boundary, so a short lookback stays cheap even on high-volume vaults. **Parameters** | Parameter | Type | Description | | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | | `params` | { `chainId?`: `number`; `sinceTs?`: `number`; `types?`: (`"deposit"` \| `"withdraw-request"` \| `"withdraw-processed"` \| `"redeem"`)\[]; `untilTs?`: `number`; `vault`: `` `0x${string}` ``; } | Query parameters. | | `params.chainId?` | `number` | Chain id of the vault; falls back to the active network when omitted. Required for the subgraph lookup. | | `params.sinceTs?` | `number` | Lower bound (inclusive) as a Unix timestamp in seconds. Events at or after this time are returned. | | `params.types?` | (`"deposit"` \| `"withdraw-request"` \| `"withdraw-processed"` \| `"redeem"`)\[] | Restrict to a subset of event types (e.g. `['deposit']`). Returns all types when omitted. | | `params.untilTs?` | `number` | Upper bound (inclusive) as a Unix timestamp in seconds. Events at or before this time are returned. | | `params.vault` | `` `0x${string}` `` | Vault (pool) address to read activity for. | **Returns** `Promise`<`IVaultUserHistoryItem`\[]> Activity items sorted oldest-first, each with a normalized `amount`, actor `address`, `type`, and `transactionHash`. **Throws** If `vault` is not a valid address, or no chain id can be resolved. **Example** ```ts const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86_400; const deposits = await sdk.getVaultActivity({ vault: '0x36eDbF0C834591BFdfCaC0Ef9605528c75c406aA', chainId: 143, sinceTs: weekAgo, types: ['deposit'], }); console.log(`${deposits.length} deposits in the last 7 days`); ``` **getVaultAllocations()** > **getVaultAllocations**(`vault`): `Promise`<`IVaultAllocations` | { `message`: `string`; `status`: `number`; }> Fetch a vault's DeFi / CeFi / OTC allocation breakdown. **Parameters** | Parameter | Type | Description | | ---------------- | ------------------------------------------------------- | ---------------------- | | `vault` | { `chainId?`: `number`; `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.chainId?` | `number` | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultAllocations` | { `message`: `string`; `status`: `number`; }> Allocation data for the vault **Throws** AugustValidationError (`INVALID_CHAIN`) when `chainId` is not a chain the SDK recognises, or is a supported EVM chain with no RPC URL configured on this SDK instance. ~~**getVaultAnnualizedApy()**~~ > **getVaultAnnualizedApy**(`vault`): `Promise`<`IVaultAnnualizedApy`> Get annualized APY metrics for a vault. Supported Vaults: cUSDO, tETH, wstETH, rsETH **Parameters** | Parameter | Type | Description | | --------- | ------------------- | ------------- | | `vault` | `` `0x${string}` `` | Vault address | **Returns** `Promise`<`IVaultAnnualizedApy`> Annualized APY data including liquidity APY **Deprecated** The `hgETH30dLiquidAPY` and `hgETH7dLiquidAPY` response fields are deprecated. These fields will be removed in the next major release. Use `liquidAPY30Day` and `liquidAPY7Day` fields instead. ~~**getVaultApy()**~~ > **getVaultApy**(`vault`): `Promise`<`object`\[]> **`Function`** **Parameters** | Parameter | Type | Description | | ------------------- | ------------------------------------------------------------------------------------- | --------------------------- | | `vault` | { `historical?`: `Partial`<`IVaultHistoricalParams`>; `vault`: `` `0x${string}` ``; } | pool/vault contract address | | `vault.historical?` | `Partial`<`IVaultHistoricalParams`> | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`object`\[]> a value or array of objects containing the APR and timestamp **Deprecated** use getVaultHistoricalTimeseries instead getVaultApy gets the vault/pool APR, both current and historical **getVaultAvailableRedemptions()** > **getVaultAvailableRedemptions**(`__namedParameters`): `Promise`<{ `availableRedemptions`: `IVaultAvailableRedemption`\[]; `pendingRedemptions`: `IVaultAvailableRedemption`\[]; `processedWithdrawals`: `ISubgraphWithdrawProccessed`\[]; `requestedWithdrawals`: `ISubgraphWithdrawRequest`\[]; }> **Parameters** | Parameter | Type | | ---------------------------- | -------------------------------------------------------------------------------------------------------------- | | `__namedParameters` | { `chainId?`: `number`; `vault`: `` `0x${string}` ``; `verbose?`: `boolean`; `wallet?`: `` `0x${string}` ``; } | | `__namedParameters.chainId?` | `number` | | `__namedParameters.vault` | `` `0x${string}` `` | | `__namedParameters.verbose?` | `boolean` | | `__namedParameters.wallet?` | `` `0x${string}` `` | **Returns** `Promise`<{ `availableRedemptions`: `IVaultAvailableRedemption`\[]; `pendingRedemptions`: `IVaultAvailableRedemption`\[]; `processedWithdrawals`: `ISubgraphWithdrawProccessed`\[]; `requestedWithdrawals`: `ISubgraphWithdrawRequest`\[]; }> **getVaultBorrowerHealthFactor()** > **getVaultBorrowerHealthFactor**(`chainId?`, `vault?`): `Promise`<`Record`<`string`, `IVaultBorrowerHealthFactor`\[]> | `Record`<`string`, `IVaultBorrowerHealthFactor`\[]>\[]> Gets borrower health-factor data for vaults on a chain, optionally scoped to a single vault. Pass `vault` whenever the caller knows which pool it cares about — this skips the all-vaults cross-chain fanout and only reads the loans for that one pool. The response map is keyed by **lowercased** vault address; look entries up with `address.toLowerCase()`. Individual loan failures (bad/test loan contracts, unrecognized borrowers) are isolated and logged rather than rejecting the batch. **Parameters** | Parameter | Type | Description | | ---------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `chainId?` | `number` | Optional chain to scope the read to. When omitted, iterates the SDK's configured providers and returns the flattened list (legacy shape — prefer passing a chain). | | `vault?` | `` `0x${string}` `` | Optional vault address. When provided alongside `chainId`, only that vault's data is fetched. | **Returns** `Promise`<`Record`<`string`, `IVaultBorrowerHealthFactor`\[]> | `Record`<`string`, `IVaultBorrowerHealthFactor`\[]>\[]> When `chainId` is set, an object map of lowercased vault address → array of borrower-health-factor rows. When `chainId` is omitted, a flat array (legacy behavior, kept for backward compat). **getVaultHistoricalTimeseries()** > **getVaultHistoricalTimeseries**(`vault`): `Promise`<`IHistoricalTimeseriesResponse`> **`Function`** getVaultHistoricalTimeseries gets historical timeseries data for a vault **Parameters** | Parameter | Type | Description | | -------------- | ----------------------------------------------------- | ---------------------- | | `vault` | { `nDays?`: `number`; `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.nDays?` | `number` | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IHistoricalTimeseriesResponse`> Historical timeseries data with TVL, APY, PnL, share price, and other metrics **getVaultLoans()** > **getVaultLoans**(`vault`): `Promise`<`IVaultLoan`\[]> Fetch the active loans issued by a vault. **Parameters** | Parameter | Type | Description | | ---------------- | ------------------------------------------------------- | ---------------------- | | `vault` | { `chainId?`: `number`; `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.chainId?` | `number` | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultLoan`\[]> Loan data for the vault **Throws** AugustValidationError (`INVALID_CHAIN`) when `chainId` is not a chain the SDK recognises, or is a supported EVM chain with no RPC URL configured on this SDK instance. **getVaultPendingRedemptions()** > **getVaultPendingRedemptions**(`vault`): `Promise`<`IVaultPendingRedemptions`> Fetch pending redemptions for a vault with liquidity analysis. **Parameters** | Parameter | Type | Description | | ------------------- | --------------------------------------------------------------------------------- | ---------------------- | | `vault` | { `futureDays?`: `number`; `pastDays?`: `number`; `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.futureDays?` | `number` | - | | `vault.pastDays?` | `number` | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultPendingRedemptions`> Pending redemptions grouped by date with liquidity summary **getVaultPnl()** > **getVaultPnl**(`props`): `Promise`<`IVaultPnl`> Get PnL for a vault (vault-level, not user-specific). Returns the vault's overall profit and loss across all users. **Parameters** | Parameter | Type | Description | | ---------------- | ------------------------------------------------------- | ----------------------------------- | | `props` | { `chainId?`: `number`; `vault`: `` `0x${string}` ``; } | Vault address and optional chain ID | | `props.chainId?` | `number` | - | | `props.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultPnl`> Vault PnL in USD and notional value **getVaultPositions()** > **getVaultPositions**(`__namedParameters`): `Promise`<`IVaultPosition`\[]> Fetch the wallet's positions across vaults — a single vault, one chain, or every chain with a configured provider. RPC volume (worst case, multi-vault paths): the two non-cacheable per-vault reads (`balanceOf`, `lagDuration`) are aggregated into chunked Multicall3 `aggregate3` batches per chain (10 calls per chunk) on chains where the canonical deployment is verified; unverified chains (e.g. Citrea 4114) and non-EVM vaults keep one `eth_call` per read. Measured on a cold cache for a wallet with 62 vaults across Ethereum + Avalanche: 83 RPC HTTP requests before batching, 54 after (\~35% fewer). A vault whose batched read fails (e.g. paused) falls back to its own per-vault reads — never to a zeroed balance. **Parameters** | Parameter | Type | | ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `__namedParameters` | { `chainId?`: `number`; `options?`: [`IVaultBaseOptions`](#ivaultbaseoptions); `showAllVaults?`: `boolean`; `solanaWallet?`: `string`; `stellarWallet?`: `string`; `vault?`: `` `0x${string}` ``; `wallet?`: `` `0x${string}` ``; } | | `__namedParameters.chainId?` | `number` | | `__namedParameters.options?` | [`IVaultBaseOptions`](#ivaultbaseoptions) | | `__namedParameters.showAllVaults?` | `boolean` | | `__namedParameters.solanaWallet?` | `string` | | `__namedParameters.stellarWallet?` | `string` | | `__namedParameters.vault?` | `` `0x${string}` `` | | `__namedParameters.wallet?` | `` `0x${string}` `` | **Returns** `Promise`<`IVaultPosition`\[]> **getVaultRedemptionHistory()** > **getVaultRedemptionHistory**(`vault`): `Promise`<`IVaultRedemptionHistoryItem`\[]> Historical redemption requests for a vault (settled, cancelled, and pending-but-out-of-window). Filterable by wallet. Stellar vaults return `[]` — on-chain redemption history is not yet indexed for that adapter. **Parameters** | Parameter | Type | Description | | ----------------------- | -------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- | | `vault` | { `chainId?`: `number`; `lookbackBlocks?`: `number`; `vault`: `` `0x${string}` ``; `wallet?`: `` `0x${string}` ``; } | Vault address (EVM or Stellar). Stellar input is accepted but always resolves to an empty array for now. | | `vault.chainId?` | `number` | - | | `vault.lookbackBlocks?` | `number` | - | | `vault.vault` | `` `0x${string}` `` | - | | `vault.wallet?` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultRedemptionHistoryItem`\[]> The same array shape `getVaultRedemptionHistory` returns at the module level — historical redemption records, newest first. **Example** ```ts const history = await sdk.vaultsModule.getVaultRedemptionHistory({ vault: '0xVault', chainId: 8453, wallet: '0xWallet', }); ``` **getVaults()** > **getVaults**(`options?`): `Promise`<`IVault`\[]> Fetch all vaults across configured networks with optional enrichment. Automatically filters by available providers and optionally by chain IDs. Includes closed vaults that are still visible (`status: 'closed'`, `is_visible: true`) so consumers can render positions held in closed vaults; closed vaults with `is_visible: false` are excluded. RPC volume (worst case, wallet enrichment path): the per-vault `balanceOf`/`lagDuration` reads are aggregated into chunked Multicall3 `aggregate3` batches per chain (10 calls per chunk) on chains where the canonical Multicall3 deployment is verified; other chains (e.g. Citrea 4114) keep one `eth_call` per read. Measured on a cold cache for a wallet with 62 vaults across Ethereum + Avalanche: 83 RPC HTTP requests before batching, 54 after (\~35% fewer; 124 per-vault `eth_call`s collapse into \~13 `aggregate3` calls — the remaining requests are the per-vault cached decimals/receipt-token reads on a cold cache). **Parameters** | Parameter | Type | Description | | ---------- | ----------------------------------------- | -------------------------------------- | | `options?` | [`IGetVaultsOptions`](#igetvaultsoptions) | Filtering and enrichment configuration | **Returns** `Promise`<`IVault`\[]> Array of vault objects with optional loans/allocations/positions **getVaultSubaccountLoans()** > **getVaultSubaccountLoans**(`vault`): `Promise`<`IVaultLoan`\[]> Fetch a vault's loans broken down by sub-account. **Parameters** | Parameter | Type | Description | | ---------------- | ------------------------------------------------------- | ---------------------- | | `vault` | { `chainId?`: `number`; `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.chainId?` | `number` | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultLoan`\[]> Sub-account loan data for the vault **Throws** AugustValidationError (`INVALID_CHAIN`) when `chainId` is not a chain the SDK recognises, or is a supported EVM chain with no RPC URL configured on this SDK instance. **getVaultSummary()** > **getVaultSummary**(`vault`): `Promise`<`IVaultSummary`> Get summary data for a vault (name, type, chain, recent returns). **Parameters** | Parameter | Type | Description | | --------- | ------------------- | ------------- | | `vault` | `` `0x${string}` `` | Vault address | **Returns** `Promise`<`IVaultSummary`> Vault summary data **getVaultTvl()** > **getVaultTvl**(`vault`): `Promise`<`object`\[]> **`Function`** getVaultTvl gets the vault/pool TVL, both current and historical **Parameters** | Parameter | Type | Description | | ------------------- | ------------------------------------------------------------------------------------------------ | --------------------------- | | `vault` | { `chainId?`: `number`; `historical?`: `IVaultHistoricalParams`; `vault`: `` `0x${string}` ``; } | pool/vault contract address | | `vault.chainId?` | `number` | - | | `vault.historical?` | `IVaultHistoricalParams` | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`object`\[]> an object or array of objects containing the TVL and timestamp **getVaultUserLifetimePnl()** > **getVaultUserLifetimePnl**(`props`): `Promise`<`IVaultUserLifetimePnl`> Get lifetime PnL for a user in a specific vault. **Parameters** | Parameter | Type | Description | | ---------------- | -------------------------------------------------------------------------------------- | ---------------------------------------------------- | | `props` | { `chainId?`: `number`; `vault`: `` `0x${string}` ``; `wallet`: `` `0x${string}` ``; } | Vault address, wallet address, and optional chain ID | | `props.chainId?` | `number` | - | | `props.vault` | `` `0x${string}` `` | - | | `props.wallet` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultUserLifetimePnl`> Lifetime PnL data including realized and unrealized PnL **getVaultWithdrawals()** > **getVaultWithdrawals**(`vault`, `chainId?`): `Promise`<`IVaultWithdrawals`> Get withdrawal summary and pending queue for a vault. **Parameters** | Parameter | Type | Description | | ---------- | ------------------- | ------------------------------------------ | | `vault` | `` `0x${string}` `` | Vault address | | `chainId?` | `number` | Chain ID (will be converted to chain name) | **Returns** `Promise`<`IVaultWithdrawals`> Withdrawal summary and pending queue **getWithdrawalRequestsWithStatus()** > **getWithdrawalRequestsWithStatus**(`vault`, `receiver?`, `lookbackBlocks?`, `chainId?`): `Promise`<[`WithdrawalRequestStatus`](#withdrawalrequeststatus)\[]> Get all withdrawal requests for a vault with deterministic status tracking. Matches requests to processed events by `(receiver, claimableDate)` tuple. **Status values:** * `'processed'` — Matching `WithdrawalProcessed` event found on-chain. * `'ready_to_claim'` — Claimable date has passed, no processed event found yet. * `'pending'` — Claimable date is still in the future. **Lookback window:** Processed events are fetched from on-chain logs, which only cover a finite block range. Requests whose claimable date is older than this window with no matching processed event are excluded (assumed already processed). Use `lookbackBlocks` to widen or narrow the scan range. **Parameters** | Parameter | Type | Description | | ----------------- | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | | `vault` | `` `0x${string}` `` | Vault contract address | | `receiver?` | `` `0x${string}` `` | Optional receiver address to filter by | | `lookbackBlocks?` | `number` | Optional on-chain log lookback window in blocks. Defaults to chain-specific value (e.g. 150,000 for Ethereum, 3,456,000 for Monad). | | `chainId?` | `number` | Optional chain id for the vault address | **Returns** `Promise`<[`WithdrawalRequestStatus`](#withdrawalrequeststatus)\[]> Array of withdrawal requests with status and claimable dates **getYieldLastRealizedOn()** > **getYieldLastRealizedOn**(`vault`): `Promise`<`number`> **`Function`** getYieldLastRealizedOn gets the timestamp when yield was last realized for a vault **Parameters** | Parameter | Type | Description | | ---------------- | ------------------------------------------------------- | ---------------------- | | `vault` | { `chainId?`: `number`; `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.chainId?` | `number` | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`number`> Timestamp (Unix timestamp in seconds) when yield was last realized **init()** > **init**(): `Promise`<`void`> Verify the configured August API key and mark this instance as authorized. **Returns** `Promise`<`void`> **Throws** Error when `keys.august` is missing or rejected by the API. **Inherited from** `AugustBase.init` **previewRedemption()** > **previewRedemption**(`vault`): `Promise`<`INormalizedNumber`> Preview the amount of assets that would be received for redeeming shares (queued redemption). **Parameters** | Parameter | Type | Description | | -------------------- | --------------------------------------------------------------------------------------------------------- | ---------------------- | | `vault` | { `chainId?`: `number`; `sharesAmount`: `string` \| `number` \| `bigint`; `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.chainId?` | `number` | - | | `vault.sharesAmount` | `string` \| `number` \| `bigint` | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`INormalizedNumber`> The amount of assets as INormalizedNumber { normalized, raw } **previewRwaRedemption()** > **previewRwaRedemption**(`vault`): `Promise`<`INormalizedNumber`> Preview the output amount for an RWA instant redemption. Resolves the vault address to the RwaRedeemSubaccount internally. **Parameters** | Parameter | Type | Description | | ---------------- | --------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | | `vault` | { `amount`: `string` \| `number` \| `bigint`; `asset`: `` `0x${string}` ``; `chainId?`: `number`; `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.amount` | `string` \| `number` \| `bigint` | - | | `vault.asset` | `` `0x${string}` `` | - | | `vault.chainId?` | `number` | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`INormalizedNumber`> normalized number of the expected output amount (in output asset decimals) **registerUserForPoints()** > **registerUserForPoints**(`userAddress`, `referrerAddress`, `chainId`, `signature`, `nonce`, `expiry`): `Promise`<`Response`> Register a user for the points program, authenticated by a wallet signature. The caller produces a personal\_sign signature over a canonical message built from these primitives — see `registerUserForPoints` in `./getters` for the exact template and a worked example. **Parameters** | Parameter | Type | Description | | ----------------- | ------------------- | ----------------------------------------------------------------------------------------------------------------------------- | | `userAddress` | `` `0x${string}` `` | EVM wallet address being registered. | | `referrerAddress` | `` `0x${string}` `` | Optional referrer EVM address. | | `chainId` | `number` | Chain on which the wallet signed; powers the EIP-1271 fallback for smart-contract wallets and pins the signature cross-chain. | | `signature` | `string` | 0x-prefixed hex personal\_sign signature over the canonical message. | | `nonce` | `string` | Single-use random string (8–128 chars). | | `expiry` | `number` | Unix seconds; must be in the future, within the backend's TTL. | **Returns** `Promise`<`Response`> Raw `Response` from the backend. **rwaRedeemAsset()** > **rwaRedeemAsset**(`signer`, `vault`): `Promise`<`string`> Redeem vault shares for an underlying asset via instant redemption (RWA subaccount). Resolves the vault address to the RwaRedeemSubaccount internally. Handles vault share approval automatically. **Parameters** | Parameter | Type | Description | | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | | `signer` | `Signer` \| `Wallet` | Signer / wallet object | | `vault` | { `amount`: `string` \| `number` \| `bigint`; `asset`: `` `0x${string}` ``; `chainId?`: `number`; `minOut`: `string` \| `number` \| `bigint`; `vault`: `` `0x${string}` ``; `wait?`: `boolean`; } | Vault contract address | | `vault.amount` | `string` \| `number` \| `bigint` | - | | `vault.asset` | `` `0x${string}` `` | - | | `vault.chainId?` | `number` | - | | `vault.minOut` | `string` \| `number` \| `bigint` | - | | `vault.vault` | `` `0x${string}` `` | - | | `vault.wait?` | `boolean` | - | **Returns** `Promise`<`string`> transaction hash **switchNetwork()** > **switchNetwork**(`chainId`): `void` Switch the active blockchain network. Updates both chain ID and RPC URL for subsequent operations. **Parameters** | Parameter | Type | | --------- | -------- | | `chainId` | `number` | **Returns** `void` **Inherited from** `AugustBase.switchNetwork` **updateWallet()** > **updateWallet**(`address`): `void` Set active wallet address and update monitoring headers. Preserves existing environment setting. **Parameters** | Parameter | Type | | --------- | ------------------- | | `address` | `` `0x${string}` `` | **Returns** `void` **Inherited from** `AugustBase.updateWallet` **vaultDeposit()** > **vaultDeposit**(`signer`, `options`): `Promise`<`string`> **Parameters** | Parameter | Type | Description | | --------- | ----------------------- | ----------------------------------------------------------------------------------------------------- | | `signer` | `Signer` \| `Wallet` | signer / wallet object | | `options` | `IContractWriteOptions` | object including pool contract address, user wallet address, string amount, and optional depositAsset | **Returns** `Promise`<`string`> deposit tx hash **Description** deposit underlying token into the specified pool with adapter support. This is for when we cannot pass in a signer in sdk and need to do so as an arg ### Interfaces #### IGetVaultsOptions Options accepted by `getVaults` — on both the `AugustSDK` facade and the underlying `AugustVaults` module. Defined once so the two signatures cannot drift (the facade previously declared a narrower inline type that rejected documented options like `includeClosed` at compile time). **Extends** * [`IVaultCustomOptions`](#ivaultcustomoptions) **Properties** | Property | Type | Description | Overrides | Inherited from | | ------------------ | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | | `allocations?` | `boolean` | - | - | [`IVaultCustomOptions`](#ivaultcustomoptions).[`allocations`](#allocations-1) | | `baseDelay?` | `number` | Base backoff delay in **milliseconds** for the per-vault retry schedule (see `maxRetries`). **Default** `2000` | - | - | | `chainIds?` | `number`\[] | - | - | - | | `headers?` | `IWSMonitorHeaders` | - | - | - | | `includeClosed?` | `boolean` | Portfolio mode: include closed vaults in the result. By default (`false`) closed vaults are excluded, so marketplace / discovery callers never receive a `status: 'closed'` vault. When set, closed vaults are returned regardless of `is_visible` (closed + invisible vaults bucket as closed), so a consumer joining user positions can render a position held in a closed vault on the portfolio page. In this mode, loans/allocations enrichment is also skipped for closed vaults: they have none, and the per-vault enrichment (`getVault` → `getVaultAllocations`) otherwise re-throws when a closed vault has no live strategy/debank data or no subaccounts, which would land the vault in the `failed` bucket and silently drop it before it reaches the filter. Skipping enrichment lets the vault survive on its backend metadata + base on-chain read. **Default** `false` | [`IVaultCustomOptions`](#ivaultcustomoptions).[`includeClosed`](#includeclosed-2) | - | | `loadSnapshots?` | `boolean` | - | - | - | | `loadSubaccounts?` | `boolean` | - | - | - | | `loans?` | `boolean` | - | - | [`IVaultCustomOptions`](#ivaultcustomoptions).[`loans`](#loans-1) | | `maxRetries?` | `number` | Maximum primary-fetch attempts per vault before the fallback strategies (fallback RPCs, minimal fetch, extended retry) run. Attempt `n` waits `baseDelay * 2^(n-1)` ms before retrying, so the default (5 attempts, 2000 ms base) can spend up to 30s of backoff on a single persistently-failing vault. Callers racing this method against their own timeout should lower it (e.g. `2`) so one flaky vault cannot exhaust the whole budget. **Default** `5` | - | - | | `solanaWallet?` | `string` | - | - | [`IVaultCustomOptions`](#ivaultcustomoptions).[`solanaWallet`](#solanawallet-1) | | `stellarWallet?` | `string` | - | - | [`IVaultCustomOptions`](#ivaultcustomoptions).[`stellarWallet`](#stellarwallet-1) | | `wallet?` | `` `0x${string}` `` | - | - | [`IVaultCustomOptions`](#ivaultcustomoptions).[`wallet`](#wallet-1) | *** #### IVaultBaseOptions Base configuration for vault operations. **Properties** | Property | Type | Description | | -------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `augustKey?` | `string` | - | | `chainId?` | `number` | - | | `env?` | `IEnv` | - | | `headers?` | `IWSMonitorHeaders` | - | | `includeClosed?` | `boolean` | Portfolio mode: when true, the per-vault EVM getter does NOT null out a closed + invisible vault. Needed so a user's position in a closed, invisible vault can still resolve its metadata. Defaults to undefined (false) so marketplace/discovery reads keep hiding closed staging vaults. | | `rpcUrl` | `string` | - | | `solanaService?` | `ISolanaService` | - | | `stellarRpc?` | `object` | Optional Soroban RPC override (e.g. a keyed Alchemy URL) for Stellar vault reads, threaded from the SDK's `stellar` config. Carries the network it was configured for so it is only applied to matching-network vaults — a testnet override must not be used for a mainnet read. Unset → built-in endpoints. | | `stellarRpc.network` | `IStellarNetwork` | - | | `stellarRpc.rpcUrl` | `string` | - | | `subgraphKey?` | `string` | - | *** #### IVaultCustomOptions Optional enrichment options for vault queries. **Extended by** * [`IGetVaultsOptions`](#igetvaultsoptions) **Properties** | Property | Type | Description | | ---------------- | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `allocations?` | `boolean` | - | | `includeClosed?` | `boolean` | Portfolio mode for a SINGLE vault read: when true, a `closed` + `is_visible: false` vault resolves normally instead of coming back as null. Needed by any caller reading ONE vault by address on behalf of a holder — a position in a closed vault must still resolve its metadata, or the holder is left with no way to act on it. The plural counterpart is [IGetVaultsOptions.includeClosed](#includeclosed); this is the same flag on the per-address path. **Default** `false` | | `loans?` | `boolean` | - | | `solanaWallet?` | `string` | - | | `stellarWallet?` | `string` | - | | `wallet?` | `` `0x${string}` `` | - | *** #### PnlHistoryConsistencyParams Inputs the lifetime-PnL history guard inspects. **Properties** | Property | Type | Description | | -------------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------- | | `currentPositionRaw` | `bigint` | Current on-chain position value, in raw base units (asset decimals). | | `hasDeposits` | `boolean` | Whether the resolved deposit history contains at least one deposit record (subgraph deposits or LayerZero cross-chain deposits). | | `totalWithdrawnRaw` | `bigint` | Total withdrawn, in raw base units (asset decimals). | | `vault` | `` `0x${string}` `` | Vault contract address, used for the error message and context. | | `wallet` | `` `0x${string}` `` | User wallet address, used for the error message and context. | *** #### WithdrawalRequestStatus Withdrawal request with computed claimable date and current processing status. The unique identifier is (receiver, claimableDate). WithdrawalRequestStatus **Properties** | Property | Type | Description | | --------------------------- | -------------------------------------------------- | ---------------------------------------------------------------- | | `assetsReceived?` | `bigint` | Assets received (if processed) | | `claimableDate` | `object` | Computed claimable date in UTC (year, month, day) | | `claimableDate.day` | `number` | - | | `claimableDate.month` | `number` | - | | `claimableDate.year` | `number` | - | | `claimableEpoch` | `number` | Epoch timestamp when this withdrawal becomes claimable | | `processedTransactionHash?` | `string` | Transaction hash of the processing transaction (if processed) | | `receiver` | `string` | Receiver address for the withdrawal | | `requestTimestamp` | `number` | Block timestamp when the withdrawal was requested (seconds, UTC) | | `shares` | `bigint` | Shares amount being redeemed | | `status` | `"processed"` \| `"ready_to_claim"` \| `"pending"` | Current status of the withdrawal | | `transactionHash` | `string` | Transaction hash of the withdrawal request | ### Functions #### assertPnlHistoryConsistent() > **assertPnlHistoryConsistent**(`params`): `void` Guard against lifetime-PnL over-inflation when the deposit history fails to load. Lifetime PnL is `currentPosition + totalWithdrawn - totalDeposited`. When the deposit/withdrawal history fails to load it collapses to empty, so both `totalDeposited` and `totalWithdrawn` read as zero. If the wallet still holds a live on-chain position, the formula degenerates to reporting the entire 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 are present (the normal, computable case); * 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, so a zero PnL is correct, not inflated). Pure and synchronous — no RPC, no I/O — so it is safe to call inside the hot path with no added latency. Known imprecision — vault shares are transferable ERC-20 receipt tokens, so a wallet that *received* shares via a direct token transfer (never deposited, never withdrew) legitimately has `position > 0` with no history records and will throw `HISTORY_UNAVAILABLE` even though its history loaded fine. This is not a regression — the pre-guard formula reported that same position as 100% profit, which was also wrong — but the error message is misleading for that (rare) path. If receipt-token transfer becomes a real user flow, distinguish it here (e.g. by checking for a share-transfer event) rather than widening the guard. **Parameters** | Parameter | Type | Description | | --------- | ------------------------------------------------------------- | ---------------------------------------------------------------- | | `params` | [`PnlHistoryConsistencyParams`](#pnlhistoryconsistencyparams) | See [PnlHistoryConsistencyParams](#pnlhistoryconsistencyparams). | **Returns** `void` `void` when the history is consistent. **Throws** AugustHistoryUnavailableError with code `HISTORY_UNAVAILABLE` and `context: { vault, wallet }` when a non-zero position has neither deposits nor withdrawals recorded. The message carries the `#getVaultUserLifetimePnl::::` prefix so it groups with the other errors leaving the getter. **Example** ```ts assertPnlHistoryConsistent({ vault, wallet, hasDeposits: depositsByAsset.size > 0, totalWithdrawnRaw, currentPositionRaw: currentPositionValue.raw, }); ``` *** #### fetchPointsLeaderboard() > **fetchPointsLeaderboard**(`params`): `Promise`<`any`> Fetch the points leaderboard data. **Parameters** | Parameter | Type | Description | | ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------- | | `params` | { `options?`: [`IVaultBaseOptions`](#ivaultbaseoptions); `params?`: { `page?`: `number`; `perPage?`: `number`; `sortBy?`: `"streakDays"` \| `"totalPoints"`; }; } | Optional parameters for pagination and sorting | | `params.options?` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `params.params?` | { `page?`: `number`; `perPage?`: `number`; `sortBy?`: `"streakDays"` \| `"totalPoints"`; } | - | | `params.params.page?` | `number` | - | | `params.params.perPage?` | `number` | - | | `params.params.sortBy?` | `"streakDays"` \| `"totalPoints"` | - | **Returns** `Promise`<`any`> Leaderboard response data *** #### getHealthFactorOfBorrowersByVault() > **getHealthFactorOfBorrowersByVault**(`options`): `Promise`<`Record`<`string`, `IVaultBorrowerHealthFactor`\[]>> Aggregate borrower-health-factor data, optionally scoped to a single vault. * When `vault` is provided, only that vault's tokenized record is fetched and only its loans are read. This is the path callers should use when they already know which vault they care about — it skips the cross-chain fanout entirely. * When `vault` is omitted, the function fetches every tokenized vault and builds health factors for each, preserving the legacy behavior. Per-vault failures are isolated with `Promise.allSettled` so one bad vault returns an empty array instead of rejecting the whole map. The returned map is keyed by **lowercased** vault address so callers can look up entries without worrying about EIP-55 checksum casing in either the backend response or the caller's input. **Parameters** | Parameter | Type | Description | | ----------------- | ---------------------------------------------------------------------------------------- | --------------------------------------------------------------- | | `options` | { `options`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault?`: `` `0x${string}` ``; } | Standard vault options — `rpcUrl` should match `vault`'s chain. | | `options.options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `options.vault?` | `` `0x${string}` `` | - | **Returns** `Promise`<`Record`<`string`, `IVaultBorrowerHealthFactor`\[]>> Map of lowercased vault address → array of borrower-health-factor rows. *** #### getPreviewRedemption() > **getPreviewRedemption**(`vault`): `Promise`<`INormalizedNumber`> Preview the amount of assets that would be received for redeeming shares (queued redemption). **Parameters** | Parameter | Type | Description | | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | | `vault` | { `options`: [`IVaultBaseOptions`](#ivaultbaseoptions); `sharesAmount`: `string` \| `number` \| `bigint`; `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `vault.sharesAmount` | `string` \| `number` \| `bigint` | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`INormalizedNumber`> The amount of assets as an INormalizedNumber with `normalized` and `raw` fields *** #### getRewardsStakingPositions() > **getRewardsStakingPositions**(`__namedParameters`): `Promise`<`IActiveStakingPosition`\[]> **Parameters** | Parameter | Type | | --------------------------------- | ---------------------------------------------------------------------------------- | | `__namedParameters` | { `coinGeckoKey?`: `string`; `rpcUrl`: `string`; `wallet?`: `` `0x${string}` ``; } | | `__namedParameters.coinGeckoKey?` | `string` | | `__namedParameters.rpcUrl` | `string` | | `__namedParameters.wallet?` | `` `0x${string}` `` | **Returns** `Promise`<`IActiveStakingPosition`\[]> *** #### getSwapRouterDepositResult() > **getSwapRouterDepositResult**(`signer`, `options`): `Promise`<`ISwapRouterDepositResult`> Resolves the real, post-execution outcome of a SwapRouter deposit from its mined transaction receipt. The SwapRouter contract itself emits no deposit/amount-out event — only the vault does, via its own `Deposit` event — so this decodes that log directly rather than trusting the pre-trade quote a UI shows before the user submits (the true post-swap amount depends on execution-time price and can differ from that estimate). Works for both vault generations without the caller resolving the version first: evm-1 (ERC-4626-style `Deposit(sender, owner, assets, shares)`) and evm-2 (`Deposit(assetIn, amountIn, shares, senderAddr, receiverAddr)`) have different event signatures (different topic0), so both are registered and whichever matches the vault's actual log is decoded. **Parameters** | Parameter | Type | Description | | --------- | --------------------------------- | --------------------------------------------------------------------------------------------------- | | `signer` | `Signer` \| `Wallet` | ethers `Signer` or `Wallet` connected to a provider (used read-only here — no transaction is sent). | | `options` | `ISwapRouterDepositResultOptions` | ISwapRouterDepositResultOptions. | **Returns** `Promise`<`ISwapRouterDepositResult`> The decoded ISwapRouterDepositResult, or `null` if the receipt isn't found yet or carries no `Deposit` log from `vault` (e.g. the hash is wrong, or the tx hasn't mined). **Throws** AugustValidationError if `signer` has no connected provider. **Worst Case Rpc Calls** 1 — a single `getTransactionReceipt` call; decoding is local. **Example** ```ts const hash = await augustSdk.evm.swapRouterDeposit({ ... }); const result = await augustSdk.evm.getSwapRouterDepositResult({ txHash: hash, vault: '0x74ad2f789ed583dbd141bbdafc673fe1f033718b', }); // result?.amountOut — actual reference-asset amount received after the swap ``` *** #### getUserPoints() > **getUserPoints**(`userAddress`): `Promise`<`any`> Fetch user points from the backend API endpoint. This replaces client-side points calculation with server-side processing. **Parameters** | Parameter | Type | Description | | ------------------------- | ---------------------------------------------------------------------------------------------- | ----------------------------------- | | `userAddress` | { `options?`: [`IVaultBaseOptions`](#ivaultbaseoptions); `userAddress`: `` `0x${string}` ``; } | User wallet address (EVM or Solana) | | `userAddress.options?` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `userAddress.userAddress` | `` `0x${string}` `` | - | **Returns** `Promise`<`any`> Points data from the backend API *** #### getVault() > **getVault**(`vault`): `Promise`<`IVault`> Fetch comprehensive vault data including on-chain state and backend metadata. Routes to appropriate chain adapter (EVM v1/v2, Solana, or Stellar) based on vault version. Optionally enriches with loan and allocation data. **Parameters** | Parameter | Type | Description | | ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | | `vault` | { `allocations?`: `boolean`; `loadSnapshots?`: `boolean`; `loadSubaccounts?`: `boolean`; `loans?`: `boolean`; `options`: [`IVaultBaseOptions`](#ivaultbaseoptions); `tokenizedVault?`: `ITokenizedVault`; `vault`: `` `0x${string}` ``; } | Vault contract address (EVM hex, Stellar C-address, or Solana program ID) | | `vault.allocations?` | `boolean` | - | | `vault.loadSnapshots?` | `boolean` | - | | `vault.loadSubaccounts?` | `boolean` | - | | `vault.loans?` | `boolean` | - | | `vault.options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `vault.tokenizedVault?` | `ITokenizedVault` | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVault`> Complete vault object with optional enrichments *** #### getVaultAllocations() > **getVaultAllocations**(`vault`, `options`, `tokenizedVault?`): `Promise`<`IVaultAllocations`> Fetch comprehensive vault asset allocation breakdown. Includes DeFi protocols (via DeBank), CeFi balances, OTC positions, and loans. Categorizes exposures by borrowing, supplying, lending, and wallet holdings. DeFi exposure resolves per chain family: EVM vaults via DeBank, Solana borrowers via Octav.fi, and Stellar vaults via the Untangled portfolio API — one vault-level call covering the idle buffer, Stellar protocol positions, custody wallets, and capital bridged to other chains. The Stellar path adds exactly 1 HTTP call and zero for every other chain; when it fails, the exposure section comes back empty and the CeFi, OTC and loan allocations are still returned. **Parameters** | Parameter | Type | Description | | ----------------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `vault` | `` `0x${string}` `` | Vault address | | `options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | RPC configuration | | `tokenizedVault?` | `ITokenizedVault` | Optional pre-fetched backend row for `vault`. When a caller already holds the row (e.g. `getVault` fetched it one call earlier), passing it skips this function's own `GET /tokenized_vault/{address}` — a pure de-duplication of backend traffic. The row must carry the subaccount data this function reads (`.subaccounts`, `.eoa_operators`), so it must not have been fetched with `loadSubaccounts: false`; a row fetched that way would silently resolve zero borrowers. | **Returns** `Promise`<`IVaultAllocations`> Detailed allocation data with exposure categorization *** #### ~~getVaultAnnualizedApy()~~ > **getVaultAnnualizedApy**(`vault`): `Promise`<`IVaultAnnualizedApy`> Fetch annualized APY metrics for a vault. Supported Vaults: cUSDO, tETH, wstETH, rsETH **Parameters** | Parameter | Type | Description | | ---------------- | ---------------------------------------------------------------------------------------- | ---------------------- | | `vault` | { `options?`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.options?` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultAnnualizedApy`> Annualized APY data including liquidity APY **Deprecated** The `hgETH30dLiquidAPY` and `hgETH7dLiquidAPY` response fields are deprecated. These fields will be removed in the next major release. Use `liquidAPY30Day` and `liquidAPY7Day` fields instead. *** #### ~~getVaultApy()~~ > **getVaultApy**(`__namedParameters`): `Promise`<`object`\[]> **Parameters** | Parameter | Type | | ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | | `__namedParameters` | { `historical?`: `IVaultHistoricalParams`; `options?`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault`: `` `0x${string}` ``; } | | `__namedParameters.historical?` | `IVaultHistoricalParams` | | `__namedParameters.options?` | [`IVaultBaseOptions`](#ivaultbaseoptions) | | `__namedParameters.vault` | `` `0x${string}` `` | **Returns** `Promise`<`object`\[]> **Deprecated** use getVaultHistoricalTimeseries instead *** #### getVaultAvailableRedemptions() > **getVaultAvailableRedemptions**(`__namedParameters`): `Promise`<{ `availableRedemptions`: `IVaultAvailableRedemption`\[]; `pendingRedemptions`: `IVaultAvailableRedemption`\[]; `processedWithdrawals`: `ISubgraphWithdrawProccessed`\[]; `requestedWithdrawals`: `ISubgraphWithdrawRequest`\[]; }> **Parameters** | Parameter | Type | | --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | | `__namedParameters` | { `options`: [`IVaultBaseOptions`](#ivaultbaseoptions) & `object`; `vault`: `` `0x${string}` ``; `wallet?`: `` `0x${string}` ``; } | | `__namedParameters.options` | [`IVaultBaseOptions`](#ivaultbaseoptions) & `object` | | `__namedParameters.vault` | `` `0x${string}` `` | | `__namedParameters.wallet?` | `` `0x${string}` `` | **Returns** `Promise`<{ `availableRedemptions`: `IVaultAvailableRedemption`\[]; `pendingRedemptions`: `IVaultAvailableRedemption`\[]; `processedWithdrawals`: `ISubgraphWithdrawProccessed`\[]; `requestedWithdrawals`: `ISubgraphWithdrawRequest`\[]; }> *** #### getVaultBorrowerHealthFactor() > **getVaultBorrowerHealthFactor**(`vault`): `Promise`<`IVaultBorrowerHealthFactor`\[]> Build the per-loan borrower / health-factor list for a single vault. Resilience: individual loan reads (`loanState()`, `borrower()`) and the per-borrower August backend call are isolated with `Promise.allSettled` and try/catch so one bad loan — a test loan whose address isn't a real contract, a borrower the backend doesn't recognize, an intermittent RPC error — drops that single row from the result instead of rejecting the whole batch. Failed rows are logged via `Logger.log.warn`; the loan is still returned with `health_factor: undefined` so callers can render an explicit empty state rather than a perpetual loading skeleton. **Parameters** | Parameter | Type | Description | | --------------- | --------------------------------------------------------------------------------------- | ------------------------------------ | | `vault` | { `options`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault`: `` `0x${string}` ``; } | Vault address to scope the fetch to. | | `vault.options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultBorrowerHealthFactor`\[]> Array of `IVaultBorrowerHealthFactor`, one entry per active loan. *** #### getVaultHistoricalTimeseries() > **getVaultHistoricalTimeseries**(`__namedParameters`): `Promise`<`IHistoricalTimeseriesResponse`> **Parameters** | Parameter | Type | | ---------------------------- | ------------------------------------------------------------------------------------------------------------ | | `__namedParameters` | { `nDays?`: `number`; `options?`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault`: `` `0x${string}` ``; } | | `__namedParameters.nDays?` | `number` | | `__namedParameters.options?` | [`IVaultBaseOptions`](#ivaultbaseoptions) | | `__namedParameters.vault` | `` `0x${string}` `` | **Returns** `Promise`<`IHistoricalTimeseriesResponse`> *** #### getVaultLoans() > **getVaultLoans**(`vault`, `options`): `Promise`<`IVaultLoan`\[]> Vault Loans **Parameters** | Parameter | Type | | --------- | ----------------------------------------- | | `vault` | `string` \| `IVault` | | `options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | **Returns** `Promise`<`IVaultLoan`\[]> *** #### getVaultPendingRedemptions() > **getVaultPendingRedemptions**(`vault`): `Promise`<`IVaultPendingRedemptions`> Fetch pending redemptions for a vault with liquidity analysis. **Parameters** | Parameter | Type | Description | | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | | `vault` | { `futureDays?`: `number`; `options?`: [`IVaultBaseOptions`](#ivaultbaseoptions); `pastDays?`: `number`; `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.futureDays?` | `number` | - | | `vault.options?` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `vault.pastDays?` | `number` | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultPendingRedemptions`> Pending redemptions grouped by date with liquidity summary *** #### getVaultPnl() > **getVaultPnl**(`vault`): `Promise`<`IVaultPnl`> Calculate PnL for a vault (vault-level, not user-specific). Returns the vault's overall profit and loss across all users. **Parameters** | Parameter | Type | Description | | --------------- | --------------------------------------------------------------------------------------- | ---------------------- | | `vault` | { `options`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultPnl`> Vault PnL in USD and notional value *** #### getVaultPositions() > **getVaultPositions**(`__namedParameters`): `Promise`<`IVaultPosition`\[]> Vault Positions **Parameters** | Parameter | Type | | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `__namedParameters` | { `options`: [`IVaultBaseOptions`](#ivaultbaseoptions); `solanaWallet?`: `string`; `stellarWallet?`: `string`; `vault`: `` `0x${string}` ``; `wallet?`: `` `0x${string}` ``; } | | `__namedParameters.options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | | `__namedParameters.solanaWallet?` | `string` | | `__namedParameters.stellarWallet?` | `string` | | `__namedParameters.vault` | `` `0x${string}` `` | | `__namedParameters.wallet?` | `` `0x${string}` `` | **Returns** `Promise`<`IVaultPosition`\[]> *** #### getVaultRedemptionHistory() > **getVaultRedemptionHistory**(`__namedParameters`): `Promise`<`IVaultRedemptionHistoryItem`\[]> **Parameters** | Parameter | Type | | ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | | `__namedParameters` | { `lookbackBlocks?`: `number`; `options`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault`: `` `0x${string}` ``; `wallet?`: `` `0x${string}` ``; } | | `__namedParameters.lookbackBlocks?` | `number` | | `__namedParameters.options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | | `__namedParameters.vault` | `` `0x${string}` `` | | `__namedParameters.wallet?` | `` `0x${string}` `` | **Returns** `Promise`<`IVaultRedemptionHistoryItem`\[]> *** #### getVaultSubaccountLoans() > **getVaultSubaccountLoans**(`vault`, `options`): `Promise`<`IVaultLoan`\[]> Vault Subaccount Loans **Parameters** | Parameter | Type | | --------- | ----------------------------------------- | | `vault` | `string` \| `IVault` | | `options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | **Returns** `Promise`<`IVaultLoan`\[]> *** #### getVaultSummary() > **getVaultSummary**(`vault`): `Promise`<`IVaultSummary`> Fetch summary data for a vault (name, type, chain, recent returns). **Parameters** | Parameter | Type | Description | | ---------------- | ---------------------------------------------------------------------------------------- | ---------------------- | | `vault` | { `options?`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.options?` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultSummary`> Vault summary data *** #### getVaultTvl() > **getVaultTvl**(`__namedParameters`): `Promise`<`object`\[]> **Parameters** | Parameter | Type | | ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | | `__namedParameters` | { `historical?`: `IVaultHistoricalParams`; `options`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault`: `` `0x${string}` ``; } | | `__namedParameters.historical?` | `IVaultHistoricalParams` | | `__namedParameters.options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | | `__namedParameters.vault` | `` `0x${string}` `` | **Returns** `Promise`<`object`\[]> *** #### getVaultUserLifetimePnl() > **getVaultUserLifetimePnl**(`vault`): `Promise`<`IVaultUserLifetimePnl`> Calculate lifetime PnL for a user in a specific vault. Basic logic: 1. Get user's list of deposits and withdrawals from subgraph 2. Fetch user's current assets (balanceOf \* sharePrice via convertToAssets) 3. Calculate PnL = assets withdrawn + current assets - assets deposited `totalDeposited` is the face value of what the user actually paid in (each deposited asset's raw amount, rescaled to the vault's decimals — no live price conversion), so any entry/exit fee the vault charges is automatically counted as a cost against PnL rather than excluded from it. Pre-deposit multi-asset vaults are assumed to only accept dollar-pegged stablecoins into a dollar-denominated vault; a vault accepting a non-pegged deposit asset would need deposit-time price conversion, which this function does not perform. **Parameters** | Parameter | Type | Description | | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | | `vault` | { `coingeckoKey?`: `string`; `options`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault`: `` `0x${string}` ``; `wallet`: `` `0x${string}` ``; } | Vault contract address | | `vault.coingeckoKey?` | `string` | - | | `vault.options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `vault.vault` | `` `0x${string}` `` | - | | `vault.wallet` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultUserLifetimePnl`> Lifetime PnL data in both native token and USD *** #### getVaultWithdrawals() > **getVaultWithdrawals**(`vault`): `Promise`<`IVaultWithdrawals`> Fetch withdrawal summary and pending queue for a vault. **Parameters** | Parameter | Type | Description | | ---------------- | ----------------------------------------------------------------------------------------------------------- | ---------------------- | | `vault` | { `chain`: `string`; `options?`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.chain` | `string` | - | | `vault.options?` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVaultWithdrawals`> Withdrawal summary and pending queue *** #### getWithdrawalRequestsWithStatus() > **getWithdrawalRequestsWithStatus**(`params`): `Promise`<[`WithdrawalRequestStatus`](#withdrawalrequeststatus)\[]> Returns all withdrawal requests for a vault, enriched with computed claimable dates and current processing status. The unique identifier for matching requests to processed events is: (receiver, claimableDate.year, claimableDate.month, claimableDate.day) This is the primary method for integrators to reliably track withdrawal status when multiple requests are submitted by the same receiver. ### Data sources * **Withdrawal requests** come from the subgraph (all historical requests). * **Processed events** come from on-chain `WithdrawalProcessed` logs, which are limited to a finite lookback window determined by the chain's block parameters. ### Lookback window & filtering On-chain logs only cover a limited number of recent blocks (e.g. \~20 days on Monad, \~21 days on Ethereum). The `lookbackBlocks` parameter controls how far back to scan and is applied uniformly to both data sources: it bounds the `WithdrawalProcessed` log query *and* drops any withdrawal request whose submission timestamp falls outside the window — regardless of whether a matching processed event was found. Callers who need deeper history should widen `lookbackBlocks`. ### Status determination * `'processed'` — A matching `WithdrawalProcessed` event was found (by receiver + claimable date). * `'ready_to_claim'` — Claimable date has passed (within the lookback window) but no processed event found. * `'pending'` — Claimable date is still in the future. **Parameters** | Parameter | Type | Description | | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `params` | { `lookbackBlocks?`: `number`; `options`: [`IVaultBaseOptions`](#ivaultbaseoptions); `receiver?`: `` `0x${string}` ``; `vault`: `` `0x${string}` ``; } | Query parameters: - `vault` — Vault address to query. - `receiver` — (Optional) Filter by receiver address. - `lookbackBlocks` — (Optional) On-chain log lookback window in blocks. Defaults to a chain-specific value (e.g. 150,000 for Ethereum, 3,456,000 for Monad). Increasing this scans more history but requires more RPC calls. - `options` — Standard vault query options (provider, RPC URL, etc.). | | `params.lookbackBlocks?` | `number` | - | | `params.options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `params.receiver?` | `` `0x${string}` `` | - | | `params.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<[`WithdrawalRequestStatus`](#withdrawalrequeststatus)\[]> Array of withdrawal requests with status and claimable dates **Example** ```typescript const requests = await getWithdrawalRequestsWithStatus({ vault: '0xVault...', receiver: '0xReceiver...' }); // Results show exact status + claimable date requests.forEach(req => { console.log( `${req.claimableDate.year}-${req.claimableDate.month}-${req.claimableDate.day}: ${req.status}` ); }); // With custom lookback window (e.g. 30 days on Ethereum ≈ 216,000 blocks) const moreResults = await getWithdrawalRequestsWithStatus({ vault: '0xVault...', lookbackBlocks: 216_000, }); ``` *** #### getYieldLastRealizedOn() > **getYieldLastRealizedOn**(`vault`): `Promise`<`number`> Fetch the timestamp when yield was last realized for a vault. Returns the assetsUpdatedOn timestamp from the vault contract. **Parameters** | Parameter | Type | Description | | --------------- | --------------------------------------------------------------------------------------- | ---------------------- | | `vault` | { `options`: [`IVaultBaseOptions`](#ivaultbaseoptions); `vault`: `` `0x${string}` ``; } | Vault contract address | | `vault.options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `vault.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`number`> Timestamp (Unix timestamp in seconds) when yield was last realized *** #### registerUserForPoints() > **registerUserForPoints**(`userAddress`): `Promise`<`Response`> Register a user for the points program, authenticated by a wallet signature. The caller must obtain a personal\_sign (EIP-191) signature over the canonical message template below — the backend reconstructs the same string from these fields and verifies the signature recovers to `userAddress`. Building the message client-side and server-side from the same primitives means a hostile client cannot show one message in the wallet prompt while submitting a different one for validation. Canonical message (`\n`-separated, no trailing newline): ``` Upshift: register {userAddress.toLowerCase()} referrer: {referrerAddress.toLowerCase() || "none"} chain: {chainId} nonce: {nonce} expires: {expiry} ``` **Parameters** | Parameter | Type | Description | | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | | `userAddress` | { `chainId`: `number`; `expiry`: `number`; `nonce`: `string`; `options?`: [`IVaultBaseOptions`](#ivaultbaseoptions); `referrerAddress?`: `` `0x${string}` ``; `signature`: `string`; `userAddress`: `` `0x${string}` ``; } | EVM wallet address being registered. Must match the signer that produced `signature`. Lowercased before being embedded in the canonical message. | | `userAddress.chainId` | `number` | - | | `userAddress.expiry` | `number` | - | | `userAddress.nonce` | `string` | - | | `userAddress.options?` | [`IVaultBaseOptions`](#ivaultbaseoptions) | - | | `userAddress.referrerAddress?` | `` `0x${string}` `` | - | | `userAddress.signature` | `string` | - | | `userAddress.userAddress` | `` `0x${string}` `` | - | **Returns** `Promise`<`Response`> Raw `Response` from the backend. 200 on success, 401 for expired / replayed / mismatched-signer / tampered-referrer, 422 for an unsupported `chainId`. **Example** ```ts const nonce = crypto.randomUUID().replace(/-/g, ''); const expiry = Math.floor(Date.now() / 1000) + 300; const message = `Upshift: register ${address.toLowerCase()}\n` + `referrer: ${referrer?.toLowerCase() ?? 'none'}\n` + `chain: ${chainId}\n` + `nonce: ${nonce}\n` + `expires: ${expiry}`; const signature = await walletClient.signMessage({ account: address, message }); await registerUserForPoints({ userAddress: address, referrerAddress: referrer, chainId, signature, nonce, expiry }); ``` *** #### sumDepositsAtFaceValue() > **sumDepositsAtFaceValue**(`depositsByAsset`, `assetDecimals`, `vaultDecimals`): `bigint` Sum a wallet's per-asset deposits into the vault's own decimals, at face value — 1 unit of any deposited asset is treated as 1 unit of the vault's reporting currency, with no live price conversion. Used by [getVaultUserLifetimePnl](#getvaultuserlifetimepnl-2) for `totalDeposited`. Pre-deposit multi-asset vaults only accept dollar-pegged stablecoins (USDC, USDT, DAI, USDS, RLUSD, etc.) into a dollar-denominated vault, so face value is a reasonable stand-in for USD value. This intentionally does NOT re-quote through a live price oracle: doing so priced a historical deposit at today's market rate, so `totalDeposited` (and lifetimePnl) drifted between calls purely from stablecoin peg noise, and approximately re-inflated deposits back toward face value — which silently excluded the vault's entry fee from PnL. The fee is money the user actually paid, so PnL must be computed net of it. **Parameters** | Parameter | Type | Description | | ----------------- | ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | | `depositsByAsset` | `Map`<`string`, `bigint`> | Raw deposited amount per asset, keyed by lowercased asset address (or `'default'` / `'lz-default'` for single-asset / cross-chain rows). | | `assetDecimals` | `Map`<`string`, `number`> | Decimals for each key in `depositsByAsset`. | | `vaultDecimals` | `number` | The vault's own decimals — the target scale every asset is rescaled to. | **Returns** `bigint` Total deposited, in raw base units at `vaultDecimals`. ### References #### default Renames and re-exports [AugustVaults](#augustvaults)