Settlement notifier

import { createServer } from "node:http";
import { existsSync, readFileSync, writeFileSync } from "node:fs";
import { verifySignature } from "@0xinsider/sdk";

const API_KEY = process.env.OXINSIDER_API_KEY ?? "";
const DISCORD_URL = process.env.DISCORD_WEBHOOK_URL ?? "";
const SECRET = process.env.OXINSIDER_WEBHOOK_SECRET ?? ""; // optional: Pro and Max
const LEAGUES = process.env.LEAGUES ?? "nba,epl";
const TYPES = process.env.MARKET_TYPES ?? "moneyline";
const PORT = Number(process.env.PORT ?? 8787);
const STATE_FILE = "settlement-notifier.json";
if (!API_KEY || !DISCORD_URL) throw new Error("Set OXINSIDER_API_KEY and DISCORD_WEBHOOK_URL");

// The fields of a settled market this server reads: a webhook's data, or one row of the list.
interface Settled {
  condition_id: string;
  settlement_id: number;
  event_slug: string | null;
  league: string | null;
  sports_market_type: string | null;
  outcomes: string[];
  settlement: {
    payouts: number[] | null;
    result: "outcome" | "split" | null;
    winning_outcome_index: number | null;
    observed_at: string;
  };
}

// The list's cursor and the settlements already posted, kept across restarts.
const state: { cursor: string | null; posted: string[] } = existsSync(STATE_FILE)
  ? JSON.parse(readFileSync(STATE_FILE, "utf8"))
  : { cursor: null, posted: [] };
const posted = new Set(state.posted);
function save(): void {
  state.posted = [...posted].slice(-5000);
  writeFileSync(STATE_FILE, JSON.stringify(state));
}

function message(row: Settled): string {
  const { payouts, result, winning_outcome_index: winner } = row.settlement;
  const game = row.event_slug ?? row.condition_id;
  const type = row.sports_market_type ?? "market";
  let outcome = "resolved, payouts not published yet";
  if (result === "split") {
    outcome = "settled 50-50";
  } else if (winner !== null) {
    const pays = payouts ? `, pays $${(payouts[winner] / 1_000_000).toFixed(2)} a share` : "";
    outcome = `**${row.outcomes[winner] || `outcome ${winner}`}** won${pays}`;
  }
  const link = row.event_slug ? `\nhttps://0xinsider.com/event/${row.event_slug}` : "";
  return `${game} ${type}: ${outcome}${link}`;
}

// Posts a settlement once. Returns false when Discord refused it, so the caller can retry.
async function post(row: Settled): Promise<boolean> {
  const id = `${row.condition_id}_${row.settlement_id}`;
  if (posted.has(id)) return true;
  posted.add(id); // claimed before the await, so the webhook and the read never both post it
  const sent = await fetch(`${DISCORD_URL}?wait=true`, {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({ content: message(row), allowed_mentions: { parse: [] } }),
  });
  if (!sent.ok) {
    posted.delete(id);
    return false;
  }
  save();
  return true;
}

// Reads every settlement recorded since the last read, page by page, and posts it.
async function catchUp(): Promise<void> {
  for (;;) {
    const query = state.cursor
      ? new URLSearchParams({ cursor: state.cursor, limit: "100" })
      : new URLSearchParams({ since: new Date().toISOString(), league: LEAGUES, sports_market_type: TYPES, limit: "100" });
    const res = await fetch(`https://api.0xinsider.com/api/v1/markets/settled?${query}`, {
      headers: { authorization: `Bearer ${API_KEY}` },
    });
    if (!res.ok) throw new Error(`List settled markets answered ${res.status}: ${await res.text()}`);
    const page = await res.json();
    for (const row of page.data as Settled[]) {
      // Stop before the cursor moves past a settlement Discord refused; the next read retries it.
      if (!(await post(row))) return;
    }
    state.cursor = page.next_cursor;
    save();
    if (!page.has_more) return;
  }
}

async function readEveryMinute(): Promise<void> {
  try {
    await catchUp();
  } catch (error) {
    console.error(error);
  }
  setTimeout(readEveryMinute, 60_000);
}
void readEveryMinute();

// The webhook receiver, on Pro and Max. Without a secret, the server only reads.
if (SECRET) {
  createServer(async (req, res) => {
    if (req.method !== "POST") {
      res.writeHead(405).end();
      return;
    }
    const chunks: Buffer[] = [];
    for await (const chunk of req) chunks.push(chunk as Buffer);
    const body = Buffer.concat(chunks);

    // Verify the raw bytes before parsing: re-serialized JSON no longer matches the signature.
    const signed = verifySignature({
      secret: SECRET,
      timestamp: String(req.headers["x-0xinsider-timestamp"] ?? ""),
      signature: String(req.headers["x-0xinsider-signature"] ?? ""),
      body,
    });
    if (!signed) {
      res.writeHead(401).end();
      return;
    }

    // The verification challenge and other event types are acknowledged and not posted.
    const event = JSON.parse(body.toString("utf8"));
    if (event.type !== "market_settled") {
      res.writeHead(204).end();
      return;
    }
    // A 503 makes 0xinsider retry the delivery later; the minute read may post it first.
    res.writeHead((await post(event.data as Settled)) ? 204 : 503).end();
  }).listen(PORT, () => console.log(`listening on ${PORT}`));
}