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

> Find available Amplify accounts, contract addresses, fees, and supported assets via API

Before preparing transactions, discover which accounts are available and fetch their contract addresses. `GET /v2/amplify/vaults` is the single entry point — it returns accounts grouped by `name`, with per-chain `deployments[]` and nested per-asset configuration, fees, supply caps, minimum withdrawal sizes, and withdrawal SLAs.

## List Accounts

`GET /v2/amplify/vaults` returns accounts grouped by `name`. Each item has a `deployments[]` array with one entry per chain the account is deployed on.

### Parameters

| Parameter   | Type     | Required | Description                                                                                                   |
| ----------- | -------- | -------- | ------------------------------------------------------------------------------------------------------------- |
| `filter`    | `string` | No       | Filter string. Flags: `chainId`, `inDeprecation`, `requiresKyt`. Example: `chainId=1 AND inDeprecation=false` |
| `pageSize`  | `number` | No       | Max items per page (1–100, default 25)                                                                        |
| `pageToken` | `string` | No       | Pagination token. Omit for the first page.                                                                    |

### Example

<Tabs>
  <Tab title="curl">
    ```bash theme={null}
    curl "https://api.paxoslabs.com/v2/amplify/vaults?filter=chainId%3D1%20AND%20inDeprecation%3Dfalse" \
      -H "x-api-key: pxl_your_key"
    ```
  </Tab>

  <Tab title="Node.js">
    ```ts theme={null}
    const BASE = "https://api.paxoslabs.com";
    const HEADERS = { "x-api-key": process.env.AMPLIFY_API_KEY! };

    const url = new URL(`${BASE}/v2/amplify/vaults`);
    url.searchParams.set("filter", "chainId=1 AND inDeprecation=false");

    const resp = await fetch(url, { headers: HEADERS });
    const data = await resp.json();

    for (const vault of data.vaults) {
      console.log(`Account: ${vault.name}`);
      for (const d of vault.deployments) {
        console.log(`  Chain ${d.chainId}`);
        console.log(`    BoringVault:   ${d.boringVaultAddress}`);
        console.log(`    Depositor:     ${d.depositorAddress}`);
        console.log(`    WithdrawQueue: ${d.withdrawQueueAddress}`);
        for (const a of d.assets) {
          console.log(
            `    Asset ${a.assetAddress}: deposit=${a.depositable}, withdraw=${a.withdrawable}`
          );
        }
      }
    }
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    import requests

    resp = requests.get(
        "https://api.paxoslabs.com/v2/amplify/vaults",
        headers={"x-api-key": "pxl_your_key"},
        params={"filter": "chainId=1 AND inDeprecation=false"},
    )
    data = resp.json()

    for vault in data["vaults"]:
        print(f"Account: {vault['name']}")
        for d in vault["deployments"]:
            print(f"  Chain {d['chainId']}")
            print(f"    BoringVault:   {d['boringVaultAddress']}")
            print(f"    Depositor:     {d['depositorAddress']}")
            print(f"    WithdrawQueue: {d['withdrawQueueAddress']}")
            for a in d["assets"]:
                print(
                    f"    Asset {a['assetAddress']}: "
                    f"deposit={a['depositable']}, withdraw={a['withdrawable']}"
                )
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    package main

    import (
        "encoding/json"
        "fmt"
        "io"
        "net/http"
        "os"
    )

    func main() {
        req, _ := http.NewRequest("GET",
            "https://api.paxoslabs.com/v2/amplify/vaults?"+
            "filter=chainId%3D1%20AND%20inDeprecation%3Dfalse", nil)
        req.Header.Set("x-api-key", os.Getenv("AMPLIFY_API_KEY"))
        resp, _ := http.DefaultClient.Do(req)
        defer resp.Body.Close()
        body, _ := io.ReadAll(resp.Body)

        var data map[string]interface{}
        json.Unmarshal(body, &data)
        // iterate data["vaults"][i].deployments[j] to access contract
        // addresses, per-asset flags, fees, supply caps, and SLAs
        fmt.Println(data)
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    import java.net.URI;
    import java.net.http.HttpClient;
    import java.net.http.HttpRequest;
    import java.net.http.HttpResponse;
    import com.google.gson.JsonObject;
    import com.google.gson.JsonParser;

    public class ListVaults {
        public static void main(String[] args) throws Exception {
            HttpClient client = HttpClient.newHttpClient();
            HttpRequest req = HttpRequest.newBuilder()
                .uri(URI.create(
                    "https://api.paxoslabs.com/v2/amplify/vaults?" +
                    "filter=chainId%3D1%20AND%20inDeprecation%3Dfalse"))
                .header("x-api-key", System.getenv("AMPLIFY_API_KEY"))
                .GET().build();

            HttpResponse<String> resp = client.send(req,
                HttpResponse.BodyHandlers.ofString());
            JsonObject data = JsonParser.parseString(resp.body()).getAsJsonObject();
            // iterate data.vaults[i].deployments[j] to access contract
            // addresses, per-asset flags, fees, supply caps, and SLAs
        }
    }
    ```
  </Tab>
</Tabs>

### Response

```json theme={null}
{
  "vaults": [
    {
      "name": "Amplify USDC Core",
      "deployments": [
        {
          "chainId": 1,
          "boringVaultAddress": "0xbbbb000000000000000000000000000000000001",
          "depositorAddress": "0xcccc000000000000000000000000000000000001",
          "withdrawQueueAddress": "0xdddd000000000000000000000000000000000001",
          "requiresKyt": false,
          "baseTokenAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
          "accountantAddress": "0xaaaa000000000000000000000000000000000001",
          "tellerAddress": "0xeeee000000000000000000000000000000000001",
          "depositFeeAddress": null,
          "withdrawFeeAddress": null,
          "inDeprecation": false,
          "depositSupplyCap": {
            "raw": "1000000000000",
            "formatted": "1000000.0",
            "decimals": 6,
            "hasCap": true
          },
          "minimumWithdrawalOrderSize": {
            "raw": "1000000000000000000",
            "formatted": "1.0",
            "decimals": 18
          },
          "assets": [
            {
              "assetAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
              "depositable": true,
              "withdrawable": true,
              "depositFees": { "bps": 0, "percentage": "0.0000" },
              "withdrawFees": { "bps": 25, "percentage": "0.2500" },
              "withdrawalSLAs": {
                "expectedDelay": "86400s",
                "expiryBuffer": "36000s",
                "internalWithdrawalQueueDelaySLA": "43200s",
                "externalWithdrawalQueueDelaySLA": "86400s",
                "internalAccountantRateUpdateDelaySLA": "43200s",
                "externalAccountantRateUpdateSLA": "86400s"
              }
            }
          ]
        }
      ]
    }
  ],
  "nextPageToken": null
}
```

### Field Mapping for Transaction Preparation

| Field                                      | Used For                                                                        |
| ------------------------------------------ | ------------------------------------------------------------------------------- |
| `deployments[].boringVaultAddress`         | `vaultAddress` parameter in all calldata endpoints and `/v2/core/authorization` |
| `deployments[].depositorAddress`           | Target of the prepared deposit transaction (`transaction.to`)                   |
| `deployments[].withdrawQueueAddress`       | Spender address for the share approval before a withdrawal                      |
| `deployments[].requiresKyt`                | If `true`, the account requires a KYT attestation — resolved server-side        |
| `deployments[].baseTokenAddress`           | The primary deposit asset address                                               |
| `deployments[].depositSupplyCap`           | `{ raw, formatted, decimals, hasCap }`; `hasCap=false` means uncapped           |
| `deployments[].minimumWithdrawalOrderSize` | Minimum `shareAmount` accepted by `/v2/amplify/withdraw`                        |
| `deployments[].assets[].depositFees`       | `{ bps, percentage }` — deposit fee per asset                                   |
| `deployments[].assets[].withdrawFees`      | `{ bps, percentage }` — withdraw fee per asset                                  |
| `deployments[].assets[].withdrawalSLAs`    | Protobuf duration strings (e.g. `"86400s"`) for queue / rate-update SLAs        |

Use this single endpoint to build account selector UIs, fee previews, supply-cap progress bars, and withdrawal time estimates.