Skip to main content
Retrieves the list of token metadata across all accounts, with optional filtering by yield strategy, chain, address, or symbol. This returns token-level information only (address, symbol, decimals, chains) — it does not indicate whether a specific token is currently depositable or withdrawable on a given account.
The assets returned by getSupportedAssets() are not guaranteed to be depositable or withdrawable on every account. Deposit/withdrawal availability is a per-account, per-asset property. To check whether an asset is currently depositable or withdrawable for a specific account, use getVaultsByConfig() and inspect vault.supportedAssets[].depositable / vault.supportedAssets[].withdrawable.

​
Import

import { getSupportedAssets, YieldType } from '@paxoslabs/amplify-sdk'

​
Usage

// All supported assets (cache-first)
const allAssets = await getSupportedAssets()

// Filter by yield strategy
const coreAssets = await getSupportedAssets({ yieldType: YieldType.CORE })

// Filter by chain IDs
const ethAssets = await getSupportedAssets({ chains: [1, 8453] })

// Combine filters
const coreEthAssets = await getSupportedAssets({
  yieldType: YieldType.CORE,
  chains: [1],
})

// Filter by token address (cache-only)
const usdc = await getSupportedAssets({
  address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
})

// Filter by symbol (cache-only)
const usdcBySymbol = await getSupportedAssets({ symbol: 'USDC' })

​
Parameters

All parameters are optional and can be combined to narrow the results.
ParameterTypeRequiredDescription
yieldTypeYieldTypeNoFilter by yield strategy (CORE, TREASURY, or FRONTIER)
chainsnumber[]NoFilter by chain IDs (e.g., [1, 8453])
addressstringNoFilter by exact token address (cache-only)
symbolstringNoFilter by token symbol (cache-only)
interface AssetFilterOptions {
  /** Filter by yield type (CORE, TREASURY, FRONTIER) */
  yieldType?: YieldType
  /** Filter by chain IDs (e.g., [1, 8453]) */
  chains?: number[]
  /** Filter by exact token address (cache-only) */
  address?: string
  /** Filter by token symbol (cache-only) */
  symbol?: string
}
The yieldType and chains filters are applied at the API level. The address and symbol filters are applied client-side against the cached asset data.

​
Return Type

Returns SupportedAsset[] — token metadata only. This type intentionally does not include depositable or withdrawable flags because those are per-account properties. See VaultSupportedAsset below for per-account flags. 
interface SupportedAsset {
  /** Token contract address */
  address: `0x${string}`;
  /** Token symbol (e.g., "USDC") */
  symbol: string;
  /** Full token name (e.g., "USD Coin") */
  name: string;
  /** Token decimals (e.g., 6 for USDC) */
  decimals: number;
  /** CoinGecko token identifier for price lookups */
  coinGeckoTokenId?: string;
  /** Chain IDs where this token is supported */
  chains: number[];
}

type FetchSupportedAssetsResult = SupportedAsset[];

​
Examples

import { getSupportedAssets } from "@paxoslabs/amplify-sdk";

// Assets available on Ethereum and Base
const assets = await getSupportedAssets({ chains: [1, 8453] });

console.log(`Found ${assets.length} supported assets`);
assets.forEach((asset) => {
  console.log(`${asset.symbol}: chains ${asset.chains.join(", ")}`);
});

​
Account-Level Availability

The depositable and withdrawable flags live on each account’s supportedAssets array as VaultSupportedAsset, not on the global SupportedAsset returned here. The same token may be depositable on one account but not another. 
import { getVaultsByConfig, YieldType } from '@paxoslabs/amplify-sdk'

const vaults = await getVaultsByConfig({
  yieldType: YieldType.CORE,
  chainId: 1,
})

for (const vault of vaults) {
  for (const asset of vault.supportedAssets) {
    console.log(
      `${asset.symbol} on ${vault.name}: ` +
        `deposit=${asset.depositable}, withdraw=${asset.withdrawable}`
    )
  }
}

interface VaultSupportedAsset {
  address: `0x${string}`
  symbol: string
  name: string
  decimals: number
  coinGeckoTokenId?: string
  /** Whether deposits are currently enabled for this vault-asset pair */
  depositable?: boolean
  /** Whether withdrawals are currently enabled for this vault-asset pair */
  withdrawable?: boolean
}

​
Checking Permit Support

To determine the optimal deposit flow for a token, use prepareDepositAuthorization() which automatically detects permit support at the contract level: 
import {
  prepareDepositAuthorization,
  isPermitAuth,
  getVaultsByConfig,
  YieldType,
} from '@paxoslabs/amplify-sdk'

const [vault] = await getVaultsByConfig({
  yieldType: YieldType.CORE,
  chainId: 1,
})

const auth = await prepareDepositAuthorization({
  vaultName: vault.name,
  depositAsset: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
  depositAmount: '100',
  to: userAddress,
  chainId: 1,
})

if (isPermitAuth(auth)) {
  console.log('Token supports gasless permit signatures')
} else {
  console.log('Token requires standard approval')
}

​
Error Handling

Error Message PatternDescriptionResolution
"SDK not initialized"SDK not initializedCall initAmplifySDK() first
"No vault found"No account matches parametersVerify yieldType and chainId
import { getSupportedAssets, YieldType, APIError } from '@paxoslabs/amplify-sdk'

try {
  const assets = await getSupportedAssets({ yieldType: YieldType.CORE })
} catch (error) {
  if (error instanceof APIError) {
    console.error(`API Error [${error.endpoint}]: ${error.message}`)
  }
}