> 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 **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**(`__namedParameters`): `Promise`<`IVaultAllocations` | { `message`: `string`; `status`: `number`; }> **Parameters** | Parameter | Type | | ---------------------------- | ------------------------------------------------------- | | `__namedParameters` | { `chainId?`: `number`; `vault`: `` `0x${string}` ``; } | | `__namedParameters.chainId?` | `number` | | `__namedParameters.vault` | `` `0x${string}` `` | **Returns** `Promise`<`IVaultAllocations` | { `message`: `string`; `status`: `number`; }> ~~**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 on 2026-01-01. 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**(`__namedParameters`): `Promise`<`IVaultLoan`\[]> **Parameters** | Parameter | Type | | ---------------------------- | ------------------------------------------------------- | | `__namedParameters` | { `chainId?`: `number`; `vault`: `` `0x${string}` ``; } | | `__namedParameters.chainId?` | `number` | | `__namedParameters.vault` | `` `0x${string}` `` | **Returns** `Promise`<`IVaultLoan`\[]> **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 with `benchmarks/request-counter.js` 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 with `benchmarks/request-counter.js` 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?` | `object` & [`IVaultCustomOptions`](#ivaultcustomoptions) | Filtering and enrichment configuration | **Returns** `Promise`<`IVault`\[]> Array of vault objects with optional loans/allocations/positions **getVaultSubaccountLoans()** > **getVaultSubaccountLoans**(`__namedParameters`): `Promise`<`IVaultLoan`\[]> **Parameters** | Parameter | Type | | ---------------------------- | ------------------------------------------------------- | | `__namedParameters` | { `chainId?`: `number`; `vault`: `` `0x${string}` ``; } | | `__namedParameters.chainId?` | `number` | | `__namedParameters.vault` | `` `0x${string}` `` | **Returns** `Promise`<`IVaultLoan`\[]> **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 API keys and authorize SDK usage. TODO: initialize class with appropriate keys and verify august key **Returns** `Promise`<`void`> **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 #### 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. **Properties** | Property | Type | | ---------------- | ------------------- | | `allocations?` | `boolean` | | `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` | `"ready_to_claim"` \| `"processed"` \| `"pending"` | Current status of the withdrawal | | `transactionHash` | `string` | Transaction hash of the withdrawal request | ### Functions #### assertPnlHistoryConsistent() > **assertPnlHistoryConsistent**(`params`): `void` Guard against the 2026-07-09 lifetime-PnL over-inflation failure mode. 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); `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.vault` | `` `0x${string}` `` | - | **Returns** `Promise`<`IVault`> Complete vault object with optional enrichments *** #### getVaultAllocations() > **getVaultAllocations**(`vault`, `options`): `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. **Parameters** | Parameter | Type | Description | | --------- | ----------------------------------------- | ----------------- | | `vault` | `` `0x${string}` `` | Vault address | | `options` | [`IVaultBaseOptions`](#ivaultbaseoptions) | RPC configuration | **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 on 2026-01-01. 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 **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 }); ``` ### References #### default Renames and re-exports [AugustVaults](#augustvaults)