> ## 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.
# Account Queries & Monitoring
> Discover accounts, read APY/TVL, check balances and fees, and monitor withdrawal status — using REST API calls and on-chain reads
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](mailto:support@paxoslabs.com) to get one. See the [API
Reference](/v1.0.0/api-reference/introduction) 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`](/v1.0.0/api-reference/introduction) instead.
### List All Accounts
```bash theme={null}
curl -s "https://api.paxoslabs.com/v2/amplify/vaultAssets?pageSize=100" \
-H "x-api-key: $AMPLIFY_API_KEY" | jq
```
```ts theme={null}
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()
}
```
```python theme={null}
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()
```
```go theme={null}
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
}
```
```swift theme={null}
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]
}
```
```kotlin theme={null}
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()
}
```
```dart theme={null}
import 'dart:convert';
import 'package:http/http.dart' as http;
Future> 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:**
```json theme={null}
{
"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`:
```bash theme={null}
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.amplify.vaults.getApys()` — see [SDK AI Reference](/v1.0.0/intro/products/earn/developers/sdk-ai-reference). Uses [`GET /v2/amplify/vaultApys`](/v1.0.0/api-reference/introduction).
```bash theme={null}
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]'
```
```ts theme={null}
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,
}
}
```
```python theme={null}
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"],
}
```
```go theme={null}
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
}
```
```swift theme={null}
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]
}
```
```kotlin theme={null}
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()
}
```
```dart theme={null}
Future> 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.amplify.vaults.getTvls()` — see [SDK AI Reference](/v1.0.0/intro/products/earn/developers/sdk-ai-reference). Uses [`GET /v2/amplify/vaultTvls`](/v1.0.0/api-reference/introduction).
```bash theme={null}
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]'
```
```ts theme={null}
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]
}
```
```python theme={null}
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]
```
```go theme={null}
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
}
```
```swift theme={null}
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]
}
```
```kotlin theme={null}
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()
}
```
```dart theme={null}
Future> 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.amplify.withdraw.listRequests()` — see [SDK AI Reference](/v1.0.0/intro/products/earn/developers/sdk-ai-reference). Uses [`GET /v2/amplify/withdrawalRequests`](/v1.0.0/api-reference/introduction).
```bash theme={null}
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
```
```ts theme={null}
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()
}
```
```python theme={null}
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()
```
```go theme={null}
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
}
```
```swift theme={null}
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]
}
```
```kotlin theme={null}
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()
}
```
```dart theme={null}
Future> 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.
```ts theme={null}
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 }
}
```
```python theme={null}
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}
```
```go theme={null}
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
}
```
```swift theme={null}
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)
}
```
```kotlin theme={null}
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() {}))
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() {}))
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)
}
```
```dart theme={null}
Future> 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
The SDK's `client.core.authorization.detect(...)` returns `'permit' | 'approval' | 'already_approved'`. The `ERC20.allowance(owner, spender)` check shown below only differentiates between `'already_approved'` (allowance ≥ amount) and `'approval'` (allowance \< amount). The `'permit'` branch is returned by the SDK only after additional on-chain permit metadata reads succeed (nonces, DOMAIN\_SEPARATOR, name, version). Direct-contract callers who only need the approval path can use allowance alone; implementing full permit detection requires the additional reads.
```ts theme={null}
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)
```
```python theme={null}
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)
```
```go theme={null}
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
}
```
```swift theme={null}
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
}
```
```kotlin theme={null}
fun checkAllowance(tokenAddress: String, owner: String, spender: String): BigInteger {
val fn = Function("allowance", listOf(Address(owner), Address(spender)), listOf(object : TypeReference() {}))
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
}
```
```dart theme={null}
Future 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.
```ts theme={null}
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] })
}
```
```python theme={null}
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()
```
```go theme={null}
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
}
```
```swift theme={null}
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
}
```
```kotlin theme={null}
fun getExchangeRate(accountantAddress: String, quoteAsset: String): BigInteger {
val fn = Function("getRateInQuoteSafe", listOf(Address(quoteAsset)), listOf(object : TypeReference() {}))
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
}
```
```dart theme={null}
Future 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.amplify.withdraw.calculateFee()` — see [SDK AI Reference](/v1.0.0/intro/products/earn/developers/sdk-ai-reference). Reads from the WithdrawQueue's FeeModule on-chain.
```ts theme={null}
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 }
}
```
```python theme={null}
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}
```
```go theme={null}
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
}
```
```swift theme={null}
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)
}
```
```kotlin theme={null}
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() {}))
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() {}))
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() {}))
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)
}
```
```dart theme={null}
Future> 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.
```ts theme={null}
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' })
}
```
```python theme={null}
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()
```
```go theme={null}
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
}
```
```swift theme={null}
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
}
```
```kotlin theme={null}
fun checkPauseState(tellerAddress: String): Boolean {
val fn = Function("isPaused", emptyList(), listOf(object : TypeReference() {}))
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
}
```
```dart theme={null}
Future 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.amplify.vaults.list({ filter? })` | Amplify GraphQL API — see [vault-discovery](./vault-queries/vault-discovery) |
| `client.amplify.vaults.listAssets({ filter? })` | [`GET /v2/amplify/vaultAssets`](/v1.0.0/api-reference/introduction) — filter by `depositable: true` or `withdrawable: true` |
| `client.amplify.vaults.getApys({ filter? })` | [`GET /v2/amplify/vaultApys`](/v1.0.0/api-reference/introduction) |
| `client.amplify.vaults.getTvls({ filter? })` | [`GET /v2/amplify/vaultTvls`](/v1.0.0/api-reference/introduction) |
| `client.amplify.vaults.getSupplyCaps({ filter? })` | On-chain: `DistributorCodeDepositor.supplyCapInBase()` per asset |
| `client.amplify.withdraw.listRequests({ filter? })` | [`GET /v2/amplify/withdrawalRequests`](/v1.0.0/api-reference/introduction) |
| `client.amplify.withdraw.calculateFee({...})` | On-chain: `WithdrawQueue.feeModule()` → `FeeModule.calculateOfferFees()` |
| `client.amplify.users.getPositions({...})` | On-chain: `BoringVault.balanceOf(user)` + `Accountant.getRateInQuoteSafe(quote)` |
| `client.core.authorization.detect({...})` | On-chain: `ERC20.allowance(owner, spender)` — branch on the result |
| `client.amplify.deposit.prepare({...})` | Encode `DistributorCodeDepositor.deposit()` or `depositWithPermit()` directly |
| `client.amplify.withdraw.prepare({...})` | Encode `WithdrawQueue.submitOrder()` directly |
| `client.amplify.withdraw.cancel({...})` | Encode `WithdrawQueue.cancelOrder()` directly |
***
## Next Steps
* [Direct Deposits](/v1.0.0/intro/products/earn/developers/guides/direct-contract/deposits) — Deposit tokens into an account
* [Direct Withdrawals](/v1.0.0/intro/products/earn/developers/guides/direct-contract/withdrawals) — Submit a withdrawal order
* [Direct Cancellations](/v1.0.0/intro/products/earn/developers/guides/direct-contract/cancellations) — Cancel a pending order
* [Overview](/v1.0.0/intro/products/earn/developers/guides/direct-contract/index) — Contract architecture and setup