SDK Reference

import { GauntletClient } from '@gauntlet-xyz/sdk'
import { createPublicClient, createWalletClient, http } from 'viem'
import { base } from 'viem/chains'

const client = new GauntletClient({
  evmClients: {
    [base.id]: createPublicClient({ chain: base, transport: http(process.env.RPC_URL_BASE!) }),
  },
  wallet: createWalletClient({
    account,
    chain: base,
    transport: http(process.env.RPC_URL_BASE!),
  }),
})

import { getVaults } from '@gauntlet-xyz/sdk/evm'
// also available from the root: import { getVaults } from '@gauntlet-xyz/sdk'
import { base } from 'viem/chains'

const candidates = await getVaults(client, { chainId: base.id })
// returns:
// [
//   {
//     vaultId: "baseUsdcPrime",
//     name: "...",
//     protocol: "morpho",
//     deployments: [{ chainId: 8453, supplyToken: [{ symbol: "USDC", ... }], ... }]
//   },
//   ...
// ]

import { getDepositTx, VaultId } from '@gauntlet-xyz/sdk/evm'
// also available from the root: import { getDepositTx, VaultId } from '@gauntlet-xyz/sdk'

const steps = await getDepositTx(client, {
  vaultId: VaultId.AeraUsdAlpha,
  amount: 1_000_000n,
  receiver: '0xReceiver', // optional, defaults to wallet account
})

import { getWithdrawTx, VaultId } from '@gauntlet-xyz/sdk/evm'
// also available from the root: import { getWithdrawTx, VaultId } from '@gauntlet-xyz/sdk'

// Withdraw all shares
const steps = await getWithdrawTx(client, {
  vaultId: VaultId.AeraUsdAlpha,
  entireAmount: true,
  receiver: '0xReceiver', // optional
})

// Withdraw by shares
const steps = await getWithdrawTx(client, {
  vaultId: VaultId.AeraUsdAlpha,
  shares: 500_000000000000000000n,
})

// Withdraw by asset amount
const steps = await getWithdrawTx(client, {
  vaultId: VaultId.AeraUsdAlpha,
  amount: 1_000_000n,
})

import { getUserCurrentBalance, VaultId } from '@gauntlet-xyz/sdk'
// VaultId also available from: import { VaultId } from '@gauntlet-xyz/sdk/evm'

const balance = await getUserCurrentBalance(client, {
  vaultId: VaultId.AeraUsdAlpha,
  address: '0xUser',
})

type UserCurrentBalance = {
  chain: string           // chain identifier, e.g. "base" — included for non-EVM compatibility
  token: Address          // token address
  decimals: number        // token decimals
  pendingDeposit: bigint  // assets locked in provisioner after async deposit — not yet earning yield; 0n if none
  balance: bigint         // assets actively earning in the vault; 0n if no position
  pendingWithdraw: bigint // assets redeemed but not yet claimable after async withdraw — no longer earning; 0n if none
}

type PreparedTx = {
  payload: {
    type: string    // 'approve' | 'deposit' | 'requestDeposit' | 'redeem' | 'requestRedeem' | 'withdraw'
    to: Address     // contract to call
    data: Hex       // ABI-encoded calldata with attribution suffix already concatenated
    account?: Address
  }
  tx: EvmTxStep    // structured ABI fields + raw attribution bytes — use with writeContract
}

type EvmTxStep = {
  type: 'approve' | 'deposit' | 'requestDeposit' | 'redeem' | 'requestRedeem' | 'withdraw'
  address: Address        // contract to call
  abi: Abi                // ABI fragment for this call
  functionName: string
  args: readonly unknown[]
  account: Address        // sender address
  attribution?: Hex       // raw attribution bytes — must pass as dataSuffix to writeContract
}

for (const step of steps) {
  await walletClient.sendTransaction(step.payload)
}

for (const step of steps) {
  await walletClient.writeContract({
    address: step.tx.address,
    abi: step.tx.abi,
    functionName: step.tx.functionName,
    args: step.tx.args,
    account: step.tx.account,
    dataSuffix: step.tx.attribution, // required — omitting silently drops attribution
  })
}

type VaultInfo = {
  vaultId: string
  name: string
  protocol: 'aera' | 'morpho'
  strategy: string
  deployments: VaultDeployment[]
}

type VaultDeployment = {
  chain: 'evm'
  chainId: number
  vaultAddress: Address           // ERC4626 vault contract
  provisionerAddress?: Address    // multi-depositor vaults: deposit routes through this instead
  vaultType: 'single-depositor' | 'multi-depositor'
  depositMode: 'sync' | 'async' | 'both'  // validates the depositMode param in getDepositTx / getWithdrawTx
  supplyToken: TokenInfo[]        // tokens accepted by this vault; provides address and decimals
}

type TokenInfo = {
  symbol: string
  address: Address
  decimals: number
}

type VaultFilter = {
  chainId?: number
  protocol?: string
}

enum AttributionMode {
  PUBLIC  = 'public',
  ENCODED = 'encoded',  // not yet implemented
  PRIVATE = 'private',  // not yet implemented
}