| import { readFileSync } from "node:fs"; |
| import { describe, expect, it } from "vitest"; |
| import request from "supertest"; |
| import { calibrate } from "./intel/calibrate.js"; |
| import { buildPreIpo, buildPreview, buildRunners, buildSignal } from "./intel/builders.js"; |
| import { createApp, challengeOnlyFacilitator } from "./server.js"; |
| import { |
| parseCandleRows, |
| parseEnvelope, |
| parseFundingRows, |
| parseIndexRows, |
| parseInstrumentRows, |
| parseOpenInterestRows, |
| parseOrderBookRow, |
| parseRubikLongShortRows, |
| parseRubikOpenInterestRows, |
| parseRubikTakerRows, |
| parseTickerRows, |
| } from "./okx/parsers.js"; |
| import type { OrderBook, Positioning, UniverseProvider } from "./intel/types.js"; |
| import type { RunnerInput } from "./intel/input.js"; |
| import type { MarketSnapshot } from "./intel/types.js"; |
|
|
| const ENV = { |
| NETWORK: "eip155:196", |
| PAY_TO: "0x000000000000000000000000000000000000dEaD", |
| PUBLIC_API_BASE_URL: "http://localhost:8080", |
| WEB_ORIGIN: "*", |
| }; |
|
|
| function fixture<T>(name: string): T[] { |
| const parsed = JSON.parse( |
| readFileSync(new URL(`./okx/__fixtures__/${name}`, import.meta.url), "utf8"), |
| ) as { code: string; data: T[] }; |
| return parseEnvelope<T>(parsed).data; |
| } |
|
|
| function makeSnapshot(): MarketSnapshot { |
| const perps = parseInstrumentRows( |
| fixture<Record<string, unknown>>("instruments-swap.json"), |
| "perp", |
| ); |
| const spots = parseInstrumentRows( |
| fixture<Record<string, unknown>>("instruments-spot.json"), |
| "spot", |
| ); |
| const series = { |
| "NVDA-USDT-SWAP": parseCandleRows(fixture<unknown>("candles-nvda-swap.json")), |
| "XNVDA-USDT": parseCandleRows(fixture<unknown>("candles-nvda-spot.json")), |
| "ANTHROPIC-USDT-SWAP": parseCandleRows( |
| fixture<unknown>("candles-anthropic.json"), |
| ), |
| }; |
| const byMarket = { |
| perp: { |
| "NVDA-USDT-SWAP": series["NVDA-USDT-SWAP"], |
| "ANTHROPIC-USDT-SWAP": series["ANTHROPIC-USDT-SWAP"], |
| }, |
| spot: { "XNVDA-USDT": series["XNVDA-USDT"] }, |
| }; |
| return { |
| perps, |
| spots, |
| tickers: { |
| ...parseTickerRows( |
| fixture<Record<string, unknown>>("tickers-swap.json"), |
| "perp", |
| ), |
| ...parseTickerRows( |
| fixture<Record<string, unknown>>("tickers-spot.json"), |
| "spot", |
| ), |
| }, |
| indices: parseIndexRows(fixture<Record<string, unknown>>("index.json")), |
| funding: parseFundingRows( |
| fixture<Record<string, unknown>>("funding.json"), |
| ), |
| openInterest: parseOpenInterestRows( |
| fixture<Record<string, unknown>>("open-interest.json"), |
| ), |
| series, |
| calibrations: { |
| perp: { |
| 1: calibrate(byMarket.perp, 1), |
| 7: calibrate(byMarket.perp, 7), |
| 30: calibrate(byMarket.perp, 30), |
| }, |
| spot: { |
| 1: calibrate(byMarket.spot, 1), |
| 7: calibrate(byMarket.spot, 7), |
| 30: calibrate(byMarket.spot, 30), |
| }, |
| }, |
| books: { |
| "ANTHROPIC-USDT-SWAP": parseOrderBookRow( |
| fixture<Record<string, unknown>>("books-anthropic.json")[0]!, |
| ), |
| }, |
| updatedAt: new Date().toISOString(), |
| candlesRefreshedAt: new Date().toISOString(), |
| tickersRefreshedAt: new Date().toISOString(), |
| }; |
| } |
|
|
| const snapshot = makeSnapshot(); |
| const rubikOi = parseRubikOpenInterestRows( |
| fixture<unknown>("rubik-open-interest.json"), |
| ); |
| const rubikLongShort = parseRubikLongShortRows( |
| fixture<unknown>("rubik-long-short.json"), |
| ); |
| const rubikTaker = parseRubikTakerRows(fixture<unknown>("rubik-taker.json")); |
| const book = parseOrderBookRow( |
| fixture<Record<string, unknown>>("books-anthropic.json")[0]!, |
| ); |
|
|
| function makeProvider(data: MarketSnapshot | null): UniverseProvider { |
| return { |
| snapshot: () => data, |
| status: () => ({ |
| ready: data !== null, |
| perps: data?.perps.length ?? 0, |
| spots: data?.spots.length ?? 0, |
| preIpo: data?.perps.filter((instrument) => instrument.preIpo).length ?? 0, |
| candlesRefreshedAt: data?.candlesRefreshedAt ?? null, |
| tickersRefreshedAt: data?.tickersRefreshedAt ?? null, |
| }), |
| async positioning(instId): Promise<Positioning> { |
| return { |
| fundingRate: data?.funding[instId]?.fundingRate ?? null, |
| nextFundingTime: data?.funding[instId]?.nextFundingTime ?? null, |
| openInterestUsd: data?.openInterest[instId]?.oiUsd ?? null, |
| oiHistory: instId === "NVDA-USDT-SWAP" ? rubikOi : [], |
| longShortAccountRatio: |
| instId === "NVDA-USDT-SWAP" ? rubikLongShort : null, |
| takerVolume: instId === "NVDA-USDT-SWAP" ? rubikTaker : [], |
| }; |
| }, |
| async orderBook(instId): Promise<OrderBook | null> { |
| return instId === "ANTHROPIC-USDT-SWAP" ? book : null; |
| }, |
| }; |
| } |
|
|
| function appFor(data: MarketSnapshot | null = snapshot) { |
| return createApp({ |
| env: ENV, |
| universe: makeProvider(data), |
| facilitator: challengeOnlyFacilitator(ENV.NETWORK), |
| syncFacilitatorOnStart: true, |
| }); |
| } |
|
|
| describe("API", () => { |
| it("serves the free health, catalog, universe, preview, and payments endpoints", async () => { |
| const app = appFor(); |
| const health = await request(app).get("/health"); |
| expect(health.status).toBe(200); |
| expect(health.body.service).toBe("UltraX"); |
| expect(health.body.universe.ready).toBe(true); |
|
|
| const catalog = await request(app).get("/catalog"); |
| expect(catalog.status).toBe(200); |
| expect(catalog.body.name).toBe("UltraX"); |
| expect(catalog.body.tagline).toBe( |
| "Market intelligence for everything stocks on OKX", |
| ); |
| expect(catalog.body.endpoints.paid).toHaveLength(3); |
| expect(catalog.body.okxAgent.id).toBe("13937"); |
|
|
| const universe = await request(app).get("/universe"); |
| expect(universe.status).toBe(200); |
| expect(universe.body.counts.perps).toBeGreaterThan(0); |
| expect(universe.body.perps.map((item: { symbol: string }) => item.symbol)).toContain( |
| "NVDA", |
| ); |
|
|
| const preview = await request(app).get("/preview"); |
| expect(preview.status).toBe(200); |
| expect(preview.body.runners.daily.length).toBeGreaterThan(0); |
| expect(Object.keys(preview.body.runners.daily[0]).sort()).toEqual( |
| ["closes", "last", "preIpo", "returnPct", "symbol"].sort(), |
| ); |
| expect(preview.body.runners.daily[0].closes).toBeInstanceOf(Array); |
| expect( |
| preview.body.runners.daily[0].closes.every( |
| (c: unknown) => typeof c === "number", |
| ), |
| ).toBe(true); |
| expect(preview.body.runners.daily[0]).not.toHaveProperty("score"); |
|
|
| const payments = await request(app).get("/payments/recent"); |
| expect(payments.status).toBe(200); |
| expect(payments.body.payTo).toBe(ENV.PAY_TO); |
| expect(payments.body.payments).toEqual([]); |
| }); |
|
|
| it("validates required fields and rejects unknown or non-pre-IPO symbols before payment", async () => { |
| const app = appFor(); |
| const runners = await request(app).post("/runners").send({}); |
| expect(runners.status).toBe(400); |
| expect(runners.body.status).toBe("input_required"); |
| expect(runners.body.missing).toEqual(["period"]); |
| expect(runners.body.required.period.enum).toEqual([ |
| "daily", |
| "weekly", |
| "monthly", |
| ]); |
|
|
| const signal = await request(app).post("/signal").send({}); |
| expect(signal.status).toBe(400); |
| expect(signal.body.status).toBe("input_required"); |
| expect(signal.body.missing).toEqual(["symbol"]); |
|
|
| const unknown = await request(app) |
| .post("/signal") |
| .send({ symbol: "NOT-A-STOCK" }); |
| expect(unknown.status).toBe(400); |
| expect(unknown.body.hint).toBe("GET /universe"); |
|
|
| const notPreIpo = await request(app) |
| .post("/preipo") |
| .send({ symbol: "NVDA" }); |
| expect(notPreIpo.status).toBe(400); |
| }); |
|
|
| it("issues x402 challenges for all valid unpaid paid routes", async () => { |
| const app = appFor(); |
| const cases = [ |
| ["/runners", { period: "weekly" }, "10000"], |
| ["/signal", { symbol: "NVDA" }, "5000"], |
| ["/preipo", {}, "10000"], |
| ] as const; |
| for (const [path, body, amount] of cases) { |
| const response = await request(app).post(path).send(body); |
| expect(response.status, response.text).toBe(402); |
| const header = response.headers["payment-required"]; |
| expect(header).toBeTruthy(); |
| const decoded = JSON.parse( |
| Buffer.from(header, "base64").toString("utf8"), |
| ) as { accepts: { amount: string; payTo: string }[] }; |
| expect(decoded.accepts[0]!.amount).toBe(amount); |
| expect(decoded.accepts[0]!.payTo.toLowerCase()).toBe( |
| ENV.PAY_TO.toLowerCase(), |
| ); |
| } |
| }); |
|
|
| it("returns 503 before payment while the universe is warming", async () => { |
| const app = appFor(null); |
| const cases = [ |
| ["/runners", { period: "daily" }], |
| ["/signal", { symbol: "NVDA" }], |
| ["/preipo", {}], |
| ] as const; |
| for (const [path, body] of cases) { |
| const response = await request(app).post(path).send(body); |
| expect(response.status).toBe(503); |
| expect(response.body.error).toBe("universe warming up"); |
| } |
| }); |
|
|
| it("builds fixture-backed runners, per-stock signals, and pre-IPO tables", async () => { |
| const runners = buildRunners(snapshot, { |
| period: "weekly", |
| market: "perp", |
| direction: "up", |
| limit: 10, |
| minVolumeUsd: 100_000, |
| } satisfies RunnerInput); |
| expect(runners.runners.length).toBeGreaterThan(0); |
|
|
| const signal = await buildSignal(snapshot, "NVDA-USDT-SWAP", "weekly", async (instId) => |
| makeProvider(snapshot).positioning(instId), |
| ); |
| expect(signal.instId).toBe("NVDA-USDT-SWAP"); |
| expect(signal.horizons.weekly.horizonDays).toBe(7); |
| expect(signal.positioning.fundingRate).not.toBeNull(); |
| expect(signal).toHaveProperty("spot.instId", "XNVDA-USDT"); |
|
|
| const preIpo = await buildPreIpo( |
| snapshot, |
| "ANTHROPIC", |
| async () => book, |
| ); |
| expect(preIpo.contracts).toHaveLength(1); |
| expect(preIpo.contracts[0]!.company).toBe("Anthropic"); |
| expect(preIpo.contracts[0]!.estimatedShares).toBe(1_000_000_000); |
| expect(preIpo.contracts[0]!.impliedValuationUsd).toBeGreaterThan(10_000_000_000); |
| expect(preIpo.contracts[0]!.orderbook.spreadBps).not.toBeNull(); |
|
|
| const preview = await buildPreview(snapshot); |
| expect(preview.model.calibration.daily.samples).toBeGreaterThan(0); |
| }); |
| }); |
|
|
