> ## 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](/v0.5.2/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`](/v0.5.2/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 [`getVaultAPY()`](/v0.5.2/intro/products/earn/developers/api/display/getVaultAPY). Uses [`GET /v2/amplify/vaultApys`](/v0.5.2/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 [`getVaultTVL()`](/v0.5.2/intro/products/earn/developers/api/display/getVaultTVL). Uses [`GET /v2/amplify/vaultTvls`](/v0.5.2/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 [`getWithdrawalRequests()`](/v0.5.2/intro/products/earn/developers/api/display/getWithdrawalRequests). Uses [`GET /v2/amplify/withdrawalRequests`](/v0.5.2/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. Equivalent to the SDK's internal `getErc20Balance()`.
```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
Equivalent to SDK's `isDepositSpendApproved()` and `isWithdrawalSpendApproved()`.
```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. Equivalent to SDK's internal `getRateInQuoteWithAssetDecimals()`. 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 [`getWithdrawalFee()`](/v0.5.2/intro/products/earn/developers/api/display/getWithdrawalFee). 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. Equivalent to SDK's internal `getPausedStates()`.
```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
| SDK Function | Direct Contract Equivalent |
| --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `initAmplifySDK()` | No equivalent needed — configure RPC client and contract addresses directly |
| [`getVaultsByConfig()`](/v0.5.2/intro/products/earn/developers/api/getVaultsByConfig) | [`GET /v2/amplify/vaultAssets`](/v0.5.2/api-reference/introduction) |
| [`getSupportedAssets()`](/v0.5.2/intro/products/earn/developers/api/getSupportedAssets) | [`GET /v2/amplify/vaultAssets`](/v0.5.2/api-reference/introduction) — filter by `depositable: true` |
| `getWithdrawSupportedAssets()` | [`GET /v2/amplify/vaultAssets`](/v0.5.2/api-reference/introduction) — filter by `withdrawable=true` |
| [`getVaultAPY()`](/v0.5.2/intro/products/earn/developers/api/display/getVaultAPY) | [`GET /v2/amplify/vaultApys`](/v0.5.2/api-reference/introduction) |
| [`getVaultTVL()`](/v0.5.2/intro/products/earn/developers/api/display/getVaultTVL) | [`GET /v2/amplify/vaultTvls`](/v0.5.2/api-reference/introduction) |
| [`getWithdrawalRequests()`](/v0.5.2/intro/products/earn/developers/api/display/getWithdrawalRequests) | [`GET /v2/amplify/withdrawalRequests`](/v0.5.2/api-reference/introduction) |
| [`getMinimumMint()`](/v0.5.2/intro/products/earn/developers/api/display/getMinimumMint) | On-chain: `Accountant.getRateInQuoteSafe(quoteAsset)` + math (see [Deposits](/v0.5.2/intro/products/earn/developers/guides/direct-contract/deposits#calculating-minimummint-slippage-protection)) |
| [`getMinimumWithdrawalOrderSize()`](/v0.5.2/intro/products/earn/developers/api/display/getMinimumWithdrawalOrderSize) | On-chain: `WithdrawQueue.minimumOrderSize()` (see [Withdrawals](/v0.5.2/intro/products/earn/developers/guides/direct-contract/withdrawals#minimum-order-size)) |
| [`getWithdrawalFee()`](/v0.5.2/intro/products/earn/developers/api/display/getWithdrawalFee) | On-chain: `WithdrawQueue.feeModule()` → `FeeModule.calculateOfferFees()` |
| `isDepositSpendApproved()` | On-chain: `ERC20.allowance(owner, depositor)` |
| `isWithdrawalSpendApproved()` | On-chain: `BoringVault.allowance(owner, queue)` |
| `prepareDeposit()` | Encode `DistributorCodeDepositor.deposit()` or `depositWithPermit()` directly |
| `prepareWithdrawal()` | Encode `WithdrawQueue.submitOrder()` directly |
| `prepareCancelWithdrawOrderTxData()` | Encode `WithdrawQueue.cancelOrder()` directly |
***
## Next Steps
* [Direct Deposits](/v0.5.2/intro/products/earn/developers/guides/direct-contract/deposits) — Deposit tokens into an account
* [Direct Withdrawals](/v0.5.2/intro/products/earn/developers/guides/direct-contract/withdrawals) — Submit a withdrawal order
* [Direct Cancellations](/v0.5.2/intro/products/earn/developers/guides/direct-contract/cancellations) — Cancel a pending order
* [Overview](/v0.5.2/intro/products/earn/developers/guides/direct-contract/index) — Contract architecture and setup