Compare a market across venues

import os
import requests

API = "https://api.routeur.app"
session = requests.Session()
session.headers["X-API-Key"] = os.environ["ROUTEUR_API_KEY"]


def equivalent_pairs(pages=5, limit=200):
    for page in range(pages):
        res = session.get(f"{API}/v1/cross-venue",
                          params={"relation": "equivalent", "limit": limit, "offset": page * limit}, timeout=20)
        res.raise_for_status()
        data = res.json()["data"]
        yield from data
        if len(data) < limit:
            return


def yes_ask(market):
    ask = (market.get("quote") or {}).get("yes_ask_usd")
    return float(ask) if ask else None


def cents(x):
    return f"{x * 100:.1f}¢"


rows = []
for pair in equivalent_pairs():
    left, right = pair["left"], pair["right"]
    if "thin" in (left["liquidity"], right["liquidity"]):
        continue                                    # a price nobody can trade at is not a price
    l, r = yes_ask(left), yes_ask(right)
    if l is None or r is None:
        continue
    gap = abs(l - r)
    # Crossing both books costs each market's own round trip; what is left is the net gap.
    round_trips = float(left.get("spread_usd") or 0) + float(right.get("spread_usd") or 0)
    rows.append((gap, gap - round_trips, pair))

rows.sort(key=lambda row: row[0], reverse=True)
for gap, net, pair in rows[:10]:
    l, r = pair["left"], pair["right"]
    print(f"{cents(gap):>6} apart, {cents(net):>6} after both spreads · {l['title']}")
    print(f"       {l['venue']}: {cents(yes_ask(l))} ({l['liquidity']}, ${float(l['volume_24h_usd']):,.0f} in 24h)"
          f"   {r['venue']}: {cents(yes_ask(r))} ({r['liquidity']}, ${float(r['volume_24h_usd']):,.0f} in 24h)")
print(f"\n{len(rows)} tradeable pairs compared")

const API = 'https://api.routeur.app';
const headers = { 'X-API-Key': process.env.ROUTEUR_API_KEY! };

type Market = {
  venue: string; id: string; title: string; liquidity: 'deep' | 'tradeable' | 'thin';
  volume_24h_usd: string; spread_usd?: string; quote?: { yes_ask_usd?: string };
};
type Pair = { relation: string; left: Market; right: Market };

async function equivalentPairs(pages = 5, limit = 200): Promise<Pair[]> {
  const all: Pair[] = [];
  for (let page = 0; page < pages; page++) {
    const params = new URLSearchParams({ relation: 'equivalent', limit: String(limit), offset: String(page * limit) });
    const res = await fetch(`${API}/v1/cross-venue?${params}`, { headers });
    if (!res.ok) throw new Error(`cross-venue: ${res.status}`);
    const { data } = (await res.json()) as { data: Pair[] };
    all.push(...data);
    if (data.length < limit) break;
  }
  return all;
}

const yesAsk = (m: Market) => (m.quote?.yes_ask_usd ? Number(m.quote.yes_ask_usd) : undefined);
const cents = (x: number) => `${(x * 100).toFixed(1)}¢`;
const usd = (s: string) => `$${Math.round(Number(s)).toLocaleString()}`;

const rows = (await equivalentPairs())
  .filter(p => p.left.liquidity !== 'thin' && p.right.liquidity !== 'thin')
  .map(p => ({ pair: p, left: yesAsk(p.left), right: yesAsk(p.right) }))
  .filter(p => p.left !== undefined && p.right !== undefined)
  .map(p => {
    const gap = Math.abs(p.left! - p.right!);
    const roundTrips = Number(p.pair.left.spread_usd ?? 0) + Number(p.pair.right.spread_usd ?? 0);
    return { ...p, gap, net: gap - roundTrips };
  })
  .sort((a, b) => b.gap - a.gap);

for (const { pair, left, right, gap, net } of rows.slice(0, 10)) {
  const l = pair.left, r = pair.right;
  console.log(`${cents(gap)} apart, ${cents(net)} after both spreads · ${l.title}`);
  console.log(`     ${l.venue}: ${cents(left!)} (${l.liquidity}, ${usd(l.volume_24h_usd)} in 24h)   ${r.venue}: ${cents(right!)} (${r.liquidity}, ${usd(r.volume_24h_usd)} in 24h)`);
}
console.log(`\n${rows.length} tradeable pairs compared`);