How to Build a Prediction Market Trading Terminal

npm install decimal.js

const BASE = "https://bravado-api-k7kaq.ondigitalocean.app";

async function api(path: string, init: RequestInit = {}) {
  const res = await fetch(`${BASE}${path}`, {
    ...init,
    headers: {
      Authorization: `Bearer ${process.env.BRAVADO_API_KEY}`,
      "Content-Type": "application/json",
      ...init.headers,
    },
  });
  if (!res.ok) throw Object.assign(new Error(res.statusText), { status: res.status, res });
  return res.json();
}

export async function bootstrap() {
  const [account, balances, positions, orders] = await Promise.all([
    api("/v2/trade/account"),
    api("/v2/trade/balances"),
    api("/v2/trade/positions"),
    api("/v2/trade/orders/open"),
  ]);
  return { account, balances, positions, orders };
}

const { api_key } = account;

const canTrade    = api_key.scopes.includes("trade.execute");
const canCancel   = api_key.scopes.includes("trade.cancel");
const canWithdraw = api_key.scopes.includes("trade.withdraw");

const budgetPerMin = api_key.rate_limit_per_min;   // your polling allowance

type Working =
  | { kind: "order";    id: string; symbol: string; remaining: string }
  | { kind: "strategy"; id: string; symbol: string; remaining: string; status: string };

async function workingItems(): Promise<Working[]> {
  const [o, s] = await Promise.all([
    api("/v2/trade/orders/open"),
    api("/v2/trade/strategies"),
  ]);

  return [
    ...o.orders.map((x: any) => ({ kind: "order" as const, id: x.order_id,
                                   symbol: x.symbol, remaining: x.remaining_size })),
    ...s.strategies.map((x: any) => ({ kind: "strategy" as const, id: x.record_id,
                                       symbol: x.symbol, remaining: x.remaining_size,
                                       status: x.status })),
  ];
}

type Ticket = {
  clientOrderId: string;      // generated when the ticket opens
  type: "MARKET" | "LIMIT" | "TWAP" | "ICEBERG" | "PEGGED"
      | "STOP_LOSS" | "TAKE_PROFIT" | "TRAILING_STOP";
  symbol: string;
  side: "BUY" | "SELL";
  dollars?: string;
  shares?: string;
  price?: string;
};

export async function submit(t: Ticket) {
  const payload: Record<string, unknown> = {
    type: t.type, symbol: t.symbol, side: t.side,
  };

  if (t.type === "MARKET") payload.quote_amount = t.dollars;
  else {
    payload.size = t.shares;
    if (t.price) payload.price = t.price;
  }

  return api("/v2/trade/order", {
    method: "POST",
    headers: { "Idempotency-Key": t.clientOrderId },
    body: JSON.stringify(payload),
  });
}

function openTicket(symbol: string): Ticket {
  return { clientOrderId: crypto.randomUUID(), type: "MARKET", symbol, side: "BUY" };
}

const res = await submit(ticket);

if (res.warnings?.length) notify(res.warnings);

for (const leg of ["take_profit", "stop_loss"] as const) {
  const err = res.brackets?.[leg]?.error;
  if (err) warn(`${leg} not placed: ${err}`);   // position is unprotected
}

const SCHEDULE = [
  { path: "/v2/trade/orders/open", everyMs:   5_000 },
  { path: "/v2/trade/positions",   everyMs:  10_000 },
  { path: "/v2/trade/balances",    everyMs:  15_000 },
  { path: "/v2/trade/strategies",  everyMs:  15_000 },
  { path: "/leaderboard",          everyMs: 120_000 },
];

const perMin = SCHEDULE.reduce((n, s) => n + 60_000 / s.everyMs, 0);
if (perMin > account.api_key.rate_limit_per_min * 0.7) {
  console.warn(`polling ${perMin.toFixed(0)}/min against a budget of ${account.api_key.rate_limit_per_min}`);
}

async function poll(path: string) {
  try {
    return await api(path);
  } catch (e: any) {
    if (e.status === 429) {
      const wait = Number(e.res.headers.get("Retry-After") ?? 30);
      backoff(path, wait * 1000);      // pause this panel only
      return null;
    }
    throw e;
  }
}

type PositionState = "open" | "awaiting_resolution" | "resolved_unredeemed" | "redeemed";

function stateOf(p: any): PositionState {
  if (!p.market_resolved) return p.event_concluded ? "awaiting_resolution" : "open";
  return p.redeemed ? "redeemed" : "resolved_unredeemed";
}

{state === "awaiting_resolution" && (
  <Badge tone="muted">Awaiting resolution</Badge>
)}
{state === "resolved_unredeemed" && (
  <Button onClick={() => redeem(p.symbol)}>Redeem ${value}</Button>
)}

import { Decimal } from "decimal.js";

const size  = new Decimal(pos.size);
const price = new Decimal(pos.current_price);
const value = size.times(price);

const cents = `${price.times(100).toFixed(1)}¢`;
const pct   = `${price.times(100).toFixed(0)}%`;

if (e.status === 503) {
  const body = await e.res.json();
  if (body.available === false) return { state: "processing" };  // spinner, poll later
}