💰Vaults

Query vault data across EVM and Solana chains. All vault getters are available on the main AugustSDK class.

Overview

The August SDK provides comprehensive vault querying capabilities across all supported chains. Vaults follow the ERC4626 standard and include additional features for loan management, allocations, and user positions.

Vault Versions

Version	Description	Chains
evm-0	Legacy vaults	Ethereum, Arbitrum
evm-1	Standard vaults	All EVM chains
evm-2	Multi-asset vaults	Ethereum, Base
sol-0	Solana vaults	Solana Mainnet

Get All Vaults

Fetch all vaults across configured networks with optional enrichment.

sdk.getVaults(options?: {
  chainIds?: number[];
  loans?: boolean;
  allocations?: boolean;
  wallet?: string;
  solanaWallet?: string;
}): Promise<IVault[]>

Parameters

Parameter	Type	Required	Description
options.chainIds	number[]	No	Filter by specific chain IDs
options.loans	boolean	No	Include loan data (default: true)
options.allocations	boolean	No	Include allocation data (default: true)
options.wallet	string	No	EVM wallet to fetch positions for
options.solanaWallet	string	No	Solana wallet to fetch positions for

Returns

Array of IVault objects

Example

import { AugustSDK } from '@augustdigital/sdk';

const sdk = new AugustSDK({
  providers: {
    1: 'https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY',
    42161: 'https://arb-mainnet.g.alchemy.com/v2/YOUR_KEY',
  },
});

// Get all vaults
const vaults = await sdk.getVaults();
console.log(`Found ${vaults.length} vaults`);

// Filter by chain
const ethVaults = await sdk.getVaults({ chainIds: [1] });

// Include user positions
const vaultsWithPositions = await sdk.getVaults({
  wallet: '0xYourWallet...',
  loans: false, // Skip loan data for faster response
});

Get Single Vault

Fetch detailed data for a specific vault with optional enrichment.

sdk.getVault({
  vault: string;
  chainId?: number;
  options?: {
    loans?: boolean;
    allocations?: boolean;
    wallet?: string;
    solanaWallet?: string;
  };
}): Promise<IVault>

Parameters

Parameter	Type	Required	Description
vault	string	Yes	Vault contract address or program ID
chainId	number	No	Chain ID (uses active network if not provided)
options.loans	boolean	No	Include loan data (default: true)
options.allocations	boolean	No	Include allocation data (default: true)
options.wallet	string	No	EVM wallet for position data
options.solanaWallet	string	No	Solana wallet for position data

Returns

Single IVault object

Example

// Get vault with all data
const vault = await sdk.getVault({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  chainId: 1,
});

console.log(vault.name); // "Upshift USDC"
console.log(vault.apy); // Vault APY
console.log(vault.depositAssets); // All supported deposit tokens

// Get vault with user position
const vaultWithPosition = await sdk.getVault({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  chainId: 1,
  options: {
    wallet: '0xYourWallet...',
    loans: false,
  },
});

console.log(vaultWithPosition.position?.walletBalance);

Get Vault Summary

Fetch summary data for a vault including name, type, chain, and recent returns.

sdk.getVaultSummary({
  vault: string;
}): Promise<IVaultSummary>

Parameters

Parameter	Type	Required	Description
vault	string	Yes	Vault contract address

Returns

IVaultSummary object with name, type, chain, and recent returns.

Example

const summary = await sdk.getVaultSummary({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
});

console.log(summary.name);
console.log(summary.chain);
console.log(summary.recentReturns.day);
console.log(summary.recentReturns.week);
console.log(summary.recentReturns.month);

Get Vault Loans

Fetch active loan data for a vault (EVM-0 vaults only).

sdk.getVaultLoans({
  vault: string;
  chainId?: number;
}): Promise<IVaultLoan[]>

Returns

Array of loan objects with borrower, principal, interest, and APR data.

Example

const loans = await sdk.getVaultLoans({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  chainId: 1,
});

loans.forEach(loan => {
  console.log(`Borrower: ${loan.borrower}`);
  console.log(`Principal: ${loan.principalAmount}`);
  console.log(`APR: ${loan.apr}%`);
});

Get Vault Allocations

Fetch DeFi, CeFi, and OTC allocation breakdowns for a vault.

sdk.getVaultAllocations({
  vault: string;
  chainId?: number;
}): Promise<IVaultAllocations>

Returns

Object containing defi, cefi, otc, and tokens arrays.

Example

const allocations = await sdk.getVaultAllocations({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  chainId: 1,
});

console.log('DeFi protocols:', allocations.defi.length);
console.log('CeFi positions:', allocations.cefi.length);
console.log('Net value:', allocations.netValue);

Get Vault APY

Deprecated: Use getVaultHistoricalTimeseries instead for comprehensive historical data.

Fetch current or historical APY data for a vault. This will return a time series. If you are looking for a single value (ie for 30D APY) please take a look at the tokenizedVault response, namely the field historical_apy that will have this information.

sdk.getVaultApy({
  vault: string;
  historical?: {
    daysAgo?: number;
    order?: 'asc' | 'desc';
    interval?: 'days' | 'weeks' | 'months' | 'years';
  };
}): Promise<{ value: number; timestamp: string }[]>

Returns

Array of APY data points with timestamps.

Example

// Current APY
const [current] = await sdk.getVaultApy({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
});
console.log('Current APY:', current.value);

// Historical APY
const historical = await sdk.getVaultApy({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  historical: {
    daysAgo: 30,
    interval: 'days',
    order: 'desc',
  },
});

Get Vault Annualized APY

Fetch annualized APY metrics for specific vaults.

Supported Vaults: cUSDO, tETH, wstETH, rsETH

Deprecation Notice: The hgETH30dLiquidAPY and hgETH7dLiquidAPY response fields are deprecated and will be removed on 2026-01-01. Use liquidAPY30Day and liquidAPY7Day instead.

sdk.getVaultAnnualizedApy({
  vault: string;
}): Promise<IVaultAnnualizedApy>

Parameters

Parameter	Type	Required	Description
vault	string	Yes	Vault contract address

Returns

IVaultAnnualizedApy object with liquidity APY and annualized metrics.

Example

const apy = await sdk.getVaultAnnualizedApy({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
});

console.log('Liquidity APY:', apy.liquidityApy);
console.log('Annualized APY:', apy.annualizedApy);
console.log('7-day Liquid APY:', apy.liquidAPY7Day);
console.log('30-day Liquid APY:', apy.liquidAPY30Day);

Get Vault Historical Timeseries

Fetch comprehensive historical timeseries data for a vault including TVL, APY, PnL, share price, and other metrics.

sdk.getVaultHistoricalTimeseries({
  vault: string;
  nDays?: number;
}): Promise<IHistoricalTimeseriesResponse>

Parameters

Parameter	Type	Required	Description
vault	string	Yes	Vault contract address
nDays	number	No	Number of days of historical data (default: 30, min: 1)

Returns

Historical timeseries data object with date string keys containing TVL, APY, PnL, and share price.

Example

const timeseries = await sdk.getVaultHistoricalTimeseries({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  nDays: 30,
});

// Access historical data by date
Object.entries(timeseries).forEach(([date, data]) => {
  console.log(`${date}: TVL=${data.tvl}, APY=${data.apy}`);
});

Get Vault TVL

Fetch current or historical total value locked (TVL) for a vault.

sdk.getVaultTvl({
  vault: string;
  chainId?: number;
  historical?: {
    daysAgo?: number;
    order?: 'asc' | 'desc';
    interval?: 'days' | 'weeks' | 'months' | 'years';
  };
}): Promise<{ value: INormalizedNumber; timestamp: string }[]>

Returns

Array of TVL data points with timestamps.

Example

// Current TVL
const [current] = await sdk.getVaultTvl({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  chainId: 1,
});

console.log('TVL:', current.value.normalized);

// Historical TVL
const historical = await sdk.getVaultTvl({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  chainId: 1,
  historical: { daysAgo: 7, interval: 'days' },
});

Get Vault Positions

Fetch user positions across one or all vaults.

sdk.getVaultPositions({
  vault?: string;
  wallet?: string;
  chainId?: number;
  showAllVaults?: boolean;
  solanaWallet?: string;
}): Promise<IVaultPosition[]>

Parameters

Parameter	Type	Required	Description
vault	string	No	Specific vault address (omit for all vaults)
wallet	string	No	EVM wallet address
solanaWallet	string	No	Solana wallet address
chainId	number	No	Filter by specific chain
showAllVaults	boolean	No	Include vaults with no position (default: false)

Returns

Array of vault position objects.

Example

// Get all positions for a wallet
const positions = await sdk.getVaultPositions({
  wallet: '0xYourWallet...',
  chainId: 1,
});

positions.forEach(pos => {
  console.log(`Vault: ${pos.vault}`);
  console.log(`Balance: ${pos.walletBalance.normalized}`);
  console.log(`Status: ${pos.status}`); // STAKED, REDEEM, or PENDING
  console.log(`Available redemptions: ${pos.availableRedemptions.length}`);
});

// Get position for specific vault
const vaultPosition = await sdk.getVaultPositions({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  wallet: '0xYourWallet...',
  chainId: 1,
});

Get Available Redemptions

Fetch claimable redemption requests for a vault and wallet.

sdk.getVaultAvailableRedemptions({
  vault: string;
  chainId?: number;
  wallet?: string;
  verbose?: boolean;
}): Promise<{
  availableRedemptions: IVaultAvailableRedemption[];
  pendingRedemptions: IVaultAvailableRedemption[];
}>

Returns

Object with availableRedemptions (ready to claim) and pendingRedemptions (waiting for lag period).

Example

const { availableRedemptions, pendingRedemptions } = 
  await sdk.getVaultAvailableRedemptions({
    vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
    chainId: 1,
    wallet: '0xYourWallet...',
  });

console.log(`Available to claim: ${availableRedemptions.length}`);
console.log(`Pending: ${pendingRedemptions.length}`);

// Claim available redemptions
for (const redemption of availableRedemptions) {
  console.log(`Can claim ${redemption.amount.normalized} tokens`);
  console.log(`Date: ${redemption.date}`);
}

Get Vault Withdrawals

Fetch withdrawal summary and pending withdrawal queue for a vault.

sdk.getVaultWithdrawals({
  vault: string;
  chainId?: number;
}): Promise<IVaultWithdrawals>

Parameters

Parameter	Type	Required	Description
vault	string	Yes	Vault contract address
chainId	number	No	Chain ID (uses active network if not provided)

Returns

IVaultWithdrawals object containing total withdrawals and pending queue.

Example

const withdrawals = await sdk.getVaultWithdrawals({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  chainId: 1,
});

console.log('Total withdrawals:', withdrawals.totalWithdrawals.normalized);
console.log('Pending queue:', withdrawals.pendingQueue.length);

withdrawals.pendingQueue.forEach(item => {
  console.log(`Amount: ${item.amount.normalized}`);
  console.log(`Requested at: ${item.requestedAt}`);
  console.log(`Estimated completion: ${item.estimatedCompletionDate}`);
});

Get Vault PnL

Fetch vault-level profit and loss (not user-specific).

sdk.getVaultPnl({
  vault: string;
  chainId?: number;
}): Promise<IVaultPnl>

Parameters

Parameter	Type	Required	Description
vault	string	Yes	Vault contract address
chainId	number	No	Chain ID (uses active network if not provided)

Returns

IVaultPnl object with total PnL in native token and USD.

Example

const pnl = await sdk.getVaultPnl({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  chainId: 1,
});

console.log('Total PnL:', pnl.totalPnl.normalized);
console.log('PnL in USD:', pnl.pnlUsd);

Get User Lifetime PnL

Calculate lifetime profit and loss for a user in a specific vault.

sdk.getVaultUserLifetimePnl({
  vault: string;
  wallet: string;
  chainId?: number;
}): Promise<IVaultUserLifetimePnl>

Parameters

Parameter	Type	Required	Description
vault	string	Yes	Vault contract address
wallet	string	Yes	User wallet address
chainId	number	No	Chain ID (uses active network if not provided)

Returns

IVaultUserLifetimePnl object with realized and unrealized PnL.

Example

const userPnl = await sdk.getVaultUserLifetimePnl({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  wallet: '0xYourWallet...',
  chainId: 1,
});

console.log('Token Symbol:', userPnl.tokenSymbol);
console.log('Total Deposited:', userPnl.totalDeposited.normalized);
console.log('Total Withdrawn:', userPnl.totalWithdrawn.normalized);
console.log('Current Position Value:', userPnl.currentPositionValue.normalized);
console.log('Lifetime PnL:', userPnl.lifetimePnl.normalized);
console.log('Lifetime PnL (USD):', userPnl.lifetimePnlUsd);
console.log('PnL Percentage:', userPnl.pnlPercentage);

Get Yield Last Realized

Get the timestamp when yield was last realized for a vault.

sdk.getYieldLastRealizedOn({
  vault: string;
  chainId?: number;
}): Promise<number>

Parameters

Parameter	Type	Required	Description
vault	string	Yes	Vault contract address
chainId	number	No	Chain ID (uses active network if not provided)

Returns

Unix timestamp (in seconds) when yield was last realized.

Example

const timestamp = await sdk.getYieldLastRealizedOn({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  chainId: 1,
});

const date = new Date(timestamp * 1000);
console.log('Yield last realized:', date.toISOString());

Get Borrower Health Factor

Get the borrower's health factor by vault.

sdk.getVaultBorrowerHealthFactor({
  chainId?: number;
}): Promise<Record<string, number>>

Parameters

Parameter	Type	Required	Description
chainId	number	No	Filter by specific chain ID

Returns

Object mapping vault addresses to their borrower health factors.

Example

const healthFactors = await sdk.getVaultBorrowerHealthFactor({
  chainId: 1,
});

Object.entries(healthFactors).forEach(([vaultAddress, factor]) => {
  console.log(`Vault ${vaultAddress}: Health Factor = ${factor}`);
});

IVault Interface

All vault getter methods return the IVault interface:

interface IVault {
  // Basic Info
  address: string;
  chainId: number;
  name: string;
  logoUrl: string;
  description: string;
  status: 'active' | 'closed' | 'testing';
  version: 'evm-0' | 'evm-1' | 'evm-2' | 'sol-0';
  
  // Receipt Token
  receipt: {
    address: string;
    symbol: string;
    decimals: number;
  };
  
  // Deposit Assets (includes adapter tokens)
  depositAssets: Array<{
    address: string;
    symbol: string;
    decimals: number;
  }>;
  
  // Vault Metrics
  decimals: number;
  totalAssets: INormalizedNumber;
  totalSupply: INormalizedNumber;
  maxSupply: INormalizedNumber;
  idleAssets: INormalizedNumber;
  
  // APY & Rewards
  apy: {
    apy: number;
    explainer: string;
    liquidApy: number;
    rewardsClaimable: number;
    rewardsCompounded: number;
    underlyingApy: number;
  };
  rewards: {
    points: string;
    multiplier: number;
    multipliers: Array<{ value: number; timestamp: number }>;
    additionalPoints: string[];
  };
  
  // Management
  operator: string;
  strategists: Array<{
    address: string;
    logo: string;
    name: string;
  }>;
  fees: {
    management: number;
    isManagementWaived: boolean;
    performance: number;
    isPerformanceWaived: boolean;
  };
  
  // Settings
  tags: string[];
  isFeatured: boolean;
  isVisible: boolean;
  reserveTarget: number;
  reserveTolerance: number;
  lagDuration: number;
  maxDailyDrawdown: number;
  risk: string;
  isWithdrawalPaused: boolean;
  isDepositPaused: boolean;
  startDatetime: string;
  
  // Optional Enrichments
  loans?: IVaultLoan[];
  allocations?: IVaultAllocations;
  position?: IVaultPosition;
}

Key Fields

depositAssets - Array of all supported deposit tokens including:

• Underlying asset (always first)

• Adapter tokens (if available)

• Whitelisted assets (for multi-asset vaults)

version - Determines which deposit/withdrawal functions to use:

• evm-0, evm-1: 2-param deposit

• evm-2: 3-param deposit with asset selection

position - User-specific data (when wallet provided):

• Wallet balance

• Available redemptions

• Pending redemptions

• Redeemable amount

Additional Getters

Get User History

sdk.getUserHistory({
  wallet: string;
  chainId?: number;
  vault?: string;
}): Promise<IVaultUserHistoryItem[]>

Returns user transaction history (deposits, withdrawals, etc.).

Get User Transfers

sdk.getUserTransfers({
  wallet: string;
  chainId?: number;
  vault?: string;
}): Promise<IVaultTransfer[]>

Returns vault share transfer history for a user.

Get Staking Positions

sdk.getStakingPositions(
  wallet?: string,
  chainId?: number
): Promise<IActiveStakingPosition[]>

Returns active reward staking positions.

Examples

Complete Vault Query

const vault = await sdk.getVault({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  chainId: 1,
  options: {
    loans: true,
    allocations: true,
    wallet: '0xYourWallet...',
  },
});

// Basic info
console.log(vault.name);
console.log(vault.version);
console.log(vault.apy.apy);

// Deposit options
console.log('Can deposit:', vault.depositAssets.map(a => a.symbol));

// User position
if (vault.position) {
  console.log('Your balance:', vault.position.walletBalance.normalized);
  console.log('Available redemptions:', vault.position.availableRedemptions.length);
}

// Loans (if available)
if (vault.loans) {
  console.log('Active loans:', vault.loans.length);
}

Filter Vaults by Criteria

const vaults = await sdk.getVaults();

// High APY vaults
const highYield = vaults.filter(v => v.apy.apy > 10);

// Featured vaults
const featured = vaults.filter(v => v.isFeatured);

// Active vaults only
const active = vaults.filter(v => v.status === 'active');

// Vaults with deposits enabled
const depositable = vaults.filter(v => !v.isDepositPaused);

// Multi-asset vaults
const multiAsset = vaults.filter(v => v.version === 'evm-2');

Check Deposit Options

const vault = await sdk.getVault({
  vault: '0x5Fde59415625401278c4d41C6beFCe3790eb357f',
  chainId: 1,
});

// Show all deposit options to user
console.log('You can deposit:');
vault.depositAssets.forEach(asset => {
  console.log(`- ${asset.symbol} (${asset.address})`);
});
// Output:
// - wstETH (0x7f39...)  <- Underlying
// - WETH (0xC02a...)    <- Adapter
// - ETH (0x0000...)     <- Adapter

Error Handling

try {
  const vault = await sdk.getVault({
    vault: vaultAddress,
    chainId: 1,
  });
} catch (error) {
  if (error.message.includes('Missing RPC URL')) {
    console.error('Configure RPC for this chain');
  } else if (error.message.includes('not found')) {
    console.error('Vault does not exist');
  } else {
    console.error('Failed to fetch vault:', error.message);
  }
}