Verified accounts

// Reads verified withdrawal accounts and picks the right one for a
// withdrawal — the pattern from /v3/setup/verified-accounts#read-accounts-via-the-api.
// signRequest is the real helper from /v3/authentication — adjust this path
// if you've copied it somewhere else in your own project.
const { signRequest } = require("../../authentication/node/sign-request");
// Picks the withdrawal account for a currency + rail. For a CRYPTO
// account, `rail` is the chain name (e.g. "SOLANA"). Kept separate from
// the network call so it's testable without a real request.
function findAccount(accounts, currency, rail) {
  return accounts.find((a) => a.currency === currency && a.rail === rail);
}
async function listAccounts() {
  const url = "https://api.openfx.com/v3/fx/withdrawal-accounts";
  const { headers } = signRequest({ method: "GET", url });
  const res = await fetch(url, { headers });
  const { data } = await res.json();
  return data;
}
module.exports = { findAccount, listAccounts };
if (require.main === module) {
  listAccounts()
    .then((accounts) => {
      const usdcOnSolana = findAccount(accounts, "USDC", "SOLANA");
      console.log(usdcOnSolana);
    })
    .catch((err) => {
      console.error("Error:", err.message);
      process.exitCode = 1;
    });
}

"""Reads verified withdrawal accounts and picks the right one for a
withdrawal — the pattern from
/v3/setup/verified-accounts#read-accounts-via-the-api."""
import os
import sys
# sign_request is the real helper from /v3/authentication — adjust this path
# if you've copied it somewhere else in your own project.
sys.path.insert(
    0, os.path.join(os.path.dirname(__file__), "..", "..", "authentication", "python")
)
from sign_request import sign_request  # noqa: E402
import requests  # noqa: E402
def find_account(accounts, currency, rail):
    """Picks the withdrawal account for a currency + rail. For a CRYPTO
    account, `rail` is the chain name (e.g. "SOLANA"). Kept separate from
    the network call so it's testable without a real request."""
    return next((a for a in accounts if a["currency"] == currency and a["rail"] == rail), None)
def list_accounts():
    url = "https://api.openfx.com/v3/fx/withdrawal-accounts"
    headers, _ = sign_request("GET", url)
    res = requests.get(url, headers=headers)
    return res.json()["data"]
if __name__ == "__main__":
    accounts = list_accounts()
    print(find_account(accounts, "USDC", "SOLANA"))

// Reads verified withdrawal accounts and picks the right one for a
// withdrawal — the pattern from
// /v3/setup/verified-accounts#read-accounts-via-the-api.
import java.net.HttpURLConnection;
import java.net.URI;
import java.util.List;
import java.util.Map;
public class FindAccount {
    static class Account {
        final String id;
        final String currency;
        final String rail;
        Account(String id, String currency, String rail) {
            this.id = id;
            this.currency = currency;
            this.rail = rail;
        }
    }
    // Picks the withdrawal account for a currency + rail. For a CRYPTO
    // account, rail is the chain name (e.g. "SOLANA"). Kept separate from
    // the network call so it's testable without a real request.
    static Account findAccount(List<Account> accounts, String currency, String rail) {
        for (Account a : accounts) {
            if (a.currency.equals(currency) && a.rail.equals(rail)) return a;
        }
        return null;
    }
    static List<Account> listAccounts() throws Exception {
        String url = "https://api.openfx.com/v3/fx/withdrawal-accounts";
        // SignRequest is the real helper from /v3/authentication, compiled
        // on the classpath alongside this file — see that page's example.
        Map<String, String> headers = SignRequest.signRequest("GET", url, new byte[0]);
        HttpURLConnection conn = (HttpURLConnection) URI.create(url).toURL().openConnection();
        conn.setRequestMethod("GET");
        for (Map.Entry<String, String> h : headers.entrySet()) {
            conn.setRequestProperty(h.getKey(), h.getValue());
        }
        conn.getResponseCode();
        // A real implementation would parse the JSON response body's `data`
        // array here.
        return List.of();
    }
    public static void main(String[] args) throws Exception {
        List<Account> accounts = listAccounts();
        System.out.println(findAccount(accounts, "USDC", "SOLANA"));
    }
}

// Reads verified withdrawal accounts and picks the right one for a
// withdrawal — the pattern from
// /v3/setup/verified-accounts#read-accounts-via-the-api. Requires
// OpenSSL and libcurl.
#include <curl/curl.h>
#include <optional>
#include <string>
#include <vector>
// Matches the definition in ../../authentication/cpp/sign_request.cpp,
// compiled together with this file — see that file for the real
// implementation of signRequest.
struct SignedRequest {
    std::string authHeader;
    std::string sigHeader;
};
SignedRequest signRequest(const std::string& method, const std::string& urlPath,
                           const std::string& query, const std::string& body);
struct Account {
    std::string id;
    std::string currency;
    std::string rail;
};
// Picks the withdrawal account for a currency + rail. For a CRYPTO
// account, rail is the chain name (e.g. "SOLANA"). Kept separate from the
// network call so it's testable without a real request.
std::optional<Account> findAccount(const std::vector<Account>& accounts, const std::string& currency,
                                    const std::string& rail) {
    for (const auto& a : accounts) {
        if (a.currency == currency && a.rail == rail) return a;
    }
    return std::nullopt;
}
static size_t discard(char*, size_t s, size_t n, void*) { return s * n; }
std::vector<Account> listAccounts() {
    std::string url = "https://api.openfx.com/v3/fx/withdrawal-accounts";
    SignedRequest req = signRequest("GET", "/v3/fx/withdrawal-accounts", "", "");
    CURL* curl = curl_easy_init();
    curl_slist* headers = nullptr;
    headers = curl_slist_append(headers, ("Authorization: " + req.authHeader).c_str());
    headers = curl_slist_append(headers, ("X-Request-Signature: " + req.sigHeader).c_str());
    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, discard);
    curl_easy_perform(curl);
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    // A real implementation would parse the JSON response body's `data`
    // array here.
    return {};
}
#ifndef FIND_ACCOUNT_NO_MAIN
#include <iostream>
int main() {
    try {
        auto accounts = listAccounts();
        auto account = findAccount(accounts, "USDC", "SOLANA");
        std::cout << (account ? account->id : "not found") << std::endl;
        return 0;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
}
#endif

// Reads verified withdrawal accounts and picks the right one for a
// withdrawal — the pattern from
// /v3/setup/verified-accounts#read-accounts-via-the-api.
package main
import (
	"encoding/json"
	"fmt"
	"net/http"
	// auth is the real signRequest helper from /v3/authentication — see
	// go.mod's replace directive if you've copied it somewhere else.
	auth "openfx-v3-authentication-example"
)
type Account struct {
	ID       string `json:"id"`
	Currency string `json:"currency"`
	Rail     string `json:"rail"`
}
// Picks the withdrawal account for a currency + rail. For a CRYPTO
// account, Rail is the chain name (e.g. "SOLANA"). Kept separate from the
// network call so it's testable without a real request.
func findAccount(accounts []Account, currency, rail string) *Account {
	for _, a := range accounts {
		if a.Currency == currency && a.Rail == rail {
			return &a
		}
	}
	return nil
}
func listAccounts() ([]Account, error) {
	url := "https://api.openfx.com/v3/fx/withdrawal-accounts"
	signed, err := auth.SignRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	for k, v := range signed.Headers {
		req.Header.Set(k, v)
	}
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	var envelope struct {
		Data []Account `json:"data"`
	}
	if err := json.NewDecoder(res.Body).Decode(&envelope); err != nil {
		return nil, err
	}
	return envelope.Data, nil
}
func main() {
	accounts, err := listAccounts()
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println(findAccount(accounts, "USDC", "SOLANA"))
}

#!/usr/bin/env bash
# Reads verified withdrawal accounts and picks the right one for a
# withdrawal — the pattern from
# /v3/setup/verified-accounts#read-accounts-via-the-api. Illustrative
# only: cURL can't compute the ES256 request signature itself, so
# $OPENFX_JWT/$OPENFX_SIGNATURE below are placeholders — get real values
# from signRequest, in any supported language, via /v3/authentication.
set -euo pipefail
export OPENFX_JWT="<jwt-from-signRequest>"
export OPENFX_SIGNATURE="<signature-from-signRequest>"
ACCOUNTS=$(curl -s https://api.openfx.com/v3/fx/withdrawal-accounts \
  -H "Authorization: Bearer $OPENFX_JWT" \
  -H "X-Request-Signature: $OPENFX_SIGNATURE")
# Picks the withdrawal account for a currency + rail. For a CRYPTO account,
# the rail is the chain name (e.g. "SOLANA"). Filtering an array by two
# fields needs real JSON parsing, unlike the single-field extraction
# elsewhere in these examples — this is the one place these scripts use
# jq (https://jqlang.org), not a hand-rolled pattern match.
echo "$ACCOUNTS" | jq '.data[] | select(.currency == "USDC" and .rail == "SOLANA")'