TypeScript client

npm install @0xinsider/sdk

import { OxinsiderApiClient, RateLimitedError, type Trader } from "@0xinsider/sdk";

const sandbox = OxinsiderApiClient.sandbox();
const board = await sandbox.listLeaderboard({ limit: 5 });
console.log(board.data, board.meta.sandbox); // LeaderboardEntry[], true

// sandbox_status is not part of the route's documented query, so this call
// takes the loose form: an explicit type argument in place of the typed one.
try {
  await sandbox.call<Trader>("getTrader", {
    path: { address: "swisstony" },
    query: { sandbox_status: 429 },
  });
} catch (err) {
  if (err instanceof RateLimitedError) console.log(err.retryAfterSeconds);
  else throw err;
}

import { OxinsiderApiClient } from "@0xinsider/sdk";

const client = new OxinsiderApiClient({
  apiKey: process.env.OXINSIDER_API_KEY,
  // baseUrl defaults to https://api.0xinsider.com
});

// A wallet address, a username, or a trd_ ID
const trader = await client.getTrader("swisstony", {
  query: { expand: ["strategy", "categories"] },
});
console.log(trader.data);

const markets = await client.searchMarkets("NBA", {
  query: { limit: 5, status: "active" },
});
console.log(markets.data);

// Any operation by id, typed by the id: path, query, body and the envelope
const usage = await client.call("getUsage");
const holders = await client.call("getMarketHolders", {
  path: { condition_id: "0x..." },
  query: { outcome: "yes", limit: 25 },
});

npm install @0xinsider/sdk@0.15.0

import { OxinsiderApiClient } from "@0xinsider/sdk";

const publicClient = new OxinsiderApiClient();
const entry = await publicClient.getPickOfTheDayLedgerEntry("731");
console.log(entry.data.pick_id, entry.data.state);

const controller = new AbortController();
const signal = controller.signal;
const trades = await client.listLargeTrades(
  { min_grade: "S", limit: 25 },
  { signal, timeoutMs: 5_000, maxRetries: 0 },
);
trades.data[0].trader.address; // LargeTrade
trades.meta.request_id; // ResponseMeta, always present

npm install decimal.js

import Decimal from "decimal.js";

const profile = await client.getTrader("swisstony");
const realizedAtom = profile.data.pnl.exact?.realized;
if (realizedAtom) {
  const realizedUsd = new Decimal(realizedAtom.value);
  console.log(realizedUsd.plus("0.01").toFixed());
}

const positions = await client.listPositions({ wallet: "swisstony", min_size: 0 });
const currentAtom = positions.data[0]?.exact?.current_value_usd;
const currentUsd = currentAtom ? new Decimal(currentAtom.value) : null;

const batch = await client.batchGetTraders(["swisstony", "trd_123"], {
  expand: ["strategy", "trust"], // strategy, categories, quant_metrics, trust
});
for (const item of batch.data) {
  if (item.status === "ok") console.log(item.input, item.data?.grade);
  else console.log(item.input, item.error?.code);
}

import { paginate, paginationResumePoint } from "@0xinsider/sdk";

try {
  for await (const trade of paginate(client, "listLargeTrades", {
    query: { min_grade: "S", limit: 100 },
  })) {
    console.log(trade);
  }
} catch (err) {
  const resume = paginationResumePoint(err); // { cursor, pagesFetched } or undefined
  if (!resume) throw err;
}

import { isApiNotModifiedResponse } from "@0xinsider/sdk";

const first = await client.call("getTrader", { path: { address: "swisstony" } });

if (!isApiNotModifiedResponse(first) && first.meta.etag) {
  const next = await client.call("getTrader", {
    path: { address: "swisstony" },
    headers: { "If-None-Match": first.meta.etag },
  });
  if (isApiNotModifiedResponse(next)) console.log("unchanged");
}

import { OxinsiderApiError, RateLimitedError } from "@0xinsider/sdk";

try {
  await client.listLargeTrades({ min_grade: "S" });
} catch (err) {
  if (err instanceof RateLimitedError) {
    await new Promise((r) => setTimeout(r, (err.retryAfterSeconds ?? 1) * 1000));
  } else if (err instanceof OxinsiderApiError && err.retryAt) {
    console.log("retry at", err.retryAt.toISOString()); // schedule; never sleep on it
  } else if (err instanceof OxinsiderApiError) {
    console.error(err.status, err.code, err.requestId);
  } else {
    throw err;
  }
}

await client.call("createWebhook", {
  body: {
    name: "Large trades",
    url: "https://example.com/hooks/0xinsider",
    event_types: ["whale_trades_inserted"],
  },
  idempotencyKey: crypto.randomUUID(),
});

import { streamFeed } from "@0xinsider/sdk";

for await (const frame of streamFeed(client, { signal: AbortSignal.timeout(30_000) })) {
  console.log(frame);
}