Build a headless 0Pools flow

PK="pk_test_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
SK="sk_test_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
BASE="https://pools-api.0bit.app/v1"

# 1. Discover (pk_)
curl -s "$BASE/pools" -H "Authorization: Bearer $PK"

# 2. Capabilities (sk_)
curl -s "$BASE/pools/EUR-USDT/capabilities" -H "Authorization: Bearer $SK"

# 3. Lock a firm quote — capture quoteId from the response
curl -s -X POST "$BASE/pools/EUR-USDT/quote" \
  -H "Authorization: Bearer $SK" -H "Content-Type: application/json" \
  -d '{"side":"on_ramp","fiatCurrency":"EUR","cryptoCurrency":"USDT","amount":"100.00","cryptoNetwork":"tron","type":"firm","destAddress":"0x52908400098527886E0F7030069857D2E4169EE7","destNetwork":"arbitrum"}'

# 4. Transact (Idempotency-Key required)
QUOTE_ID="pq_test_8f3c000000000123"
curl -s -X POST "$BASE/pools/EUR-USDT/transact" \
  -H "Authorization: Bearer $SK" -H "Content-Type: application/json" \
  -H "Idempotency-Key: 00000000-0000-4000-8000-000000000123" \
  -d "{\"quoteId\":\"$QUOTE_ID\"}"

# 5. Poll to settlement (this poll advances settlement)
curl -s "$BASE/pools/transactions/$QUOTE_ID" -H "Authorization: Bearer $SK"

# 6. Reconcile (pure reads)
curl -s "$BASE/pools/trades?limit=50" -H "Authorization: Bearer $SK"

const BASE = 'https://pools-api.0bit.app/v1';
const PK = process.env.POOLS_PK!; // publishable, discovery only
const SK = process.env.POOLS_SK!; // secret, server-only

const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

async function call(path: string, key: string, init: RequestInit = {}) {
  const res = await fetch(`${BASE}${path}`, {
    ...init,
    headers: { Authorization: `Bearer ${key}`, ...(init.headers ?? {}) },
  });
  const body = await res.json();
  if (!res.ok) {
    // Unified error envelope: branch on code/type, not on the message.
    throw Object.assign(new Error(body.message), {
      code: body.code,
      type: body.type,
      statusCode: body.statusCode,
      requestId: res.headers.get('X-Request-Id'),
    });
  }
  return body;
}

export async function buyWithPool(destAddress: string) {
  // 1. Discover entitled pools (pk_)
  const { pools } = await call('/pools', PK);
  const pool = pools.find((p: any) => p.available);
  if (!pool) return { state: 'no_pool' };

  // 2. Read capabilities (sk_) instead of hard-coding networks/limits
  const caps = await call(`/pools/${pool.id}/capabilities`, SK);

  // 3. Lock a firm quote (sk_)
  const quote = await call(`/pools/${pool.id}/quote`, SK, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      side: 'on_ramp',
      fiatCurrency: caps.fiatCurrency,
      cryptoCurrency: caps.cryptoCurrency,
      amount: '100.00', // decimal STRING; on_ramp amount = fiat in
      cryptoNetwork: caps.supportedNetworks[0],
      type: 'firm',
      destAddress, // required for on_ramp; locked onto the quote
      destNetwork: 'arbitrum',
    }),
  });

  // Fail-soft: HTTP 200 + available:false => no quoteId. Never transact.
  if (!quote.available || !quote.executable) {
    return { state: 'unavailable', reason: quote.unavailableReason };
  }

  // 4. Transact — Idempotency-Key REQUIRED; reuse it (and body) on retry
  const idempotencyKey = crypto.randomUUID();
  let tx;
  try {
    tx = await call(`/pools/${pool.id}/transact`, SK, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'Idempotency-Key': idempotencyKey },
      body: JSON.stringify({ quoteId: quote.quoteId }),
    });
  } catch (e: any) {
    if (e.statusCode === 409 && e.code === 'expired') {
      return { state: 'expired' }; // quote lapsed — go re-quote
    }
    throw e;
  }

  // 5. Poll to settlement — this poll ADVANCES the reserved trade
  let status = tx.status; // 'reserved'
  for (let i = 0; i < 30 && !['settled', 'failed', 'released', 'returned'].includes(status); i++) {
    await sleep(1000);
    const s = await call(`/pools/transactions/${quote.quoteId}`, SK);
    status = s.status;
  }

  return { state: status, transactId: tx.transactId, quoteId: quote.quoteId };
}

// 6. Reconcile (pure read; does NOT advance settlement)
export async function reconcile(cursor?: string) {
  const q = new URLSearchParams({ limit: '50', ...(cursor ? { cursor } : {}) });
  return call(`/pools/trades?${q}`, SK);
}

import os, time, uuid, requests

BASE = "https://pools-api.0bit.app/v1"
PK = os.environ["POOLS_PK"]  # publishable, discovery only
SK = os.environ["POOLS_SK"]  # secret, server-only

def call(method, path, key, **kwargs):
    res = requests.request(method, f"{BASE}{path}",
                           headers={"Authorization": f"Bearer {key}", **kwargs.pop("headers", {})},
                           **kwargs)
    body = res.json()
    if not res.ok:
        # Unified error envelope: branch on code/type, not on message.
        raise RuntimeError({
            "code": body.get("code"), "type": body.get("type"),
            "statusCode": body.get("statusCode"),
            "request_id": res.headers.get("X-Request-Id"),
        })
    return body

def buy_with_pool(dest_address: str):
    # 1. Discover entitled pools (pk_)
    pools = call("GET", "/pools", PK)["pools"]
    pool = next((p for p in pools if p["available"]), None)
    if not pool:
        return {"state": "no_pool"}

    # 2. Read capabilities (sk_) instead of hard-coding networks/limits
    caps = call("GET", f"/pools/{pool['id']}/capabilities", SK)

    # 3. Lock a firm quote (sk_)
    quote = call("POST", f"/pools/{pool['id']}/quote", SK, json={
        "side": "on_ramp",
        "fiatCurrency": caps["fiatCurrency"],
        "cryptoCurrency": caps["cryptoCurrency"],
        "amount": "100.00",  # decimal STRING; on_ramp amount = fiat in
        "cryptoNetwork": caps["supportedNetworks"][0],
        "type": "firm",
        "destAddress": dest_address,  # required for on_ramp; locked onto the quote
        "destNetwork": "arbitrum",
    })

    # Fail-soft: HTTP 200 + available:false => no quoteId. Never transact.
    if not quote.get("available") or not quote.get("executable"):
        return {"state": "unavailable", "reason": quote.get("unavailableReason")}

    # 4. Transact — Idempotency-Key REQUIRED; reuse it (and body) on retry
    idem = str(uuid.uuid4())
    try:
        tx = call("POST", f"/pools/{pool['id']}/transact", SK,
                  headers={"Idempotency-Key": idem},
                  json={"quoteId": quote["quoteId"]})
    except RuntimeError as e:
        if e.args[0].get("statusCode") == 409 and e.args[0].get("code") == "expired":
            return {"state": "expired"}  # quote lapsed — go re-quote
        raise

    # 5. Poll to settlement — this poll ADVANCES the reserved trade
    status = tx["status"]  # 'reserved'
    for _ in range(30):
        if status in ("settled", "failed", "released", "returned"):
            break
        time.sleep(1)
        status = call("GET", f"/pools/transactions/{quote['quoteId']}", SK)["status"]

    return {"state": status, "transactId": tx["transactId"], "quoteId": quote["quoteId"]}

# 6. Reconcile (pure read; does NOT advance settlement)
def reconcile(cursor=None):
    params = {"limit": 50}
    if cursor:
        params["cursor"] = cursor
    return call("GET", "/pools/trades", SK, params=params)