Account Queries & Monitoring

The Amplify SDK wraps several REST API endpoints and on-chain reads behind convenient functions like getVaultAPY() and getWithdrawalRequests(). When integrating directly, you call these yourself. This page covers every read-only operation the SDK provides, with the raw API calls and contract reads you need.

All REST API endpoints require an API key passed via the x-api-key header. Contact Paxos Labs to get one. See the API Reference for full endpoint documentation including pagination, filtering, and response schemas.

Account Discovery

The SDK’s getVaultsByConfig() and getSupportedAssets() are powered by a GraphQL API. For direct integrations, use the REST endpoint GET /v2/amplify/vaultAssets instead.

List All Accounts

curl -s "https://api.paxoslabs.com/v2/amplify/vaultAssets?pageSize=100" \
  -H "x-api-key: $AMPLIFY_API_KEY" | jq

const API_KEY = process.env.AMPLIFY_API_KEY!

async function getVaultAssets() {
  const res = await fetch(
    'https://api.paxoslabs.com/v2/amplify/vaultAssets?pageSize=100',
    { headers: { 'x-api-key': API_KEY } },
  )
  return res.json()
}

import requests, os

API_KEY = os.environ["AMPLIFY_API_KEY"]
HEADERS = {"x-api-key": API_KEY}

def get_vault_assets():
    resp = requests.get(
        "https://api.paxoslabs.com/v2/amplify/vaultAssets",
        headers=HEADERS,
        params={"pageSize": 100},
    )
    return resp.json()

func getVaultAssets() (map[string]interface{}, error) {
    req, _ := http.NewRequest("GET", "https://api.paxoslabs.com/v2/amplify/vaultAssets?pageSize=100", nil)
    req.Header.Set("x-api-key", os.Getenv("AMPLIFY_API_KEY"))
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return nil, err }
    defer resp.Body.Close()
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

func getVaultAssets() async throws -> [String: Any] {
    var request = URLRequest(url: URL(string: "https://api.paxoslabs.com/v2/amplify/vaultAssets?pageSize=100")!)
    request.setValue(ProcessInfo.processInfo.environment["AMPLIFY_API_KEY"], forHTTPHeaderField: "x-api-key")
    let (data, _) = try await URLSession.shared.data(for: request)
    return try JSONSerialization.jsonObject(with: data) as! [String: Any]
}

import java.net.HttpURLConnection
import java.net.URL

fun getVaultAssets(): String {
    val url = URL("https://api.paxoslabs.com/v2/amplify/vaultAssets?pageSize=100")
    val conn = url.openConnection() as HttpURLConnection
    conn.setRequestProperty("x-api-key", System.getenv("AMPLIFY_API_KEY"))
    return conn.inputStream.bufferedReader().readText()
}

import 'dart:convert';
import 'package:http/http.dart' as http;

Future<Map<String, dynamic>> getVaultAssets() async {
  final resp = await http.get(
    Uri.parse('https://api.paxoslabs.com/v2/amplify/vaultAssets?pageSize=100'),
    headers: {'x-api-key': const String.fromEnvironment('AMPLIFY_API_KEY')},
  );
  return jsonDecode(resp.body);
}

Response shape:

{
  "vaultAssets": [
    {
      "vaultAddress": "0x...",
      "chainId": 1,
      "assetAddress": "0x...",
      "depositable": true,
      "withdrawable": true
    }
  ],
  "nextPageToken": null,
  "tokenMetadata": {
    "1:0xA0b8...": {
      "address": "0xA0b8...",
      "chain_id": "1",
      "symbol": "USDC",
      "name": "USD Coin",
      "decimals": "6"
    }
  }
}

The tokenMetadata map is keyed by chainId:address and provides symbol, name, and decimals for each token — so you don’t need separate on-chain calls to resolve token info.

Withdraw-Eligible Assets

To find which assets support withdrawals for a specific account, filter the vaultAssets endpoint by withdrawable=true:

curl -s "https://api.paxoslabs.com/v2/amplify/vaultAssets?filter=withdrawable%3Dtrue%20AND%20vaultAddress%3D0x...&pageSize=100" \
  -H "x-api-key: $AMPLIFY_API_KEY" | jq

Account APY

Equivalent to SDK’s client.vaults.getApys() — see SDK AI Reference. Uses GET /v2/amplify/vaultApys.

VAULT_ADDRESS="0x..."
curl -s "https://api.paxoslabs.com/v2/amplify/vaultApys?filter=vaultAddress%3D${VAULT_ADDRESS}&orderByTimestamp=desc&pageSize=1" \
  -H "x-api-key: $AMPLIFY_API_KEY" | jq '.vaultApys[0]'

async function getVaultAPY(vaultAddress: string) {
  const params = new URLSearchParams({
    filter: `vaultAddress=${vaultAddress}`,
    orderByTimestamp: 'desc',
    pageSize: '1',
  })
  const res = await fetch(
    `https://api.paxoslabs.com/v2/amplify/vaultApys?${params}`,
    { headers: { 'x-api-key': API_KEY } },
  )
  const data = await res.json()
  const entry = data.vaultApys[0]
  return {
    apy: parseFloat(entry.apy),
    apyFormatted: `${(parseFloat(entry.apy) * 100).toFixed(2)}%`,
    vaultAddress: entry.vaultAddress,
    timestamp: entry.timestamp,
  }
}

def get_vault_apy(vault_address: str):
    resp = requests.get(
        "https://api.paxoslabs.com/v2/amplify/vaultApys",
        headers=HEADERS,
        params={
            "filter": f"vaultAddress={vault_address}",
            "orderByTimestamp": "desc",
            "pageSize": 1,
        },
    )
    entry = resp.json()["vaultApys"][0]
    apy = float(entry["apy"])
    return {
        "apy": apy,
        "apy_formatted": f"{apy * 100:.2f}%",
        "vault_address": entry["vaultAddress"],
        "timestamp": entry["timestamp"],
    }

func getVaultAPY(vaultAddress string) (map[string]interface{}, error) {
    url := fmt.Sprintf(
        "https://api.paxoslabs.com/v2/amplify/vaultApys?filter=vaultAddress%%3D%s&orderByTimestamp=desc&pageSize=1",
        vaultAddress,
    )
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("x-api-key", os.Getenv("AMPLIFY_API_KEY"))
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return nil, err }
    defer resp.Body.Close()
    var data map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&data)
    apys := data["vaultApys"].([]interface{})
    return apys[0].(map[string]interface{}), nil
}

func getVaultAPY(vaultAddress: String) async throws -> [String: Any] {
    let encoded = "vaultAddress=\(vaultAddress)".addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
    let url = URL(string: "https://api.paxoslabs.com/v2/amplify/vaultApys?filter=\(encoded)&orderByTimestamp=desc&pageSize=1")!
    var request = URLRequest(url: url)
    request.setValue(ProcessInfo.processInfo.environment["AMPLIFY_API_KEY"], forHTTPHeaderField: "x-api-key")
    let (data, _) = try await URLSession.shared.data(for: request)
    let json = try JSONSerialization.jsonObject(with: data) as! [String: Any]
    let apys = json["vaultApys"] as! [[String: Any]]
    return apys[0]
}

fun getVaultAPY(vaultAddress: String): String {
    val filter = java.net.URLEncoder.encode("vaultAddress=$vaultAddress", "UTF-8")
    val url = URL("https://api.paxoslabs.com/v2/amplify/vaultApys?filter=$filter&orderByTimestamp=desc&pageSize=1")
    val conn = url.openConnection() as HttpURLConnection
    conn.setRequestProperty("x-api-key", System.getenv("AMPLIFY_API_KEY"))
    return conn.inputStream.bufferedReader().readText()
}

Future<Map<String, dynamic>> getVaultAPY(String vaultAddress) async {
  final resp = await http.get(
    Uri.parse('https://api.paxoslabs.com/v2/amplify/vaultApys')
        .replace(queryParameters: {
      'filter': 'vaultAddress=$vaultAddress',
      'orderByTimestamp': 'desc',
      'pageSize': '1',
    }),
    headers: {'x-api-key': const String.fromEnvironment('AMPLIFY_API_KEY')},
  );
  final data = jsonDecode(resp.body);
  return (data['vaultApys'] as List).first;
}

The apy field is a decimal (e.g., 0.0523 = 5.23%). Multiply by 100 to display as a percentage.

Account TVL

Equivalent to SDK’s client.vaults.getTvls() — see SDK AI Reference. Uses GET /v2/amplify/vaultTvls.

VAULT_ADDRESS="0x..."
curl -s "https://api.paxoslabs.com/v2/amplify/vaultTvls?filter=vaultAddress%3D${VAULT_ADDRESS}&includeCurrent=true&orderByTimestamp=desc&pageSize=1" \
  -H "x-api-key: $AMPLIFY_API_KEY" | jq '.vaultTvls[0]'

async function getVaultTVL(vaultAddress: string, chainId?: number) {
  let filter = `vaultAddress=${vaultAddress}`
  if (chainId) filter += ` AND chainId=${chainId}`
  const params = new URLSearchParams({ filter, includeCurrent: 'true', orderByTimestamp: 'desc', pageSize: '1' })
  const res = await fetch(`https://api.paxoslabs.com/v2/amplify/vaultTvls?${params}`, { headers: { 'x-api-key': API_KEY } })
  const data = await res.json()
  return data.vaultTvls[0]
}

def get_vault_tvl(vault_address: str, chain_id: int = None):
    filt = f"vaultAddress={vault_address}"
    if chain_id:
        filt += f" AND chainId={chain_id}"
    resp = requests.get("https://api.paxoslabs.com/v2/amplify/vaultTvls", headers=HEADERS,
        params={"filter": filt, "includeCurrent": "true", "orderByTimestamp": "desc", "pageSize": 1})
    return resp.json()["vaultTvls"][0]

func getVaultTVL(vaultAddress string) (map[string]interface{}, error) {
    filter := fmt.Sprintf("vaultAddress%%3D%s", vaultAddress)
    url := fmt.Sprintf("https://api.paxoslabs.com/v2/amplify/vaultTvls?filter=%s&includeCurrent=true&orderByTimestamp=desc&pageSize=1", filter)
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("x-api-key", os.Getenv("AMPLIFY_API_KEY"))
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return nil, err }
    defer resp.Body.Close()
    var data map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&data)
    tvls := data["vaultTvls"].([]interface{})
    return tvls[0].(map[string]interface{}), nil
}

func getVaultTVL(vaultAddress: String) async throws -> [String: Any] {
    let encoded = "vaultAddress=\(vaultAddress)".addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
    let url = URL(string: "https://api.paxoslabs.com/v2/amplify/vaultTvls?filter=\(encoded)&includeCurrent=true&orderByTimestamp=desc&pageSize=1")!
    var request = URLRequest(url: url)
    request.setValue(ProcessInfo.processInfo.environment["AMPLIFY_API_KEY"], forHTTPHeaderField: "x-api-key")
    let (data, _) = try await URLSession.shared.data(for: request)
    let json = try JSONSerialization.jsonObject(with: data) as! [String: Any]
    return (json["vaultTvls"] as! [[String: Any]])[0]
}

fun getVaultTVL(vaultAddress: String): String {
    val filter = java.net.URLEncoder.encode("vaultAddress=$vaultAddress", "UTF-8")
    val url = URL("https://api.paxoslabs.com/v2/amplify/vaultTvls?filter=$filter&includeCurrent=true&orderByTimestamp=desc&pageSize=1")
    val conn = url.openConnection() as HttpURLConnection
    conn.setRequestProperty("x-api-key", System.getenv("AMPLIFY_API_KEY"))
    return conn.inputStream.bufferedReader().readText()
}

Future<Map<String, dynamic>> getVaultTVL(String vaultAddress) async {
  final resp = await http.get(
    Uri.parse('https://api.paxoslabs.com/v2/amplify/vaultTvls').replace(queryParameters: {
      'filter': 'vaultAddress=$vaultAddress', 'includeCurrent': 'true', 'orderByTimestamp': 'desc', 'pageSize': '1',
    }),
    headers: {'x-api-key': const String.fromEnvironment('AMPLIFY_API_KEY')},
  );
  return (jsonDecode(resp.body)['vaultTvls'] as List).first;
}

Withdrawal Request History

Equivalent to SDK’s client.withdraw.listRequests() — see SDK AI Reference. Uses GET /v2/amplify/withdrawalRequests.

USER_ADDRESS="0x..."
curl -s "https://api.paxoslabs.com/v2/amplify/withdrawalRequests?filter=userAddress%3D${USER_ADDRESS}&pageSize=20" \
  -H "x-api-key: $AMPLIFY_API_KEY" | jq

async function getWithdrawalRequests(userAddress: string, opts?: { chainId?: number; status?: string; pageSize?: number }) {
  let filter = `userAddress=${userAddress}`
  if (opts?.chainId) filter += ` AND chainId=${opts.chainId}`
  if (opts?.status) filter += ` AND status=${opts.status}`
  const params = new URLSearchParams({ filter, pageSize: String(opts?.pageSize ?? 20) })
  const res = await fetch(`https://api.paxoslabs.com/v2/amplify/withdrawalRequests?${params}`, { headers: { 'x-api-key': API_KEY } })
  return res.json()
}

def get_withdrawal_requests(user_address: str, chain_id=None, status=None, page_size=20):
    filt = f"userAddress={user_address}"
    if chain_id: filt += f" AND chainId={chain_id}"
    if status: filt += f" AND status={status}"
    resp = requests.get("https://api.paxoslabs.com/v2/amplify/withdrawalRequests",
        headers=HEADERS, params={"filter": filt, "pageSize": page_size})
    return resp.json()

func getWithdrawalRequests(userAddress string) (map[string]interface{}, error) {
    filter := fmt.Sprintf("userAddress%%3D%s", userAddress)
    url := fmt.Sprintf("https://api.paxoslabs.com/v2/amplify/withdrawalRequests?filter=%s&pageSize=20", filter)
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("x-api-key", os.Getenv("AMPLIFY_API_KEY"))
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return nil, err }
    defer resp.Body.Close()
    var data map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&data)
    return data, nil
}

func getWithdrawalRequests(userAddress: String) async throws -> [String: Any] {
    let encoded = "userAddress=\(userAddress)".addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
    let url = URL(string: "https://api.paxoslabs.com/v2/amplify/withdrawalRequests?filter=\(encoded)&pageSize=20")!
    var request = URLRequest(url: url)
    request.setValue(ProcessInfo.processInfo.environment["AMPLIFY_API_KEY"], forHTTPHeaderField: "x-api-key")
    let (data, _) = try await URLSession.shared.data(for: request)
    return try JSONSerialization.jsonObject(with: data) as! [String: Any]
}

fun getWithdrawalRequests(userAddress: String): String {
    val filter = java.net.URLEncoder.encode("userAddress=$userAddress", "UTF-8")
    val url = URL("https://api.paxoslabs.com/v2/amplify/withdrawalRequests?filter=$filter&pageSize=20")
    val conn = url.openConnection() as HttpURLConnection
    conn.setRequestProperty("x-api-key", System.getenv("AMPLIFY_API_KEY"))
    return conn.inputStream.bufferedReader().readText()
}

Future<Map<String, dynamic>> getWithdrawalRequests(String userAddress) async {
  final resp = await http.get(
    Uri.parse('https://api.paxoslabs.com/v2/amplify/withdrawalRequests').replace(queryParameters: {
      'filter': 'userAddress=$userAddress', 'pageSize': '20',
    }),
    headers: {'x-api-key': const String.fromEnvironment('AMPLIFY_API_KEY')},
  );
  return jsonDecode(resp.body);
}

Status Values

Status	Description
`PENDING`	Order submitted, awaiting fulfillment by the account operator
`COMPLETE`	Fulfilled — want asset sent to receiver
`PENDING_REFUND`	Cancellation in progress — shares being returned
`REFUNDED`	Cancelled — shares returned to refund receiver

Token Balances

Read ERC-20 token balances directly from the blockchain.

const erc20Abi = [
  { inputs: [{ name: 'account', type: 'address' }], name: 'balanceOf', outputs: [{ name: '', type: 'uint256' }], stateMutability: 'view', type: 'function' },
  { inputs: [], name: 'decimals', outputs: [{ name: '', type: 'uint8' }], stateMutability: 'view', type: 'function' },
] as const

async function getTokenBalance(tokenAddress: Address, walletAddress: Address) {
  const [balance, decimals] = await Promise.all([
    publicClient.readContract({ address: tokenAddress, abi: erc20Abi, functionName: 'balanceOf', args: [walletAddress] }),
    publicClient.readContract({ address: tokenAddress, abi: erc20Abi, functionName: 'decimals' }),
  ])
  return { balance, decimals }
}

ERC20_ABI = json.loads('[{"inputs":[{"name":"account","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"stateMutability":"view","type":"function"}]')

def get_token_balance(token_address, wallet_address):
    token = w3.eth.contract(address=token_address, abi=ERC20_ABI)
    balance = token.functions.balanceOf(wallet_address).call()
    decimals = token.functions.decimals().call()
    return {"balance": balance, "decimals": decimals}

func getTokenBalance(client *ethclient.Client, tokenAddr, walletAddr common.Address) (*big.Int, uint8, error) {
    erc20Abi, _ := abi.JSON(strings.NewReader(`[{"inputs":[{"name":"account","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"stateMutability":"view","type":"function"}]`))
    contract := bind.NewBoundContract(tokenAddr, erc20Abi, client, client, client)
    var balResult []interface{}
    err := contract.Call(nil, &balResult, "balanceOf", walletAddr)
    if err != nil { return nil, 0, err }
    var decResult []interface{}
    contract.Call(nil, &decResult, "decimals")
    return balResult[0].(*big.Int), decResult[0].(uint8), nil
}

func getTokenBalance(tokenAddress: EthereumAddress, wallet: EthereumAddress) async throws -> (balance: BigUInt, decimals: BigUInt) {
    let abi = "[{\"inputs\":[{\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]"
    let contract = web3.contract(abi, at: tokenAddress, abiVersion: 2)!
    let balResult = try await contract.createReadOperation("balanceOf", parameters: [wallet] as [AnyObject])!.callContractMethod()
    let decResult = try await contract.createReadOperation("decimals")!.callContractMethod()
    return (balResult["0"] as! BigUInt, decResult["0"] as! BigUInt)
}

data class TokenBalance(val balance: BigInteger, val decimals: Int)

fun getTokenBalance(tokenAddress: String, walletAddress: String): TokenBalance {
    val balFn = Function("balanceOf", listOf(Address(walletAddress)), listOf(object : TypeReference<Uint256>() {}))
    val balResp = web3.ethCall(Transaction.createEthCallTransaction(walletAddress, tokenAddress, FunctionEncoder.encode(balFn)), DefaultBlockParameterName.LATEST).send()
    val balance = (FunctionReturnDecoder.decode(balResp.value, balFn.outputParameters)[0] as Uint256).value

    val decFn = Function("decimals", emptyList(), listOf(object : TypeReference<Uint8>() {}))
    val decResp = web3.ethCall(Transaction.createEthCallTransaction(walletAddress, tokenAddress, FunctionEncoder.encode(decFn)), DefaultBlockParameterName.LATEST).send()
    val decimals = (FunctionReturnDecoder.decode(decResp.value, decFn.outputParameters)[0] as Uint8).value.toInt()

    return TokenBalance(balance, decimals)
}

Future<Map<String, dynamic>> getTokenBalance(EthereumAddress token, EthereumAddress wallet) async {
  final contract = DeployedContract(
    ContractAbi.fromJson('[{"inputs":[{"name":"account","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"stateMutability":"view","type":"function"}]', 'ERC20'),
    token,
  );
  final balResult = await client.call(contract: contract, function: contract.function('balanceOf'), params: [wallet]);
  final decResult = await client.call(contract: contract, function: contract.function('decimals'), params: []);
  return {'balance': balResult[0] as BigInt, 'decimals': (decResult[0] as BigInt).toInt()};
}

Allowance Checking

Equivalent to the SDK’s client.permit.authorize(...) branch resolution — the v1.0.0 SDK returns 'permit' | 'approval' | 'already_approved' based on the same on-chain ERC20.allowance(owner, spender) check shown below. Direct-contract callers run the read themselves.

async function checkAllowance(tokenAddress: Address, owner: Address, spender: Address) {
  const allowanceAbi = [{ inputs: [{ name: 'owner', type: 'address' }, { name: 'spender', type: 'address' }], name: 'allowance', outputs: [{ name: '', type: 'uint256' }], stateMutability: 'view', type: 'function' }] as const
  const allowance = await publicClient.readContract({ address: tokenAddress, abi: allowanceAbi, functionName: 'allowance', args: [owner, spender] })
  return allowance
}

// For deposits: checkAllowance(USDC, walletAddress, COMMUNITY_CODE_DEPOSITOR)
// For withdrawals: checkAllowance(BORING_VAULT, walletAddress, WITHDRAW_QUEUE)

ALLOWANCE_ABI = json.loads('[{"inputs":[{"name":"owner","type":"address"},{"name":"spender","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]')

def check_allowance(token_address, owner, spender):
    token = w3.eth.contract(address=token_address, abi=ALLOWANCE_ABI)
    return token.functions.allowance(owner, spender).call()

# For deposits: check_allowance(USDC, wallet, COMMUNITY_CODE_DEPOSITOR)
# For withdrawals: check_allowance(BORING_VAULT, wallet, WITHDRAW_QUEUE)

func checkAllowance(client *ethclient.Client, tokenAddr, owner, spender common.Address) (*big.Int, error) {
    allowanceAbi, _ := abi.JSON(strings.NewReader(`[{"inputs":[{"name":"owner","type":"address"},{"name":"spender","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]`))
    contract := bind.NewBoundContract(tokenAddr, allowanceAbi, client, client, client)
    var result []interface{}
    err := contract.Call(nil, &result, "allowance", owner, spender)
    if err != nil { return nil, err }
    return result[0].(*big.Int), nil
}

func checkAllowance(tokenAddress: EthereumAddress, owner: EthereumAddress, spender: EthereumAddress) async throws -> BigUInt {
    let abi = "[{\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]"
    let contract = web3.contract(abi, at: tokenAddress, abiVersion: 2)!
    let result = try await contract.createReadOperation("allowance", parameters: [owner, spender] as [AnyObject])!.callContractMethod()
    return result["0"] as! BigUInt
}

fun checkAllowance(tokenAddress: String, owner: String, spender: String): BigInteger {
    val fn = Function("allowance", listOf(Address(owner), Address(spender)), listOf(object : TypeReference<Uint256>() {}))
    val resp = web3.ethCall(Transaction.createEthCallTransaction(owner, tokenAddress, FunctionEncoder.encode(fn)), DefaultBlockParameterName.LATEST).send()
    return (FunctionReturnDecoder.decode(resp.value, fn.outputParameters)[0] as Uint256).value
}

Future<BigInt> checkAllowance(EthereumAddress token, EthereumAddress owner, EthereumAddress spender) async {
  final contract = DeployedContract(
    ContractAbi.fromJson('[{"inputs":[{"name":"owner","type":"address"},{"name":"spender","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]', 'ERC20'),
    token,
  );
  final result = await client.call(contract: contract, function: contract.function('allowance'), params: [owner, spender]);
  return result[0] as BigInt;
}

Exchange Rate

The Accountant contract tracks the exchange rate between account shares and the underlying asset. You must pass the quote asset address (e.g., USDC) to get the rate denominated in that asset.

const accountantAbi = [{ inputs: [{ name: 'quote', type: 'address' }], name: 'getRateInQuoteSafe', outputs: [{ name: 'rateInQuote', type: 'uint256' }], stateMutability: 'view', type: 'function' }] as const

async function getExchangeRate(accountantAddress: Address, quoteAsset: Address) {
  return publicClient.readContract({ address: accountantAddress, abi: accountantAbi, functionName: 'getRateInQuoteSafe', args: [quoteAsset] })
}

ACCOUNTANT_ABI = json.loads('[{"inputs":[{"name":"quote","type":"address"}],"name":"getRateInQuoteSafe","outputs":[{"name":"rateInQuote","type":"uint256"}],"stateMutability":"view","type":"function"}]')

def get_exchange_rate(accountant_address, quote_asset):
    accountant = w3.eth.contract(address=accountant_address, abi=ACCOUNTANT_ABI)
    return accountant.functions.getRateInQuoteSafe(quote_asset).call()

func getExchangeRate(client *ethclient.Client, accountantAddr, quoteAsset common.Address) (*big.Int, error) {
    accountantAbi, _ := abi.JSON(strings.NewReader(`[{"inputs":[{"name":"quote","type":"address"}],"name":"getRateInQuoteSafe","outputs":[{"name":"rateInQuote","type":"uint256"}],"stateMutability":"view","type":"function"}]`))
    contract := bind.NewBoundContract(accountantAddr, accountantAbi, client, client, client)
    var result []interface{}
    err := contract.Call(nil, &result, "getRateInQuoteSafe", quoteAsset)
    if err != nil { return nil, err }
    return result[0].(*big.Int), nil
}

func getExchangeRate(accountantAddress: EthereumAddress, quoteAsset: EthereumAddress) async throws -> BigUInt {
    let abi = "[{\"inputs\":[{\"name\":\"quote\",\"type\":\"address\"}],\"name\":\"getRateInQuoteSafe\",\"outputs\":[{\"name\":\"rateInQuote\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]"
    let contract = web3.contract(abi, at: accountantAddress, abiVersion: 2)!
    let result = try await contract.createReadOperation("getRateInQuoteSafe", parameters: [quoteAsset] as [AnyObject])!.callContractMethod()
    return result["0"] as! BigUInt
}

fun getExchangeRate(accountantAddress: String, quoteAsset: String): BigInteger {
    val fn = Function("getRateInQuoteSafe", listOf(Address(quoteAsset)), listOf(object : TypeReference<Uint256>() {}))
    val resp = web3.ethCall(Transaction.createEthCallTransaction(credentials.address, accountantAddress, FunctionEncoder.encode(fn)), DefaultBlockParameterName.LATEST).send()
    return (FunctionReturnDecoder.decode(resp.value, fn.outputParameters)[0] as Uint256).value
}

Future<BigInt> getExchangeRate(EthereumAddress accountantAddress, EthereumAddress quoteAsset) async {
  final contract = DeployedContract(
    ContractAbi.fromJson('[{"inputs":[{"name":"quote","type":"address"}],"name":"getRateInQuoteSafe","outputs":[{"name":"rateInQuote","type":"uint256"}],"stateMutability":"view","type":"function"}]', 'Accountant'),
    accountantAddress,
  );
  final result = await client.call(contract: contract, function: contract.function('getRateInQuoteSafe'), params: [quoteAsset]);
  return result[0] as BigInt;
}

Withdrawal Fees

Equivalent to SDK’s client.withdraw.calculateFee() — see SDK AI Reference. Reads from the WithdrawQueue’s FeeModule on-chain.

const queueFeeAbi = [{ inputs: [], name: 'feeModule', outputs: [{ name: '', type: 'address' }], stateMutability: 'view', type: 'function' }] as const
const feeModuleAbi = [
  { inputs: [{ name: 'amount', type: 'uint256' }, { name: 'offerAsset', type: 'address' }, { name: 'wantAsset', type: 'address' }, { name: 'receiver', type: 'address' }], name: 'calculateOfferFees', outputs: [{ name: 'feeAmount', type: 'uint256' }], stateMutability: 'view', type: 'function' },
  { inputs: [], name: 'offerFeePercentage', outputs: [{ name: '', type: 'uint256' }], stateMutability: 'view', type: 'function' },
] as const

async function getWithdrawalFee(shareAmount: bigint, wantAsset: Address, receiver: Address) {
  const feeModuleAddr = await publicClient.readContract({ address: WITHDRAW_QUEUE, abi: queueFeeAbi, functionName: 'feeModule' })
  const [feeAmount, feePercentage] = await Promise.all([
    publicClient.readContract({ address: feeModuleAddr, abi: feeModuleAbi, functionName: 'calculateOfferFees', args: [shareAmount, BORING_VAULT, wantAsset, receiver] }),
    publicClient.readContract({ address: feeModuleAddr, abi: feeModuleAbi, functionName: 'offerFeePercentage' }),
  ])
  return { feeAmount, feePercentage }
}

QUEUE_FEE_ABI = json.loads('[{"inputs":[],"name":"feeModule","outputs":[{"name":"","type":"address"}],"stateMutability":"view","type":"function"}]')
FEE_MODULE_ABI = json.loads('[{"inputs":[{"name":"amount","type":"uint256"},{"name":"offerAsset","type":"address"},{"name":"wantAsset","type":"address"},{"name":"receiver","type":"address"}],"name":"calculateOfferFees","outputs":[{"name":"feeAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"offerFeePercentage","outputs":[{"name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]')

def get_withdrawal_fee(share_amount, want_asset, receiver):
    queue = w3.eth.contract(address=WITHDRAW_QUEUE, abi=QUEUE_FEE_ABI)
    fee_module_addr = queue.functions.feeModule().call()
    fee_module = w3.eth.contract(address=fee_module_addr, abi=FEE_MODULE_ABI)
    fee_amount = fee_module.functions.calculateOfferFees(share_amount, BORING_VAULT, want_asset, receiver).call()
    fee_pct = fee_module.functions.offerFeePercentage().call()
    return {"fee_amount": fee_amount, "fee_percentage": fee_pct}

func getWithdrawalFee(client *ethclient.Client, queueAddr, vaultAddr, wantAsset, receiver common.Address, shareAmount *big.Int) (*big.Int, *big.Int, error) {
    queueAbi, _ := abi.JSON(strings.NewReader(`[{"inputs":[],"name":"feeModule","outputs":[{"name":"","type":"address"}],"stateMutability":"view","type":"function"}]`))
    queueContract := bind.NewBoundContract(queueAddr, queueAbi, client, client, client)
    var fmResult []interface{}
    queueContract.Call(nil, &fmResult, "feeModule")
    feeModuleAddr := fmResult[0].(common.Address)

    feeAbi, _ := abi.JSON(strings.NewReader(`[{"inputs":[{"name":"amount","type":"uint256"},{"name":"offerAsset","type":"address"},{"name":"wantAsset","type":"address"},{"name":"receiver","type":"address"}],"name":"calculateOfferFees","outputs":[{"name":"feeAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"offerFeePercentage","outputs":[{"name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]`))
    feeContract := bind.NewBoundContract(feeModuleAddr, feeAbi, client, client, client)
    var feeResult []interface{}
    feeContract.Call(nil, &feeResult, "calculateOfferFees", shareAmount, vaultAddr, wantAsset, receiver)
    var pctResult []interface{}
    feeContract.Call(nil, &pctResult, "offerFeePercentage")
    return feeResult[0].(*big.Int), pctResult[0].(*big.Int), nil
}

func getWithdrawalFee(queueAddress: EthereumAddress, shareAmount: BigUInt, vaultAddress: EthereumAddress, wantAsset: EthereumAddress, receiver: EthereumAddress) async throws -> (feeAmount: BigUInt, feePercentage: BigUInt) {
    let queueAbi = "[{\"inputs\":[],\"name\":\"feeModule\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]"
    let queueContract = web3.contract(queueAbi, at: queueAddress, abiVersion: 2)!
    let fmResult = try await queueContract.createReadOperation("feeModule")!.callContractMethod()
    let feeModuleAddr = fmResult["0"] as! EthereumAddress

    let feeAbi = "[{\"inputs\":[{\"name\":\"amount\",\"type\":\"uint256\"},{\"name\":\"offerAsset\",\"type\":\"address\"},{\"name\":\"wantAsset\",\"type\":\"address\"},{\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"calculateOfferFees\",\"outputs\":[{\"name\":\"feeAmount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"offerFeePercentage\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]"
    let feeContract = web3.contract(feeAbi, at: feeModuleAddr, abiVersion: 2)!
    let feeResult = try await feeContract.createReadOperation("calculateOfferFees", parameters: [shareAmount, vaultAddress, wantAsset, receiver] as [AnyObject])!.callContractMethod()
    let pctResult = try await feeContract.createReadOperation("offerFeePercentage")!.callContractMethod()
    return (feeResult["0"] as! BigUInt, pctResult["0"] as! BigUInt)
}

data class WithdrawalFeeResult(val feeAmount: BigInteger, val feePercentage: BigInteger)

fun getWithdrawalFee(queueAddress: String, shareAmount: BigInteger, vaultAddress: String, wantAsset: String, receiver: String): WithdrawalFeeResult {
    val fmFn = Function("feeModule", emptyList(), listOf(object : TypeReference<Address>() {}))
    val fmResp = web3.ethCall(Transaction.createEthCallTransaction(receiver, queueAddress, FunctionEncoder.encode(fmFn)), DefaultBlockParameterName.LATEST).send()
    val feeModuleAddr = (FunctionReturnDecoder.decode(fmResp.value, fmFn.outputParameters)[0] as Address).value

    val feeFn = Function("calculateOfferFees",
        listOf(Uint256(shareAmount), Address(vaultAddress), Address(wantAsset), Address(receiver)),
        listOf(object : TypeReference<Uint256>() {}))
    val feeResp = web3.ethCall(Transaction.createEthCallTransaction(receiver, feeModuleAddr, FunctionEncoder.encode(feeFn)), DefaultBlockParameterName.LATEST).send()
    val feeAmount = (FunctionReturnDecoder.decode(feeResp.value, feeFn.outputParameters)[0] as Uint256).value

    val pctFn = Function("offerFeePercentage", emptyList(), listOf(object : TypeReference<Uint256>() {}))
    val pctResp = web3.ethCall(Transaction.createEthCallTransaction(receiver, feeModuleAddr, FunctionEncoder.encode(pctFn)), DefaultBlockParameterName.LATEST).send()
    val feePercentage = (FunctionReturnDecoder.decode(pctResp.value, pctFn.outputParameters)[0] as Uint256).value

    return WithdrawalFeeResult(feeAmount, feePercentage)
}

Future<Map<String, BigInt>> getWithdrawalFee(EthereumAddress queueAddr, BigInt shareAmount, EthereumAddress vaultAddr, EthereumAddress wantAsset, EthereumAddress receiver) async {
  final queueContract = DeployedContract(ContractAbi.fromJson('[{"inputs":[],"name":"feeModule","outputs":[{"name":"","type":"address"}],"stateMutability":"view","type":"function"}]', 'Queue'), queueAddr);
  final fmResult = await client.call(contract: queueContract, function: queueContract.function('feeModule'), params: []);
  final feeModuleAddr = fmResult[0] as EthereumAddress;

  final feeContract = DeployedContract(ContractAbi.fromJson('[{"inputs":[{"name":"amount","type":"uint256"},{"name":"offerAsset","type":"address"},{"name":"wantAsset","type":"address"},{"name":"receiver","type":"address"}],"name":"calculateOfferFees","outputs":[{"name":"feeAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"offerFeePercentage","outputs":[{"name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]', 'FeeModule'), feeModuleAddr);
  final feeResult = await client.call(contract: feeContract, function: feeContract.function('calculateOfferFees'), params: [shareAmount, vaultAddr, wantAsset, receiver]);
  final pctResult = await client.call(contract: feeContract, function: feeContract.function('offerFeePercentage'), params: []);
  return {'feeAmount': feeResult[0] as BigInt, 'feePercentage': pctResult[0] as BigInt};
}

Pause State

Before submitting transactions, check whether the account is paused.

const tellerAbi = [{ inputs: [], name: 'isPaused', outputs: [{ name: '', type: 'bool' }], stateMutability: 'view', type: 'function' }] as const

async function checkPauseState(tellerAddress: Address) {
  return publicClient.readContract({ address: tellerAddress, abi: tellerAbi, functionName: 'isPaused' })
}

TELLER_ABI = json.loads('[{"inputs":[],"name":"isPaused","outputs":[{"name":"","type":"bool"}],"stateMutability":"view","type":"function"}]')

def check_pause_state(teller_address):
    teller = w3.eth.contract(address=teller_address, abi=TELLER_ABI)
    return teller.functions.isPaused().call()

func checkPauseState(client *ethclient.Client, tellerAddr common.Address) (bool, error) {
    tellerAbi, _ := abi.JSON(strings.NewReader(`[{"inputs":[],"name":"isPaused","outputs":[{"name":"","type":"bool"}],"stateMutability":"view","type":"function"}]`))
    contract := bind.NewBoundContract(tellerAddr, tellerAbi, client, client, client)
    var result []interface{}
    err := contract.Call(nil, &result, "isPaused")
    if err != nil { return false, err }
    return result[0].(bool), nil
}

func checkPauseState(tellerAddress: EthereumAddress) async throws -> Bool {
    let abi = "[{\"inputs\":[],\"name\":\"isPaused\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]"
    let contract = web3.contract(abi, at: tellerAddress, abiVersion: 2)!
    let result = try await contract.createReadOperation("isPaused")!.callContractMethod()
    return result["0"] as! Bool
}

fun checkPauseState(tellerAddress: String): Boolean {
    val fn = Function("isPaused", emptyList(), listOf(object : TypeReference<Bool>() {}))
    val resp = web3.ethCall(Transaction.createEthCallTransaction(credentials.address, tellerAddress, FunctionEncoder.encode(fn)), DefaultBlockParameterName.LATEST).send()
    return (FunctionReturnDecoder.decode(resp.value, fn.outputParameters)[0] as Bool).value
}

Future<bool> checkPauseState(EthereumAddress tellerAddress) async {
  final contract = DeployedContract(
    ContractAbi.fromJson('[{"inputs":[],"name":"isPaused","outputs":[{"name":"","type":"bool"}],"stateMutability":"view","type":"function"}]', 'Teller'),
    tellerAddress,
  );
  final result = await client.call(contract: contract, function: contract.function('isPaused'), params: []);
  return result[0] as bool;
}

If the Teller is paused, deposit and withdrawal transactions will revert. Check pause state before submitting transactions in production.

SDK-to-Direct Mapping Reference

v1.0.0 SDK call	Direct contract / API equivalent
`new AmplifyClient({ apiKey })`	No equivalent needed — configure your HTTP client and contract addresses directly
`client.vaults.list({ filter? })`	Amplify GraphQL API — see vault-discovery
`client.vaults.listAssets({ filter? })`	`GET /v2/amplify/vaultAssets` — filter by `depositable: true` or `withdrawable: true`
`client.vaults.getApys({ filter? })`	`GET /v2/amplify/vaultApys`
`client.vaults.getTvls({ filter? })`	`GET /v2/amplify/vaultTvls`
`client.vaults.getSupplyCaps({ filter? })`	On-chain: `DistributorCodeDepositor.supplyCapInBase()` per asset
`client.withdraw.listRequests({ filter? })`	`GET /v2/amplify/withdrawalRequests`
`client.withdraw.calculateFee({...})`	On-chain: `WithdrawQueue.feeModule()` → `FeeModule.calculateOfferFees()`
`client.users.getPositions({...})`	On-chain: `BoringVault.balanceOf(user)` + `Accountant.getRateInQuoteSafe(quote)`
`client.permit.authorize({...})`	On-chain: `ERC20.allowance(owner, spender)` — branch on the result
`client.deposit.prepareDeposit({...})`	Encode `DistributorCodeDepositor.deposit()` or `depositWithPermit()` directly
`client.withdraw.prepareWithdrawal({...})`	Encode `WithdrawQueue.submitOrder()` directly
`client.withdraw.cancel({...})`	Encode `WithdrawQueue.cancelOrder()` directly

Next Steps

Direct Deposits — Deposit tokens into an account
Direct Withdrawals — Submit a withdrawal order
Direct Cancellations — Cancel a pending order
Overview — Contract architecture and setup

Documentation Index

​Account Discovery

​List All Accounts

​Withdraw-Eligible Assets

​Account APY

​Account TVL

​Withdrawal Request History

​Status Values

​Token Balances

​Allowance Checking

​Exchange Rate

​Withdrawal Fees

​Pause State

​SDK-to-Direct Mapping Reference

​Next Steps

Account Discovery

List All Accounts

Withdraw-Eligible Assets

Account APY

Account TVL

Withdrawal Request History

Status Values

Token Balances

Allowance Checking

Exchange Rate

Withdrawal Fees

Pause State

SDK-to-Direct Mapping Reference

Next Steps