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

const client = new Ironflow("if_your_api_key");

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

// Or fetch history with auto-pagination
const page = await client.trades("BTC-PERP", { limit: 100 });
for (const trade of page.data) console.log(trade);

for await (const fill of client.stream.fills("0xleader_address")) {
  console.log(`${fill.side} ${fill.size} ${fill.market} @ ${fill.price}`);
  // submit identical order to your venue
}

for await (const liq of client.stream.liquidations("BTC-PERP")) {
  if (Number(liq.size) >= 10) {
    await fetch(SLACK_WEBHOOK, {
      method: "POST",
      body: JSON.stringify({ text: `${liq.size} BTC liq @ ${liq.price}` }),
    });
  }
}

const markets = await client.markets({ market_class: "perp" });
for (const m of markets) {
  const page = await client.funding(m.display_symbol, { limit: 1 });
  const [latest] = page.data;
  if (latest && Math.abs(Number(latest.rate)) > 0.0005) {
    console.log(`${m.display_symbol}: ${latest.rate}`);
  }
}

const addr = "0xabc...";

// Live snapshot (HL clearinghouseState shape)
const state = await client.userState(addr);
console.log(state.margin_summary.account_value, state.positions.length);

// Funding payments — UI-aligned (positive = paid, negative = received)
const funding = await client.userFunding(addr, { from: Date.now() - 14 * 86400_000 });
const total = funding.reduce((s, p) => s + Number(p.usdc), 0);

// Maker/taker split, per market + a TOTAL row
const mt = await client.userMakerTaker(addr, { from: Date.now() - 14 * 86400_000 });
const total_row = mt.breakdown.find((r) => r.market === "TOTAL");
console.log(total_row?.maker_pct, total_row?.taker_pct);

// Unified ledger: deposits, withdrawals, funding payments, transfers
const ledger = await client.userLedger(addr, { limit: 200 });

const predictions = await client.markets({ market_class: "prediction" });
// predictions[0].display_symbol -> e.g. "BTC-78213-20260503-Yes"
for (const m of predictions) {
  const page = await client.trades(m.display_symbol, { limit: 1 });
  console.log(m.display_symbol, page.data[0]?.price);
}

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 addr = "0xabc...";

// Open positions + margin summary (HL clearinghouseState shape)
const state = await client.userState(addr);

// Funding payments — paid (positive) and received (negative)
const funding = await client.userFunding(addr, { from, to });

// Maker vs taker breakdown per market + a synthetic TOTAL row
const mt = await client.userMakerTaker(addr, { from, to });
// mt.breakdown[i].market, .maker_volume, .taker_volume, .maker_pct, .taker_pct

// Unified ledger: deposits / withdrawals / funding / transfers
const ledger = await client.userLedger(addr, { limit: 200, cursor });

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
const predictions = await client.markets({ market_class: "prediction" }); // HIP-4

// 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);
}