> ## Documentation Index
> Fetch the complete documentation index at: https://developers.paxoslabs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# getSupportedAssets

> Retrieve supported deposit assets with optional filters for yield type, chain, address, and symbol

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.

<Warning>
  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()`](/v0.5.2/intro/products/earn/developers/api/getVaultsByConfig)
  and inspect `vault.supportedAssets[].depositable` /
  `vault.supportedAssets[].withdrawable`.
</Warning>

## Import

```ts theme={null}
import { getSupportedAssets, YieldType } from '@paxoslabs/amplify-sdk'
```

## Usage

```ts theme={null}
// 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.

| Parameter   | Type        | Required | Description                                                  |
| ----------- | ----------- | -------- | ------------------------------------------------------------ |
| `yieldType` | `YieldType` | No       | Filter by yield strategy (`CORE`, `TREASURY`, or `FRONTIER`) |
| `chains`    | `number[]`  | No       | Filter by chain IDs (e.g., `[1, 8453]`)                      |
| `address`   | `string`    | No       | Filter by exact token address (cache-only)                   |
| `symbol`    | `string`    | No       | Filter by token symbol (cache-only)                          |

```ts theme={null}
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
}
```

<Info>
  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.
</Info>

## 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`](#account-level-availability) below for per-account flags.

<Tabs>
  <Tab title="Type Definition">
    ```ts theme={null}
    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[];
    ```
  </Tab>

  <Tab title="Example Response">
    ```ts theme={null}
    [
      {
        address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        symbol: "USDC",
        name: "USD Coin",
        decimals: 6,
        coinGeckoTokenId: "usd-coin",
        chains: [1],
      },
      {
        address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
        symbol: "USDT",
        name: "Tether USD",
        decimals: 6,
        coinGeckoTokenId: "tether",
        chains: [1],
      },
    ]
    ```
  </Tab>
</Tabs>

## Examples

<Tabs>
  <Tab title="By Chain">
    ```ts theme={null}
    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(", ")}`);
    });
    ```
  </Tab>

  <Tab title="Combined Filters">
    ```ts theme={null}
    import { getSupportedAssets, YieldType } from "@paxoslabs/amplify-sdk";

    // CORE assets on Ethereum only
    const assets = await getSupportedAssets({
      yieldType: YieldType.CORE,
      chains: [1],
    });

    // Find USDC by symbol (cache-only filter)
    const usdc = await getSupportedAssets({ symbol: "USDC" });
    ```
  </Tab>

  <Tab title="With React Query">
    ```tsx theme={null}
    import { useQuery } from "@tanstack/react-query";
    import {
      getSupportedAssets,
      type AssetFilterOptions,
    } from "@paxoslabs/amplify-sdk";

    function useAssets(filters?: AssetFilterOptions) {
      return useQuery({
        queryKey: ["assets", filters],
        queryFn: () => getSupportedAssets(filters),
        staleTime: 5 * 60 * 1000,
      });
    }

    // Fetch all assets
    const { data: allAssets } = useAssets();

    // Fetch assets on a specific chain
    const { data: ethAssets } = useAssets({ chains: [1] });
    ```
  </Tab>

  <Tab title="Asset Selector">
    ```tsx theme={null}
    import { useQuery } from "@tanstack/react-query";
    import { getSupportedAssets } from "@paxoslabs/amplify-sdk";

    function AssetSelector({
      chainId,
      onSelect,
    }: {
      chainId: number;
      onSelect: (address: string) => void;
    }) {
      const { data: assets } = useQuery({
        queryKey: ["assets", chainId],
        queryFn: () => getSupportedAssets({ chains: [chainId] }),
      });

      return (
        <select onChange={(e) => onSelect(e.target.value)}>
          <option value="">Select asset</option>
          {assets?.map((asset) => (
            <option key={asset.address} value={asset.address}>
              {asset.symbol}
            </option>
          ))}
        </select>
      );
    }
    ```
  </Tab>
</Tabs>

## 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.

```ts theme={null}
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}`
    )
  }
}
```

```ts theme={null}
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:

```ts theme={null}
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 Pattern   | Description                   | Resolution                    |
| ----------------------- | ----------------------------- | ----------------------------- |
| `"SDK not initialized"` | SDK not initialized           | Call `initAmplifySDK()` first |
| `"No vault found"`      | No account matches parameters | Verify yieldType and chainId  |

```ts theme={null}
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}`)
  }
}
```

## Related

* [YieldType](/v0.5.2/intro/products/earn/developers/types/YieldType) - Yield strategy types
* [Deposit Workflow](/v0.5.2/intro/products/earn/developers/api/deposit-workflow) - Using assets for deposits
* [Deposits Guide](/v0.5.2/intro/products/earn/developers/guides/deposits) - Complete deposit examples