import { Ironflow } from "@ironflowsh/sdk";

const client = new Ironflow("if_your_api_key");

// Get recent trades
const page = await client.trades("BTC-PERP", { limit: 10 });
for (const trade of page.data) {
  console.log(trade.price, trade.size, trade.side);
}

// Paginate
if (page.hasMore) {
  const next = await page.next();
}

const client = new Ironflow("if_your_api_key", {
  baseUrl: "https://api.ironflow.sh",  // default
  source: "hyperliquid",               // default
  timeout: 30_000,                     // request timeout in ms (default: 30s)
});

// Trades
const trades = await client.trades("BTC-PERP", { limit: 100 });

// Fills (requires address)
const fills = await client.fills({ address: "0xabc...", market: "ETH-PERP" });

// Order book snapshot
const book = await client.book("BTC-PERP");
// book.bids[0].price, book.bids[0].size

// OHLCV candles
const candles = await client.candles("BTC-PERP", "1h", { limit: 24 });

// Liquidations
const liqs = await client.liquidations("BTC-PERP");

// Funding rates
const rates = await client.funding("BTC-PERP");

// Open interest
const oi = await client.openInterest("BTC-PERP");

// Mark prices
const prices = await client.markPrices("BTC-PERP");

// Deposits & withdrawals
const deps = await client.deposits({ address: "0xabc..." });
const wds = await client.withdrawals({ address: "0xabc..." });

// Order statuses
const orders = await client.orderStatuses({ address: "0xabc..." });

// Vault operations
const vaults = await client.vaultOperations({ vault: "HLP" });

const flows = await client.netFlows({ interval: "1d", limit: 7 });
// flows[0].deposits, flows[0].withdrawals, flows[0].net_flow

const levels = await client.liquidationLevels("BTC-PERP", { bucket_size: 100 });
// levels[0].price_bucket, levels[0].count, levels[0].total_size

const orderFlow = await client.orderFlow();
// orderFlow[0].total_orders, orderFlow[0].filled_orders, orderFlow[0].fill_rate

const leaderboard = await client.vaultLeaderboard();
// leaderboard[0].vault, leaderboard[0].total_deposits, leaderboard[0].net_flow

const funding = await client.fundingStats("BTC-PERP", { interval: "8h" });
// funding[0].avg_rate, funding[0].min_rate, funding[0].max_rate

// Create a webhook trigger
const trigger = await client.createTrigger({
  name: "whale-alert",
  channel: "trades",
  webhook_url: "https://your-server.com/hook",
  rule: {
    condition: { field: "data.size", op: "gt", value: "100" },
  },
});

// List, toggle, delete
const triggers = await client.listTriggers();
await client.toggleTrigger(trigger.id, false);
await client.deleteTrigger(trigger.id);

// Test a rule without creating
const result = await client.testTrigger({
  rule: { condition: { field: "data.size", op: "gt", value: "10" } },
  event: { data: { size: "50", market: "BTC-PERP" } },
});
console.log(result.matched); // true

// All currently-active markets (perp + spot, every issuer)
const all = await client.markets();

// Filter by class and issuer
const perps  = await client.markets({ market_class: "perp" });
const native = await client.markets({ issuer: "" });           // native non-builder only
const flxOnly = await client.markets({ issuer: "flx" });       // HIP-3 builder

// Each row carries the v3 identity tuple so it joins with /v1/* responses:
//   { market_id, source, market_class, issuer,
//     base_asset, quote_asset, base_market, display_symbol,
//     hl_coin, active_from_ms }
//
// `base_market` is the display symbol with any HIP-3 issuer prefix stripped:
//   "flx:GAS-PERP" -> "GAS-PERP" (pair with `issuer` to query across builders).

const cohorts = await client.listCohorts();
const addrs = await client.cohortAddresses("top_pnl_30d");
await client.createCohort({ name: "my_whales", addresses: ["0xabc..."] });
await client.deleteCohort("my_whales");

const data = await client.exportData({
  event_type: "fills",
  market: "BTC-PERP",
  format: "csv",
});
// data is Uint8Array — write to file or parse

// Overall system status + per-venue freshness
const status = await client.status();
console.log(status.status); // "operational"
console.log(status.venues.hyperliquid.streams.fills.age_seconds);

// Rolling-window performance metrics (5-min API + pipeline + synthetic)
const metrics = await client.statusMetrics();
console.log(metrics.api.latency_p99_ms, metrics.pipeline.events_per_sec);

// Uptime / freshness timeline — "24h" (default) or "7d"
const history = await client.statusHistory("7d");
console.log(history.uptime_percent, history.points.length);

const meta = await client.info({ type: "metaAndAssetCtxs" });

// Real-time trades
for await (const trade of client.stream.trades("BTC-PERP")) {
  console.log(trade.price, trade.size, trade.side);
}

// Wallet fills (copy trading)
for await (const fill of client.stream.fills("0xleader")) {
  console.log(fill.side, fill.size, fill.market);
}

// Order book updates
for await (const snap of client.stream.book("ETH-PERP")) {
  console.log(snap.bids[0].price, snap.asks[0].price);
}

// Filter by minimum size
for await (const trade of client.stream.trades("BTC-PERP", { min_size: "10" })) {
  // Only trades >= 10 BTC
}

import { Ironflow, RateLimitError, AuthError, TierError, QueryWindowError } from "@ironflowsh/sdk";

try {
  const trades = await client.trades("BTC-PERP");
} catch (err) {
  if (err instanceof RateLimitError) {
    // Retry after the specified delay
    console.log(`Rate limited, retry in ${err.retryAfterMs}ms`);
  } else if (err instanceof AuthError) {
    console.log("Invalid API key");
  } else if (err instanceof TierError) {
    console.log("Upgrade your plan for this endpoint");
  } else if (err instanceof QueryWindowError) {
    console.log("Time range too wide for your tier");
  }
}

let page = await client.trades("BTC-PERP", { limit: 1000 });
const allTrades = [...page.data];

while (page.hasMore) {
  page = await page.next();
  allTrades.push(...page.data);
}