import { GammaClient, ClobClient } from "@varla/polymarket";

// Fetch markets from Gamma API
const gamma = new GammaClient();
const markets = await gamma.getMarkets({ limit: 10 });

// Get orderbook from CLOB
const clob = new ClobClient();
const book = await clob.getBook(markets[0].clobTokenIds[0]);
console.log("Best bid:", book.bids[0]);
console.log("Best ask:", book.asks[0]);

// Get prices
const midpoint = await clob.getMidpoint(markets[0].clobTokenIds[0]);
const spread = await clob.getSpread(markets[0].clobTokenIds[0]);

import { createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { polygon } from "viem/chains";
import { ClobTradingClient } from "@varla/polymarket";

// Create wallet
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const walletClient = createWalletClient({
  account,
  chain: polygon,
  transport: http(),
});

// Create trading client
const client = new ClobTradingClient(walletClient);
await client.init(); // Derives API key from wallet

// Place a limit order
const response = await client.createAndPostOrder(
  {
    tokenId: "123456...",  // From Gamma API
    price: 0.50,           // $0.50 per share
    size: 100,             // 100 shares
    side: "BUY",
  },
  {
    tickSize: "0.01",      // From Gamma API
    negRisk: false,        // From Gamma API
  },
  "GTC" // Good-Til-Cancelled
);

console.log("Order ID:", response.orderID);

// Cancel order
await client.cancelOrder(response.orderID);

// Get open orders
const orders = await client.getOpenOrders();

import { ClobWsClient } from "@varla/polymarket";

const ws = new ClobWsClient({
  onBookUpdate: (update) => {
    console.log("Market:", update.market);
    console.log("Best bid:", update.bids[0]);
    console.log("Best ask:", update.asks[0]);
  },
  onConnect: () => console.log("Connected"),
  onDisconnect: (reason) => console.log("Disconnected:", reason),
});

ws.connect();
ws.subscribeMarket("0x5f65177b394277fd294cd75650044e32ba009a95...");

// Cleanup
ws.close();

import { 
  ClobTradingClient, 
  createSqliteOrderPersistence,
  createTrackedOrder,
} from "@varla/polymarket";

const persistence = createSqliteOrderPersistence("./orders.db");

// Track placed orders
const order = createTrackedOrder({
  orderId: response.orderID,
  market: "0x...",
  tokenId: "123456...",
  side: "BUY",
  price: 0.5,
  size: 100,
  orderType: "GTC",
  status: "OPEN",
});
await persistence.save(order);

// Query orders
const openOrders = await persistence.getOpen();
const marketOrders = await persistence.getByMarket("0x...");

// Cleanup old orders
await persistence.prune(24 * 60 * 60 * 1000); // 24h

persistence.close();

// Initialization
client.init()                           // Derive/create API key
client.setCredentials(creds)            // Set API key manually

// Orders
client.createOrder(params, options)     // Create signed order
client.postOrder(order, type)           // Post to CLOB
client.createAndPostOrder(params, options, type)  // Combined
client.getOrder(orderId)                // Get order details
client.getOpenOrders(filter?)           // List open orders

// Cancellation
client.cancelOrder(orderId)             // Cancel one order
client.cancelOrders(orderIds)           // Cancel multiple
client.cancelMarketOrders({ market })   // Cancel by market
client.cancelAll()                      // Cancel all orders

// Account
client.getClosedOnlyMode()              // Check if account is restricted

type Side = "BUY" | "SELL";
type OrderType = "GTC" | "GTD" | "FOK";  // Good-Til-Cancel, Good-Til-Date, Fill-Or-Kill
type OrderStatus = "OPEN" | "MATCHED" | "FILLED" | "CANCELLED" | "EXPIRED";

const client = new ClobTradingClient(walletClient, {
  baseUrl: "https://clob.polymarket.com",  // default
  requestTimeoutMs: 15000,
  maxRetries: 3,
});

// For Magic/Email wallets
const client = new ClobTradingClient(walletClient, {
  signatureType: 1,  // POLY_PROXY
  funderAddress: "0x...",  // Your Polymarket profile address
});

import { OrderValidationError, ClobHttpError } from "@varla/polymarket";

try {
  await client.createAndPostOrder(params, options, "GTC");
} catch (error) {
  if (error instanceof OrderValidationError) {
    console.error("Invalid order:", error.message);
  } else if (error instanceof ClobHttpError) {
    if (error.status === 401) {
      // API key expired, reinitialize
      await client.init();
    }
  }
}

import { 
  validateOrderParams, 
  roundToTickSize,
  isValidPrice,
  getMinimumOrderSize,
} from "@varla/polymarket";

// Validate before creating
validateOrderParams(params, options); // throws OrderValidationError

// Round to valid tick
const price = roundToTickSize(0.505, "0.01"); // 0.51

// Check price validity
isValidPrice(0.505, "0.01"); // false

// Get minimum shares for $1 order
getMinimumOrderSize(0.5); // 2 shares