Querying Accounts and Market Data on Proof Exchange

import {
  ExchangeClient,
  generateKeypair,
  pubkeyToOwner,
  ownerToHex,
} from "@proof/trading-sdk";

const { publicKey, privateKey } = generateKeypair();
const address = pubkeyToOwner(publicKey);
const addressHex = ownerToHex(address);

const client = new ExchangeClient({ chainId: "exchange-devnet-1" });
client.setPrivateKey(privateKey);

const book = await client.queryOrderbook(1);

// book: Orderbook
// {
//   bids: OrderbookLevel[],  // sorted best (highest price) first
//   asks: OrderbookLevel[],  // sorted best (lowest price) first
// }

console.log("Best bid:", book.bids[0]);
// { price: 4999900n, totalQty: 5n, orderCount: 3 }

console.log("Best ask:", book.asks[0]);
// { price: 5000100n, totalQty: 2n, orderCount: 1 }

// Print depth table
const toUsd = (cents: bigint) => (Number(cents) / 100).toFixed(2);

console.log("─── ASKS ───");
for (const ask of [...book.asks].reverse()) {
  console.log(`$${toUsd(ask.price).padStart(12)}  ${ask.totalQty} lots  (${ask.orderCount} orders)`);
}
console.log("─── BIDS ───");
for (const bid of book.bids) {
  console.log(`$${toUsd(bid.price).padStart(12)}  ${bid.totalQty} lots  (${bid.orderCount} orders)`);
}

const markets = await client.queryMarkets();

// Filter for perpetual markets only
const perps = markets.filter((m) => m.kind === "Perp" || !m.kind);

for (const m of perps) {
  console.log({
    market: m.market,
    ticker: m.ticker,        // e.g. "BTC"
    imBps: m.imBps,          // initial margin in bps (1000 = 10% = 10x max)
    mmBps: m.mmBps,          // maintenance margin in bps
    takerFeeBps: m.takerFeeBps,
    makerFeeBps: m.makerFeeBps,
    fundingIntervalMs: m.fundingIntervalMs,
    maxFundingRateBps: m.maxFundingRateBps,
  });
}

const ticker = await client.queryTicker(1);

if (!ticker) {
  console.log("Market not found");
} else {
  console.log({
    market: ticker.market,              // "1"
    lastPrice: ticker.lastPrice,        // "$66,752.34" as cents string, e.g. "6675234"
    volume24hContracts: ticker.volume24hContracts, // total contracts traded in 24h
    change24hBps: ticker.change24hBps,  // signed 24h change in bps, e.g. "+150" = +1.5%
    fundingMsgpackB64: ticker.fundingMsgpackB64,   // base64 msgpack FundingInfo blob
    orderbookMsgpackB64: ticker.orderbookMsgpackB64, // base64 msgpack top-of-book snapshot
    openInterest: ticker.openInterest, // always null today
  });
}

const orders = await client.queryOpenOrders();
// or: await client.queryOpenOrders("0xabc123...")

for (const order of orders) {
  console.log({
    id: order.id,          // bigint engine-assigned order ID
    market: order.market,  // number
    side: order.side,      // "Buy" | "Sell"
    price: order.price,    // bigint cents
    quantity: order.quantity, // bigint contracts
  });
}

const account = await client.queryAccount();

if (!account) {
  console.log("No account on-chain yet (no deposit recorded)");
} else {
  const toUsd = (n: bigint) => (Number(n) / 1_000_000).toFixed(2);

  console.log({
    balance: `$${toUsd(account.balance)}`,     // available USDC
    equity: `$${toUsd(account.equity)}`,       // balance + unrealized PnL
    totalMm: `$${toUsd(account.totalMm)}`,     // maintenance margin requirement
    totalIm: `$${toUsd(account.totalIm)}`,     // initial margin requirement
    marginRatioBps: account.marginRatioBps,    // equity/notional in bps
    positions: account.positions.length,
    feesAccrued: account.feesAccrued !== undefined
      ? `$${toUsd(account.feesAccrued)}`
      : "n/a (older gateway)",
    volume30dMicroUsdc: account.volume30dMicroUsdc,
  });
}

const record = await client.queryWithdrawal(7n);

if (!record) {
  console.log("Withdrawal not found");
} else {
  console.log({
    id: record.id,
    amount: record.amount,          // bigint microUSDC
    status: record.status,          // "Pending" | "Completed" | "Failed"
    requestHeight: record.requestHeight, // bigint block height
    solanaDestination: record.solanaDestination, // Uint8Array (32 bytes)
  });
}

const queue = await client.queryAdlQueue(1);

console.log(`Market 1 ADL queue: ${queue.length} entries`);
for (const entry of queue.slice(0, 5)) {
  console.log({
    side: entry.side,
    size: entry.size,       // bigint contracts
    upnlNow: entry.upnlNow, // bigint microUSDC (always positive here)
    adlScore: entry.adlScore,
  });
}

const deposits = await client.queryHistoryDeposits(addressHex, {
  fromMs: Date.now() - 30 * 24 * 60 * 60 * 1000, // last 30 days
  limit: 50,
});

for (const d of deposits) {
  console.log({
    kind: d.kind,             // "deposit_confirmed"
    amount: d.amount,         // µUSDC as string
    newBalance: d.newBalance, // post-deposit balance as string
    solanaTxSig: d.solanaTxSig,
    blockHeight: d.blockHeight,
    timestamp: new Date(d.timestamp).toISOString(),
  });
}

const withdrawals = await client.queryHistoryWithdrawals(addressHex, {
  limit: 100,
});

// Filter client-side by status kind
const pending = withdrawals.filter((w) => w.kind === "withdraw_requested");
const completed = withdrawals.filter((w) => w.kind === "withdrawal_confirmed");
const failed = withdrawals.filter((w) => w.kind === "withdrawal_failed");

console.log(`Pending: ${pending.length}, Completed: ${completed.length}, Failed: ${failed.length}`);

const resolutions = await client.queryHistoryResolutions(addressHex, {
  limit: 20,
});

for (const r of resolutions) {
  console.log({
    kind: r.kind,              // "conditional_settled" | "conditional_voided" | "prediction_settled"
    market: r.market,
    side: r.side,
    size: r.size,
    entryPrice: r.entryPrice,
    settlementPrice: r.settlementPrice,
    realizedPnl: r.realizedPnl, // signed µUSDC
    timestamp: new Date(r.timestamp).toISOString(),
  });
}

const snapshots = await client.queryHistoryPositions(addressHex, {
  market: 1,
  fromMs: Date.now() - 7 * 24 * 60 * 60 * 1000,
  limit: 200,
});

// Reconstruct position entry/exit pairs
const closes = snapshots.filter((s) => s.size === "0");
console.log(`Closed ${closes.length} positions on market 1 this week`);

for (const snap of snapshots) {
  console.log({
    side: snap.side,
    entryPrice: snap.entryPrice,
    size: snap.size === "0" ? "(closed)" : snap.size,
    blockHeight: snap.blockHeight,
    timestamp: new Date(snap.timestamp).toISOString(),
  });
}

const status = await client.status();

console.log({
  latestHeight: status.latestHeight,   // number
  latestAppHash: status.latestAppHash, // hex string
});

const health = await client.queryHealth();

console.log({
  status: health.status,  // e.g. "ok"
  height: health.height,  // current block height
});

// Fetch the latest block
const latestBlock = await client.getBlock();

// Fetch a specific block by height
const block = await client.getBlock(12345);

// Fetch ABCI results for a block (contains tx execution events)
const results = await client.getBlockResults(12345);