Trading terminal

import express from "express";
import WebSocket from "ws";

const API = "https://api.fomoscan.sh";
const headers = { Authorization: `Bearer ${process.env.FOMOSCAN_KEY}` };
const viewers = new Map();
const pnlCache = new Map();
let socket;

async function api(path, init = {}) {
  const res = await fetch(API + path, { ...init, headers: { ...headers, ...init.headers } });
  if (!res.ok) throw new Error(`${res.status} ${path}`);
  return res.json();
}

function subscribe() {
  if (socket?.readyState !== WebSocket.OPEN) return;
  const tokens = [...viewers.keys()].slice(0, 50);
  const frame = tokens.length
    ? { type: "subscribe", subscription: { type: "tokens", tokens } }
    : { type: "unsubscribe" };
  socket.send(JSON.stringify(frame));
}

function connect() {
  socket = new WebSocket(`${API.replace("https", "wss")}/v2/ws`, { headers });
  socket.on("open", subscribe);
  socket.on("message", (raw) => {
    const frame = JSON.parse(raw.toString());
    if (frame.type !== "thesis") return;
    for (const res of viewers.get(frame.data.tokenAddress) ?? []) {
      res.write(`data: ${JSON.stringify(frame.data)}\n\n`);
    }
  });
  socket.on("error", (err) => console.error(err.message));
  socket.on("close", (code) => {
    if (code !== 1008) setTimeout(connect, 2000);
  });
}

const app = express();
app.use(express.json());
app.use(express.static("public"));

app.get("/token/:address", async (req, res) => {
  const page = await api(`/v2/thesis/token/${req.params.address}?limit=50`);
  res.json(page);
});

app.get("/token/:address/live", (req, res) => {
  const key = req.query.key;
  res.set({ "Content-Type": "text/event-stream", "Cache-Control": "no-cache" });
  res.flushHeaders();
  if (!viewers.has(key)) viewers.set(key, new Set());
  viewers.get(key).add(res);
  subscribe();
  req.on("close", () => {
    viewers.get(key).delete(res);
    if (viewers.get(key).size === 0) viewers.delete(key);
    subscribe();
  });
});

app.post("/authors/pnl", async (req, res) => {
  const fresh = Date.now() - 10 * 60_000;
  const cached = (h) => pnlCache.get(h.toLowerCase());
  const wanted = req.body.handles.filter((h) => !(cached(h)?.at > fresh)).slice(0, 100);
  if (wanted.length) {
    const { entries } = await api("/v2/user/handles/pnl", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ handles: wanted }),
    });
    for (const e of entries) {
      if (e.status === "ready") pnlCache.set(e.handle.toLowerCase(), { at: Date.now(), entry: e });
    }
  }
  res.json(Object.fromEntries(req.body.handles.map((h) => [h, cached(h)?.entry ?? null])));
});

connect();
app.listen(3000);

<input id="token" placeholder="Token address" />
<ul id="wall"></ul>
<script>
  const seen = new Set();
  const wall = document.getElementById("wall");
  let live;

  function render(t, top) {
    const key = t.thesisHash ?? t.id;
    if (seen.has(key)) return;
    seen.add(key);
    const li = document.createElement("li");
    li.dataset.author = t.authorHandle;
    li.textContent = `@${t.authorHandle}: ${t.thesis}`;
    top ? wall.prepend(li) : wall.append(li);
  }

  async function open(address) {
    wall.innerHTML = "";
    seen.clear();
    const page = await (await fetch(`/token/${address}`)).json();
    page.items.forEach((t) => render(t, false));
    live?.close();
    live = new EventSource(`/token/${address}/live?key=${page.tokenAddress}`);
    live.onmessage = (e) => render(JSON.parse(e.data), true);
    const handles = [...new Set(page.items.map((t) => t.authorHandle).filter(Boolean))];
    const pnl = await (await fetch("/authors/pnl", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ handles }),
    })).json();
    for (const li of wall.children) {
      const net = pnl[li.dataset.author]?.windows?.["30d"]?.netUsd;
      if (net != null) li.textContent += ` (30d: $${Math.round(net).toLocaleString()})`;
    }
  }

  document.getElementById("token").onchange = (e) => open(e.target.value.trim());
</script>