@alango/dr-manhattan 0.1.0

package/dist/index.js

@@ -0,0 +1,2537 @@
+import { EventEmitter } from 'events';
+import WebSocket from 'ws';
+import { Wallet } from 'ethers';
+import 'socket.io-client';
+import { ClobClient, Side, AssetType } from '@polymarket/clob-client';
+import pino from 'pino';
+
+// src/types/order.ts
+var OrderSide = {
+  BUY: "buy",
+  SELL: "sell"
+};
+var OrderStatus = {
+  PENDING: "pending",
+  OPEN: "open",
+  FILLED: "filled",
+  PARTIALLY_FILLED: "partially_filled",
+  CANCELLED: "cancelled",
+  REJECTED: "rejected"
+};
+var OrderUtils = {
+  /** Get remaining unfilled amount */
+  remaining(order) {
+    return order.size - order.filled;
+  },
+  /** Check if order is still active */
+  isActive(order) {
+    return order.status === OrderStatus.OPEN || order.status === OrderStatus.PARTIALLY_FILLED;
+  },
+  /** Check if order is completely filled */
+  isFilled(order) {
+    return order.status === OrderStatus.FILLED || order.filled >= order.size;
+  },
+  /** Get fill percentage (0-1) */
+  fillPercentage(order) {
+    if (order.size === 0) return 0;
+    return order.filled / order.size;
+  }
+};
+
+// src/types/market.ts
+var MarketUtils = {
+  /** Check if market is binary (Yes/No) */
+  isBinary(market) {
+    return market.outcomes.length === 2;
+  },
+  /** Check if market is still open for trading */
+  isOpen(market) {
+    if ("closed" in market.metadata && market.metadata.closed) {
+      return false;
+    }
+    if (!market.closeTime) return true;
+    return /* @__PURE__ */ new Date() < market.closeTime;
+  },
+  /** Get bid-ask spread for binary markets */
+  spread(market) {
+    if (!MarketUtils.isBinary(market) || market.outcomes.length !== 2) {
+      return null;
+    }
+    const prices = Object.values(market.prices);
+    if (prices.length !== 2) return null;
+    return Math.abs(1 - prices.reduce((a, b) => a + b, 0));
+  },
+  /** Get token IDs from market metadata */
+  getTokenIds(market) {
+    const tokenIds = market.metadata.clobTokenIds;
+    if (!tokenIds) return [];
+    if (typeof tokenIds === "string") {
+      try {
+        return JSON.parse(tokenIds);
+      } catch {
+        return [];
+      }
+    }
+    if (Array.isArray(tokenIds)) {
+      return tokenIds.map(String);
+    }
+    return [];
+  },
+  /** Create OutcomeToken array from market */
+  getOutcomeTokens(market) {
+    const tokenIds = MarketUtils.getTokenIds(market);
+    return market.outcomes.map((outcome, i) => ({
+      outcome,
+      tokenId: tokenIds[i] ?? ""
+    }));
+  }
+};
+
+// src/types/position.ts
+var PositionUtils = {
+  /** Get total cost basis */
+  costBasis(position) {
+    return position.size * position.averagePrice;
+  },
+  /** Get current market value */
+  currentValue(position) {
+    return position.size * position.currentPrice;
+  },
+  /** Get unrealized profit/loss */
+  unrealizedPnl(position) {
+    return PositionUtils.currentValue(position) - PositionUtils.costBasis(position);
+  },
+  /** Get unrealized P&L as percentage */
+  unrealizedPnlPercent(position) {
+    const costBasis = PositionUtils.costBasis(position);
+    if (costBasis === 0) return 0;
+    return PositionUtils.unrealizedPnl(position) / costBasis * 100;
+  }
+};
+function calculateDelta(positions) {
+  const entries = Object.entries(positions);
+  if (entries.length === 0) {
+    return { delta: 0, maxOutcome: null, maxPosition: 0 };
+  }
+  let maxOutcome = null;
+  let maxPosition = 0;
+  for (const [outcome, size] of entries) {
+    if (size > maxPosition) {
+      maxPosition = size;
+      maxOutcome = outcome;
+    }
+  }
+  if (entries.length === 2) {
+    const [first, second] = entries;
+    if (first && second) {
+      const delta = Math.abs(first[1] - second[1]);
+      return { delta, maxOutcome, maxPosition };
+    }
+  }
+  return { delta: maxPosition, maxOutcome, maxPosition };
+}
+
+// src/types/orderbook.ts
+var OrderbookUtils = {
+  /** Get best bid price */
+  bestBid(orderbook) {
+    return orderbook.bids[0]?.[0] ?? null;
+  },
+  /** Get best ask price */
+  bestAsk(orderbook) {
+    return orderbook.asks[0]?.[0] ?? null;
+  },
+  /** Get mid price */
+  midPrice(orderbook) {
+    const bid = OrderbookUtils.bestBid(orderbook);
+    const ask = OrderbookUtils.bestAsk(orderbook);
+    if (bid === null || ask === null) return null;
+    return (bid + ask) / 2;
+  },
+  /** Get bid-ask spread */
+  spread(orderbook) {
+    const bid = OrderbookUtils.bestBid(orderbook);
+    const ask = OrderbookUtils.bestAsk(orderbook);
+    if (bid === null || ask === null) return null;
+    return ask - bid;
+  },
+  /** Create orderbook from REST API response */
+  fromRestResponse(data, tokenId = "") {
+    const bids = [];
+    const asks = [];
+    for (const bid of data.bids ?? []) {
+      const price = Number.parseFloat(bid.price);
+      const size = Number.parseFloat(bid.size);
+      if (price > 0 && size > 0) {
+        bids.push([price, size]);
+      }
+    }
+    for (const ask of data.asks ?? []) {
+      const price = Number.parseFloat(ask.price);
+      const size = Number.parseFloat(ask.size);
+      if (price > 0 && size > 0) {
+        asks.push([price, size]);
+      }
+    }
+    bids.sort((a, b) => b[0] - a[0]);
+    asks.sort((a, b) => a[0] - b[0]);
+    return {
+      bids,
+      asks,
+      timestamp: Date.now(),
+      assetId: tokenId,
+      marketId: ""
+    };
+  }
+};
+var OrderbookManager = class {
+  orderbooks = /* @__PURE__ */ new Map();
+  /** Update orderbook for a token */
+  update(tokenId, orderbook) {
+    this.orderbooks.set(tokenId, orderbook);
+  }
+  /** Get orderbook for a token */
+  get(tokenId) {
+    return this.orderbooks.get(tokenId);
+  }
+  /** Get best bid and ask for a token */
+  getBestBidAsk(tokenId) {
+    const orderbook = this.get(tokenId);
+    if (!orderbook) return [null, null];
+    return [OrderbookUtils.bestBid(orderbook), OrderbookUtils.bestAsk(orderbook)];
+  }
+  /** Check if we have data for a token */
+  hasData(tokenId) {
+    const orderbook = this.get(tokenId);
+    if (!orderbook) return false;
+    return orderbook.bids.length > 0 && orderbook.asks.length > 0;
+  }
+  /** Check if we have data for all tokens */
+  hasAllData(tokenIds) {
+    return tokenIds.every((id) => this.hasData(id));
+  }
+  /** Clear all orderbooks */
+  clear() {
+    this.orderbooks.clear();
+  }
+};
+
+// src/types/crypto-hourly.ts
+var TOKEN_ALIASES = {
+  BITCOIN: "BTC",
+  ETHEREUM: "ETH",
+  SOLANA: "SOL"
+};
+function normalizeTokenSymbol(token) {
+  const upper = token.toUpperCase();
+  return TOKEN_ALIASES[upper] ?? upper;
+}
+
+// src/errors/index.ts
+var DrManhattanError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DrManhattanError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ExchangeError = class extends DrManhattanError {
+  constructor(message) {
+    super(message);
+    this.name = "ExchangeError";
+  }
+};
+var NetworkError = class extends DrManhattanError {
+  constructor(message) {
+    super(message);
+    this.name = "NetworkError";
+  }
+};
+var RateLimitError = class extends DrManhattanError {
+  retryAfter;
+  constructor(message, retryAfter) {
+    super(message);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var AuthenticationError = class extends DrManhattanError {
+  constructor(message) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var InsufficientFunds = class extends DrManhattanError {
+  constructor(message) {
+    super(message);
+    this.name = "InsufficientFunds";
+  }
+};
+var InvalidOrder = class extends DrManhattanError {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidOrder";
+  }
+};
+var MarketNotFound = class extends DrManhattanError {
+  constructor(message) {
+    super(message);
+    this.name = "MarketNotFound";
+  }
+};
+
+// src/core/exchange.ts
+var Exchange = class {
+  config;
+  requestTimes = [];
+  lastRequestTime = 0;
+  constructor(config = {}) {
+    this.config = {
+      timeout: 3e4,
+      verbose: false,
+      rateLimit: 10,
+      maxRetries: 3,
+      retryDelay: 1e3,
+      retryBackoff: 2,
+      ...config
+    };
+  }
+  get verbose() {
+    return this.config.verbose ?? false;
+  }
+  get timeout() {
+    return this.config.timeout ?? 3e4;
+  }
+  describe() {
+    return {
+      id: this.id,
+      name: this.name,
+      has: {
+        fetchMarkets: true,
+        fetchMarket: true,
+        createOrder: true,
+        cancelOrder: true,
+        fetchOrder: true,
+        fetchOpenOrders: true,
+        fetchPositions: true,
+        fetchBalance: true,
+        websocket: false
+      }
+    };
+  }
+  checkRateLimit() {
+    const currentTime = Date.now();
+    const rateLimit = this.config.rateLimit ?? 10;
+    this.requestTimes = this.requestTimes.filter((t) => currentTime - t < 1e3);
+    if (this.requestTimes.length >= rateLimit) {
+      const oldestRequest = this.requestTimes[0];
+      if (oldestRequest) {
+        const sleepTime = 1e3 - (currentTime - oldestRequest);
+        if (sleepTime > 0) {
+          throw new RateLimitError(`Rate limit reached, wait ${sleepTime}ms`, sleepTime);
+        }
+      }
+    }
+    this.requestTimes.push(currentTime);
+  }
+  async withRetry(fn) {
+    const maxRetries = this.config.maxRetries ?? 3;
+    const retryDelay = this.config.retryDelay ?? 1e3;
+    const retryBackoff = this.config.retryBackoff ?? 2;
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        this.checkRateLimit();
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        if (error instanceof NetworkError || error instanceof RateLimitError) {
+          if (attempt < maxRetries) {
+            const delay = retryDelay * retryBackoff ** attempt + Math.random() * 1e3;
+            if (this.verbose) {
+              console.log(
+                `Attempt ${attempt + 1} failed, retrying in ${delay.toFixed(0)}ms: ${error.message}`
+              );
+            }
+            await this.sleep(delay);
+            continue;
+          }
+        }
+        throw error;
+      }
+    }
+    throw lastError;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  parseDateTime(timestamp) {
+    if (!timestamp) return void 0;
+    if (timestamp instanceof Date) return timestamp;
+    if (typeof timestamp === "number") return new Date(timestamp);
+    if (typeof timestamp === "string") {
+      const parsed = new Date(timestamp);
+      return Number.isNaN(parsed.getTime()) ? void 0 : parsed;
+    }
+    return void 0;
+  }
+  async findTradeableMarket(options = {}) {
+    const { binary = true, limit = 100, minLiquidity = 0 } = options;
+    const markets = await this.fetchMarkets({ limit });
+    const suitable = [];
+    for (const market of markets) {
+      if (binary && !MarketUtils.isBinary(market)) continue;
+      if (!MarketUtils.isOpen(market)) continue;
+      if (market.liquidity < minLiquidity) continue;
+      const tokenIds = MarketUtils.getTokenIds(market);
+      if (tokenIds.length === 0) continue;
+      suitable.push(market);
+    }
+    if (suitable.length === 0) return null;
+    const randomIndex = Math.floor(Math.random() * suitable.length);
+    return suitable[randomIndex] ?? null;
+  }
+  calculateSpread(market) {
+    return MarketUtils.spread(market);
+  }
+  calculateImpliedProbability(price) {
+    return Math.max(0, Math.min(1, price));
+  }
+  calculateExpectedValue(market, outcome, price) {
+    if (!MarketUtils.isBinary(market)) return 0;
+    const probability = this.calculateImpliedProbability(price);
+    const payoff = outcome === market.outcomes[0] ? 1 : 0;
+    const cost = price;
+    return probability * payoff - cost;
+  }
+  getOptimalOrderSize(market, maxPositionSize) {
+    const liquidityBasedSize = market.liquidity * 0.1;
+    return Math.min(maxPositionSize, liquidityBasedSize);
+  }
+};
+var WebSocketState = {
+  DISCONNECTED: "disconnected",
+  CONNECTING: "connecting",
+  CONNECTED: "connected",
+  RECONNECTING: "reconnecting",
+  CLOSED: "closed"
+};
+var OrderBookWebSocket = class extends EventEmitter {
+  config;
+  ws = null;
+  state = WebSocketState.DISCONNECTED;
+  reconnectAttempts = 0;
+  subscriptions = /* @__PURE__ */ new Map();
+  pingTimer = null;
+  lastMessageTime = 0;
+  constructor(config = {}) {
+    super();
+    this.config = {
+      verbose: false,
+      autoReconnect: true,
+      maxReconnectAttempts: 999,
+      reconnectDelay: 3e3,
+      pingInterval: 2e4,
+      pingTimeout: 1e4,
+      ...config
+    };
+  }
+  get isConnected() {
+    return this.state === WebSocketState.CONNECTED;
+  }
+  async connect() {
+    if (this.state === WebSocketState.CONNECTED) return;
+    this.state = WebSocketState.CONNECTING;
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.wsUrl);
+      this.ws.on("open", async () => {
+        this.state = WebSocketState.CONNECTED;
+        this.reconnectAttempts = 0;
+        this.lastMessageTime = Date.now();
+        if (this.config.verbose) {
+          console.log(`WebSocket connected to ${this.wsUrl}`);
+        }
+        try {
+          await this.authenticate();
+          for (const marketId of this.subscriptions.keys()) {
+            await this.subscribeOrderbook(marketId);
+          }
+          this.startPingTimer();
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
+      this.ws.on("message", (data) => this.handleMessage(data));
+      this.ws.on("error", (error) => this.handleError(error));
+      this.ws.on("close", () => this.handleClose());
+    });
+  }
+  async disconnect() {
+    this.state = WebSocketState.CLOSED;
+    this.config.autoReconnect = false;
+    this.stopPingTimer();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  async watchOrderbook(marketId, callback) {
+    this.subscriptions.set(marketId, callback);
+    if (this.state !== WebSocketState.CONNECTED) {
+      await this.connect();
+    }
+    await this.subscribeOrderbook(marketId);
+  }
+  async unwatchOrderbook(marketId) {
+    if (!this.subscriptions.has(marketId)) return;
+    this.subscriptions.delete(marketId);
+    if (this.state === WebSocketState.CONNECTED) {
+      await this.unsubscribeOrderbook(marketId);
+    }
+  }
+  handleMessage(data) {
+    this.lastMessageTime = Date.now();
+    try {
+      const message = data.toString();
+      if (message === "PONG" || message === "PING" || message === "") return;
+      const parsed = JSON.parse(message);
+      const orderbook = this.parseOrderbookMessage(parsed);
+      if (orderbook) {
+        const callback = this.subscriptions.get(orderbook.marketId);
+        if (callback) {
+          Promise.resolve(callback(orderbook.marketId, orderbook)).catch((error) => {
+            if (this.config.verbose) {
+              console.error("Orderbook callback error:", error);
+            }
+          });
+        }
+      }
+    } catch (error) {
+      if (this.config.verbose) {
+        console.error("Failed to parse WebSocket message:", error);
+      }
+    }
+  }
+  handleError(error) {
+    if (this.config.verbose) {
+      console.error("WebSocket error:", error);
+    }
+    this.emit("error", error);
+  }
+  handleClose() {
+    this.stopPingTimer();
+    if (this.config.verbose) {
+      console.log("WebSocket connection closed");
+    }
+    if (this.config.autoReconnect && this.state !== WebSocketState.CLOSED) {
+      this.reconnect();
+    }
+  }
+  async reconnect() {
+    const maxAttempts = this.config.maxReconnectAttempts ?? 999;
+    if (this.reconnectAttempts >= maxAttempts) {
+      this.state = WebSocketState.CLOSED;
+      return;
+    }
+    this.state = WebSocketState.RECONNECTING;
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      6e4,
+      (this.config.reconnectDelay ?? 3e3) * 1.5 ** (this.reconnectAttempts - 1)
+    );
+    if (this.config.verbose) {
+      console.log(`Reconnecting in ${delay.toFixed(0)}ms (attempt ${this.reconnectAttempts})`);
+    }
+    await this.sleep(delay);
+    try {
+      await this.connect();
+    } catch {
+      const currentState = this.state;
+      if (this.config.autoReconnect && currentState !== WebSocketState.CLOSED) {
+        this.reconnect();
+      }
+    }
+  }
+  startPingTimer() {
+    this.stopPingTimer();
+    const interval = this.config.pingInterval ?? 2e4;
+    this.pingTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.ping();
+      }
+    }, interval);
+  }
+  stopPingTimer() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  send(data) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    }
+  }
+};
+var StrategyState = {
+  STOPPED: "stopped",
+  RUNNING: "running",
+  PAUSED: "paused"
+};
+var Strategy = class extends EventEmitter {
+  exchange;
+  marketId;
+  market = null;
+  state = StrategyState.STOPPED;
+  config;
+  tickTimer = null;
+  positions = [];
+  openOrders = [];
+  constructor(exchange, marketId, config = {}) {
+    super();
+    this.exchange = exchange;
+    this.marketId = marketId;
+    this.config = {
+      tickInterval: 1e3,
+      maxPositionSize: 100,
+      spreadBps: 100,
+      verbose: false,
+      ...config
+    };
+  }
+  async start() {
+    if (this.state === StrategyState.RUNNING) return;
+    this.market = await this.exchange.fetchMarket(this.marketId);
+    this.state = StrategyState.RUNNING;
+    this.tickTimer = setInterval(async () => {
+      if (this.state !== StrategyState.RUNNING) return;
+      try {
+        await this.refreshState();
+        await this.onTick();
+      } catch (error) {
+        this.emit("error", error);
+        if (this.config.verbose) {
+          console.error("Strategy tick error:", error);
+        }
+      }
+    }, this.config.tickInterval);
+    this.emit("started");
+  }
+  async stop() {
+    if (this.state === StrategyState.STOPPED) return;
+    this.state = StrategyState.STOPPED;
+    if (this.tickTimer) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    await this.cancelAllOrders();
+    this.emit("stopped");
+  }
+  pause() {
+    if (this.state === StrategyState.RUNNING) {
+      this.state = StrategyState.PAUSED;
+      this.emit("paused");
+    }
+  }
+  resume() {
+    if (this.state === StrategyState.PAUSED) {
+      this.state = StrategyState.RUNNING;
+      this.emit("resumed");
+    }
+  }
+  async refreshState() {
+    const [positions, orders] = await Promise.all([
+      this.exchange.fetchPositions(this.marketId),
+      this.exchange.fetchOpenOrders(this.marketId)
+    ]);
+    this.positions = positions;
+    this.openOrders = orders;
+  }
+  async cancelAllOrders() {
+    for (const order of this.openOrders) {
+      try {
+        await this.exchange.cancelOrder(order.id, this.marketId);
+      } catch {
+      }
+    }
+    this.openOrders = [];
+  }
+  getPosition(outcome) {
+    return this.positions.find((p) => p.outcome === outcome);
+  }
+  getNetPosition() {
+    if (!this.market || this.market.outcomes.length !== 2) return 0;
+    const outcome1 = this.market.outcomes[0];
+    const outcome2 = this.market.outcomes[1];
+    if (!outcome1 || !outcome2) return 0;
+    const pos1 = this.getPosition(outcome1)?.size ?? 0;
+    const pos2 = this.getPosition(outcome2)?.size ?? 0;
+    return pos1 - pos2;
+  }
+  async placeOrder(outcome, side, price, size, tokenId) {
+    try {
+      const order = await this.exchange.createOrder({
+        marketId: this.marketId,
+        outcome,
+        side,
+        price,
+        size,
+        tokenId
+      });
+      this.openOrders.push(order);
+      this.emit("order", order);
+      return order;
+    } catch (error) {
+      this.emit("error", error);
+      return null;
+    }
+  }
+  log(message) {
+    if (this.config.verbose) {
+      console.log(`[${this.exchange.id}:${this.marketId}] ${message}`);
+    }
+  }
+  get isRunning() {
+    return this.state === StrategyState.RUNNING;
+  }
+  get currentState() {
+    return this.state;
+  }
+};
+
+// src/exchanges/limitless/index.ts
+var BASE_URL = "https://api.limitless.exchange";
+var CHAIN_ID = 8453;
+var Limitless = class extends Exchange {
+  id = "limitless";
+  name = "Limitless";
+  host;
+  chainId;
+  wallet = null;
+  address = null;
+  authenticated = false;
+  ownerId = null;
+  sessionCookie = null;
+  tokenToSlug = /* @__PURE__ */ new Map();
+  noTokens = /* @__PURE__ */ new Set();
+  constructor(config = {}) {
+    super(config);
+    this.host = config.host ?? BASE_URL;
+    this.chainId = config.chainId ?? CHAIN_ID;
+    if (config.privateKey) {
+      this.wallet = new Wallet(config.privateKey);
+      this.address = this.wallet.address;
+    }
+  }
+  async authenticate() {
+    if (!this.wallet || !this.address) {
+      throw new AuthenticationError("Private key required for authentication");
+    }
+    const msgResponse = await fetch(`${this.host}/auth/signing-message`, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!msgResponse.ok) {
+      throw new AuthenticationError("Failed to get signing message");
+    }
+    const message = await msgResponse.text();
+    if (!message) {
+      throw new AuthenticationError("Empty signing message");
+    }
+    const signature = await this.wallet.signMessage(message);
+    const messageHex = `0x${Buffer.from(message, "utf-8").toString("hex")}`;
+    const loginResponse = await fetch(`${this.host}/auth/login`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-account": this.address,
+        "x-signing-message": messageHex,
+        "x-signature": signature
+      },
+      body: JSON.stringify({ client: "eoa" })
+    });
+    if (!loginResponse.ok) {
+      throw new AuthenticationError("Login failed");
+    }
+    const setCookie = loginResponse.headers.get("set-cookie");
+    if (setCookie) {
+      const match = /limitless_session=([^;]+)/.exec(setCookie);
+      if (match?.[1]) {
+        this.sessionCookie = match[1];
+      }
+    }
+    const loginData = await loginResponse.json();
+    const userData = loginData.user ?? loginData;
+    this.ownerId = userData.id ?? null;
+    this.authenticated = true;
+  }
+  async ensureAuth() {
+    if (!this.authenticated) {
+      if (!this.wallet) {
+        throw new AuthenticationError("Private key required for this operation");
+      }
+      await this.authenticate();
+    }
+  }
+  async request(method, endpoint, params, requireAuth = false) {
+    if (requireAuth) {
+      await this.ensureAuth();
+    }
+    const url = new URL(`${this.host}${endpoint}`);
+    if (method === "GET" && params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.sessionCookie) {
+      headers.Cookie = `limitless_session=${this.sessionCookie}`;
+    }
+    const fetchOptions = {
+      method,
+      headers
+    };
+    if (method !== "GET" && method !== "DELETE" && params) {
+      fetchOptions.body = JSON.stringify(params);
+    }
+    const response = await fetch(url.toString(), fetchOptions);
+    if (!response.ok) {
+      if (response.status === 429) {
+        throw new NetworkError("Rate limited");
+      }
+      if (response.status === 401 || response.status === 403) {
+        this.authenticated = false;
+        throw new AuthenticationError("Authentication failed");
+      }
+      if (response.status === 404) {
+        throw new ExchangeError(`Resource not found: ${endpoint}`);
+      }
+      throw new NetworkError(`HTTP ${response.status}`);
+    }
+    return response.json();
+  }
+  parseMarket(data) {
+    const slug = data.slug ?? data.address ?? "";
+    const question = data.title ?? data.question ?? "";
+    const tokens = data.tokens ?? {};
+    const yesTokenId = String(tokens.yes ?? "");
+    const noTokenId = String(tokens.no ?? "");
+    const outcomes = ["Yes", "No"];
+    const tokenIds = yesTokenId && noTokenId ? [yesTokenId, noTokenId] : [];
+    const prices = {};
+    if (data.yesPrice !== void 0) {
+      const yesPrice = data.yesPrice ?? 0;
+      const noPrice = data.noPrice ?? 0;
+      prices.Yes = yesPrice > 1 ? yesPrice / 100 : yesPrice;
+      prices.No = noPrice > 1 ? noPrice / 100 : noPrice;
+    } else if (data.prices) {
+      if (Array.isArray(data.prices)) {
+        const yesPrice = data.prices[0] ?? 0;
+        const noPrice = data.prices[1] ?? 0;
+        prices.Yes = yesPrice > 1 ? yesPrice / 100 : yesPrice;
+        prices.No = noPrice > 1 ? noPrice / 100 : noPrice;
+      } else {
+        const yesPrice = data.prices.yes ?? 0;
+        const noPrice = data.prices.no ?? 0;
+        prices.Yes = yesPrice > 1 ? yesPrice / 100 : yesPrice;
+        prices.No = noPrice > 1 ? noPrice / 100 : noPrice;
+      }
+    }
+    let closeTime;
+    const deadline = data.deadline ?? data.closeDate ?? data.expirationDate;
+    if (deadline) {
+      closeTime = this.parseDateTime(deadline);
+    }
+    const volume = data.volumeFormatted ?? data.volume ?? 0;
+    const liquidity = data.liquidityFormatted ?? data.liquidity ?? 0;
+    const tickSize = 1e-3;
+    for (const tokenId of tokenIds) {
+      if (tokenId) {
+        this.tokenToSlug.set(tokenId, slug);
+      }
+    }
+    if (noTokenId) {
+      this.noTokens.add(noTokenId);
+    }
+    const status = data.status ?? "";
+    const closed = status.toLowerCase() === "resolved" || status.toLowerCase() === "closed";
+    const metadata = {
+      ...data,
+      slug,
+      clobTokenIds: tokenIds,
+      token_ids: tokenIds,
+      tokens: { Yes: yesTokenId, No: noTokenId },
+      minimum_tick_size: tickSize,
+      closed
+    };
+    return {
+      id: slug,
+      question,
+      outcomes,
+      closeTime,
+      volume,
+      liquidity,
+      prices,
+      tickSize,
+      description: data.description ?? "",
+      metadata
+    };
+  }
+  parseOrder(data, tokenToOutcome) {
+    const orderId = String(data.id ?? data.orderId ?? "");
+    const marketId = data.marketSlug ?? data.market_id ?? "";
+    let side;
+    if (typeof data.side === "number") {
+      side = data.side === 0 ? OrderSide.BUY : OrderSide.SELL;
+    } else {
+      side = String(data.side).toLowerCase() === "buy" ? OrderSide.BUY : OrderSide.SELL;
+    }
+    const status = this.parseOrderStatus(data.status);
+    const price = data.price ?? 0;
+    let size = data.size ?? data.amount ?? 0;
+    if (!size) {
+      const makerAmount = data.makerAmount ?? 0;
+      const takerAmount = data.takerAmount ?? 0;
+      if (makerAmount || takerAmount) {
+        size = side === OrderSide.BUY ? takerAmount / 1e6 : makerAmount / 1e6;
+      }
+    }
+    const filled = data.filled ?? data.matchedAmount ?? 0;
+    let createdAt = /* @__PURE__ */ new Date();
+    if (data.createdAt) {
+      const parsed = this.parseDateTime(data.createdAt);
+      if (parsed) createdAt = parsed;
+    }
+    let outcome = data.outcome ?? "";
+    if (!outcome && tokenToOutcome) {
+      const tokenId = String(data.token ?? data.tokenId ?? "");
+      outcome = tokenToOutcome.get(tokenId) ?? "";
+    }
+    return {
+      id: orderId,
+      marketId,
+      outcome,
+      side,
+      price,
+      size,
+      filled,
+      status,
+      createdAt
+    };
+  }
+  parseOrderStatus(status) {
+    if (!status) return OrderStatus.OPEN;
+    const statusStr = String(status).toLowerCase();
+    const statusMap = {
+      pending: OrderStatus.PENDING,
+      open: OrderStatus.OPEN,
+      live: OrderStatus.OPEN,
+      active: OrderStatus.OPEN,
+      filled: OrderStatus.FILLED,
+      matched: OrderStatus.FILLED,
+      partially_filled: OrderStatus.PARTIALLY_FILLED,
+      partial: OrderStatus.PARTIALLY_FILLED,
+      cancelled: OrderStatus.CANCELLED,
+      canceled: OrderStatus.CANCELLED
+    };
+    return statusMap[statusStr] ?? OrderStatus.OPEN;
+  }
+  parsePortfolioPositions(data) {
+    const positions = [];
+    const marketData = data.market ?? {};
+    const marketId = marketData.slug ?? data.marketSlug ?? "";
+    const tokensBalance = data.tokensBalance ?? {};
+    const positionDetails = data.positions ?? {};
+    const latestTrade = data.latestTrade ?? {};
+    const yesBalance = Number(tokensBalance.yes ?? 0);
+    if (yesBalance > 0) {
+      const yesDetails = positionDetails.yes ?? {};
+      const fillPrice = yesDetails.fillPrice ?? 0;
+      const avgPrice = fillPrice > 1 ? fillPrice / 1e6 : fillPrice;
+      const currentPrice = latestTrade.latestYesPrice ?? 0;
+      const size = yesBalance / 1e6;
+      positions.push({
+        marketId,
+        outcome: "Yes",
+        size,
+        averagePrice: avgPrice,
+        currentPrice
+      });
+    }
+    const noBalance = Number(tokensBalance.no ?? 0);
+    if (noBalance > 0) {
+      const noDetails = positionDetails.no ?? {};
+      const fillPrice = noDetails.fillPrice ?? 0;
+      const avgPrice = fillPrice > 1 ? fillPrice / 1e6 : fillPrice;
+      const currentPrice = latestTrade.latestNoPrice ?? 0;
+      const size = noBalance / 1e6;
+      positions.push({
+        marketId,
+        outcome: "No",
+        size,
+        averagePrice: avgPrice,
+        currentPrice
+      });
+    }
+    return positions;
+  }
+  async fetchMarkets(params) {
+    return this.withRetry(async () => {
+      const queryParams = {
+        page: params?.offset ? Math.floor(params.offset / 25) + 1 : 1,
+        limit: Math.min(params?.limit ?? 25, 25)
+      };
+      const response = await this.request(
+        "GET",
+        "/markets/active",
+        queryParams
+      );
+      const marketsData = Array.isArray(response) ? response : response.data ?? [];
+      let markets = marketsData.map((m) => this.parseMarket(m));
+      if (params?.active !== false) {
+        markets = markets.filter((m) => !m.metadata?.closed);
+      }
+      if (params?.limit) {
+        return markets.slice(0, params.limit);
+      }
+      return markets;
+    });
+  }
+  async fetchMarket(marketId) {
+    return this.withRetry(async () => {
+      try {
+        const data = await this.request("GET", `/markets/${marketId}`);
+        return this.parseMarket(data);
+      } catch (error) {
+        if (error instanceof ExchangeError && error.message.includes("not found")) {
+          throw new MarketNotFound(`Market ${marketId} not found`);
+        }
+        throw error;
+      }
+    });
+  }
+  async getOrderbook(marketSlugOrTokenId) {
+    const isNoToken = this.noTokens.has(marketSlugOrTokenId);
+    const slug = this.tokenToSlug.get(marketSlugOrTokenId) ?? marketSlugOrTokenId;
+    return this.withRetry(async () => {
+      const response = await this.request("GET", `/markets/${slug}/orderbook`);
+      const bids = [];
+      const asks = [];
+      const orders = response.orders ?? response.data ?? [];
+      for (const order of orders) {
+        const side = String(order.side ?? "").toLowerCase();
+        const price = Number(order.price ?? 0);
+        const size = Number(order.size ?? 0);
+        if (price > 0 && size > 0) {
+          const entry = { price: String(price), size: String(size) };
+          if (side === "buy") {
+            bids.push(entry);
+          } else {
+            asks.push(entry);
+          }
+        }
+      }
+      if (response.bids) {
+        for (const bid of response.bids) {
+          bids.push({
+            price: String(bid.price ?? 0),
+            size: String(bid.size ?? 0)
+          });
+        }
+      }
+      if (response.asks) {
+        for (const ask of response.asks) {
+          asks.push({
+            price: String(ask.price ?? 0),
+            size: String(ask.size ?? 0)
+          });
+        }
+      }
+      bids.sort((a, b) => Number(b.price) - Number(a.price));
+      asks.sort((a, b) => Number(a.price) - Number(b.price));
+      if (isNoToken) {
+        const invertedBids = asks.map((a) => ({
+          price: String(Math.round((1 - Number(a.price)) * 1e3) / 1e3),
+          size: a.size
+        }));
+        const invertedAsks = bids.map((b) => ({
+          price: String(Math.round((1 - Number(b.price)) * 1e3) / 1e3),
+          size: b.size
+        }));
+        invertedBids.sort((a, b) => Number(b.price) - Number(a.price));
+        invertedAsks.sort((a, b) => Number(a.price) - Number(b.price));
+        return { bids: invertedBids, asks: invertedAsks };
+      }
+      return { bids, asks };
+    });
+  }
+  async createOrder(params) {
+    await this.ensureAuth();
+    if (!this.wallet || !this.address) {
+      throw new AuthenticationError("Wallet not initialized");
+    }
+    const market = await this.fetchMarket(params.marketId);
+    const tokens = market.metadata?.tokens ?? {};
+    const tokenId = params.tokenId ?? tokens[params.outcome];
+    if (!tokenId) {
+      throw new InvalidOrder(`Could not find token_id for outcome '${params.outcome}'`);
+    }
+    if (params.price <= 0 || params.price >= 1) {
+      throw new InvalidOrder(`Price must be between 0 and 1, got: ${params.price}`);
+    }
+    const venue = market.metadata?.venue;
+    const exchangeAddress = venue?.exchange;
+    if (!exchangeAddress) {
+      throw new InvalidOrder("Market does not have venue.exchange address");
+    }
+    const orderType = params.params?.order_type?.toUpperCase() ?? "GTC";
+    const feeRateBps = 300;
+    const signedOrder = await this.buildSignedOrder(
+      tokenId,
+      params.price,
+      params.size,
+      params.side,
+      orderType,
+      exchangeAddress,
+      feeRateBps
+    );
+    const payload = {
+      order: signedOrder,
+      orderType,
+      marketSlug: params.marketId
+    };
+    if (this.ownerId) {
+      payload.ownerId = this.ownerId;
+    }
+    return this.withRetry(async () => {
+      const result = await this.request(
+        "POST",
+        "/orders",
+        payload,
+        true
+      );
+      const orderData = result.order ?? result;
+      const orderId = orderData.id ?? orderData.orderId ?? "";
+      const statusStr = orderData.status ?? "LIVE";
+      return {
+        id: String(orderId),
+        marketId: params.marketId,
+        outcome: params.outcome,
+        side: params.side,
+        price: params.price,
+        size: params.size,
+        filled: Number(orderData.filled ?? 0),
+        status: this.parseOrderStatus(statusStr),
+        createdAt: /* @__PURE__ */ new Date()
+      };
+    });
+  }
+  async buildSignedOrder(tokenId, price, size, side, orderType, exchangeAddress, feeRateBps) {
+    if (!this.wallet || !this.address) {
+      throw new AuthenticationError("Wallet not initialized");
+    }
+    const timestampMs = Date.now();
+    const nanoOffset = Math.floor(Math.random() * 1e6);
+    const oneDayMs = 1e3 * 60 * 60 * 24;
+    const salt = timestampMs * 1e3 + nanoOffset + oneDayMs;
+    const sharesScale = 1e6;
+    const collateralScale = 1e6;
+    const priceScale = 1e6;
+    const priceTick = 1e-3;
+    let shares = Math.floor(size * sharesScale);
+    const priceInt = Math.floor(price * priceScale);
+    const tickInt = Math.floor(priceTick * priceScale);
+    const sharesStep = Math.floor(priceScale / tickInt);
+    if (shares % sharesStep !== 0) {
+      shares = Math.floor(shares / sharesStep) * sharesStep;
+    }
+    const numerator = shares * priceInt * collateralScale;
+    const denominator = sharesScale * priceScale;
+    const sideInt = side === OrderSide.BUY ? 0 : 1;
+    let makerAmount;
+    let takerAmount;
+    if (side === OrderSide.BUY) {
+      const collateral = Math.ceil(numerator / denominator);
+      makerAmount = collateral;
+      takerAmount = shares;
+    } else {
+      const collateral = Math.floor(numerator / denominator);
+      makerAmount = shares;
+      takerAmount = collateral;
+    }
+    const orderForSigning = {
+      salt,
+      maker: this.address,
+      signer: this.address,
+      taker: "0x0000000000000000000000000000000000000000",
+      tokenId: Number.parseInt(tokenId, 10),
+      makerAmount,
+      takerAmount,
+      expiration: 0,
+      nonce: 0,
+      feeRateBps,
+      side: sideInt,
+      signatureType: 0
+    };
+    const signature = await this.signOrderEip712(orderForSigning, exchangeAddress);
+    const order = {
+      salt,
+      maker: this.address,
+      signer: this.address,
+      taker: "0x0000000000000000000000000000000000000000",
+      tokenId,
+      makerAmount,
+      takerAmount,
+      expiration: "0",
+      nonce: 0,
+      feeRateBps,
+      side: sideInt,
+      signatureType: 0,
+      signature
+    };
+    if (orderType === "GTC") {
+      order.price = Math.round(price * 1e3) / 1e3;
+    }
+    return order;
+  }
+  async signOrderEip712(order, exchangeAddress) {
+    if (!this.wallet) {
+      throw new AuthenticationError("Wallet not initialized");
+    }
+    const domain = {
+      name: "Limitless CTF Exchange",
+      version: "1",
+      chainId: this.chainId,
+      verifyingContract: exchangeAddress
+    };
+    const types = {
+      Order: [
+        { name: "salt", type: "uint256" },
+        { name: "maker", type: "address" },
+        { name: "signer", type: "address" },
+        { name: "taker", type: "address" },
+        { name: "tokenId", type: "uint256" },
+        { name: "makerAmount", type: "uint256" },
+        { name: "takerAmount", type: "uint256" },
+        { name: "expiration", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "feeRateBps", type: "uint256" },
+        { name: "side", type: "uint8" },
+        { name: "signatureType", type: "uint8" }
+      ]
+    };
+    const value = {
+      salt: order.salt,
+      maker: order.maker,
+      signer: order.signer,
+      taker: order.taker,
+      tokenId: order.tokenId,
+      makerAmount: order.makerAmount,
+      takerAmount: order.takerAmount,
+      expiration: order.expiration,
+      nonce: order.nonce,
+      feeRateBps: order.feeRateBps,
+      side: order.side,
+      signatureType: order.signatureType
+    };
+    const signature = await this.wallet._signTypedData(domain, types, value);
+    return signature;
+  }
+  async cancelOrder(orderId, marketId) {
+    await this.ensureAuth();
+    return this.withRetry(async () => {
+      await this.request("DELETE", `/orders/${orderId}`, void 0, true);
+      return {
+        id: orderId,
+        marketId: marketId ?? "",
+        outcome: "",
+        side: OrderSide.BUY,
+        price: 0,
+        size: 0,
+        filled: 0,
+        status: OrderStatus.CANCELLED,
+        createdAt: /* @__PURE__ */ new Date()
+      };
+    });
+  }
+  async fetchOrder(orderId, _marketId) {
+    await this.ensureAuth();
+    return this.withRetry(async () => {
+      const data = await this.request("GET", `/orders/${orderId}`, void 0, true);
+      return this.parseOrder(data);
+    });
+  }
+  async fetchOpenOrders(marketId) {
+    await this.ensureAuth();
+    const queryParams = { statuses: "LIVE" };
+    let endpoint;
+    if (marketId) {
+      endpoint = `/markets/${marketId}/user-orders`;
+    } else {
+      endpoint = "/orders";
+    }
+    let tokenToOutcome;
+    if (marketId) {
+      try {
+        const market = await this.fetchMarket(marketId);
+        const tokens = market.metadata?.tokens ?? {};
+        tokenToOutcome = /* @__PURE__ */ new Map();
+        for (const [outcome, tokenId] of Object.entries(tokens)) {
+          if (tokenId) {
+            tokenToOutcome.set(tokenId, outcome);
+          }
+        }
+      } catch {
+        tokenToOutcome = void 0;
+      }
+    }
+    return this.withRetry(async () => {
+      const response = await this.request(
+        "GET",
+        endpoint,
+        queryParams,
+        true
+      );
+      const ordersData = Array.isArray(response) ? response : response.data ?? [];
+      return ordersData.map((o) => this.parseOrder(o, tokenToOutcome));
+    });
+  }
+  async fetchPositions(marketId) {
+    await this.ensureAuth();
+    return this.withRetry(async () => {
+      const response = await this.request(
+        "GET",
+        "/portfolio/positions",
+        void 0,
+        true
+      );
+      const clobPositions = response.clob ?? [];
+      const positions = [];
+      for (const posData of clobPositions) {
+        const parsed = this.parsePortfolioPositions(posData);
+        for (const pos of parsed) {
+          if (marketId && pos.marketId !== marketId) {
+            continue;
+          }
+          positions.push(pos);
+        }
+      }
+      return positions;
+    });
+  }
+  async fetchBalance() {
+    await this.ensureAuth();
+    if (!this.address) {
+      throw new AuthenticationError("Wallet address not available");
+    }
+    const usdcAddress = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+    const baseRpc = "https://mainnet.base.org";
+    try {
+      const data = `0x70a08231000000000000000000000000${this.address.slice(2).toLowerCase()}`;
+      const response = await fetch(baseRpc, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          method: "eth_call",
+          params: [{ to: usdcAddress, data }, "latest"],
+          id: 1
+        })
+      });
+      const result = await response.json();
+      const balanceHex = result.result ?? "0x0";
+      const balanceWei = Number.parseInt(balanceHex, 16);
+      const usdcBalance = balanceWei / 10 ** 6;
+      return { USDC: usdcBalance };
+    } catch {
+      try {
+        const response = await this.request(
+          "GET",
+          "/portfolio/trading/allowance",
+          { type: "clob" },
+          true
+        );
+        const balance = response.balance ?? response.allowance ?? 0;
+        return { USDC: balance };
+      } catch {
+        return { USDC: 0 };
+      }
+    }
+  }
+  describe() {
+    return {
+      id: this.id,
+      name: this.name,
+      has: {
+        fetchMarkets: true,
+        fetchMarket: true,
+        createOrder: true,
+        cancelOrder: true,
+        fetchOrder: true,
+        fetchOpenOrders: true,
+        fetchPositions: true,
+        fetchBalance: true,
+        websocket: true
+      }
+    };
+  }
+};
+var BASE_URL2 = "https://proxy.opinion.trade:8443";
+var CHAIN_ID2 = 56;
+var Opinion = class extends Exchange {
+  id = "opinion";
+  name = "Opinion";
+  apiKey;
+  multiSigAddr;
+  chainId;
+  host;
+  wallet = null;
+  constructor(config = {}) {
+    super(config);
+    this.apiKey = config.apiKey ?? "";
+    this.multiSigAddr = config.multiSigAddr ?? "";
+    this.chainId = config.chainId ?? CHAIN_ID2;
+    this.host = config.host ?? BASE_URL2;
+    if (config.privateKey) {
+      this.wallet = new Wallet(config.privateKey);
+    }
+  }
+  async request(method, endpoint, params) {
+    const url = new URL(`${this.host}${endpoint}`);
+    if (method === "GET" && params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+      headers["X-API-Key"] = this.apiKey;
+    }
+    const fetchOptions = {
+      method,
+      headers
+    };
+    if (method !== "GET" && params) {
+      fetchOptions.body = JSON.stringify(params);
+    }
+    const response = await fetch(url.toString(), fetchOptions);
+    if (!response.ok) {
+      if (response.status === 429) {
+        throw new NetworkError("Rate limited");
+      }
+      if (response.status === 401 || response.status === 403) {
+        throw new AuthenticationError("Authentication failed");
+      }
+      throw new NetworkError(`HTTP ${response.status}`);
+    }
+    return response.json();
+  }
+  ensureAuth() {
+    if (!this.apiKey || !this.wallet || !this.multiSigAddr) {
+      throw new AuthenticationError("API key, private key, and multiSigAddr required");
+    }
+  }
+  parseMarket(data, _fetchPrices = false) {
+    const marketId = String(data.market_id ?? data.topic_id ?? data.id ?? "");
+    const question = data.market_title ?? data.title ?? data.question ?? "";
+    let outcomes = [];
+    const tokenIds = [];
+    const prices = {};
+    const yesTokenId = String(data.yes_token_id ?? "");
+    const noTokenId = String(data.no_token_id ?? "");
+    const yesLabel = data.yes_label ?? "Yes";
+    const noLabel = data.no_label ?? "No";
+    const childMarkets = data.child_markets ?? [];
+    if (yesTokenId && noTokenId) {
+      outcomes = [yesLabel, noLabel];
+      tokenIds.push(yesTokenId, noTokenId);
+    } else if (childMarkets.length > 0) {
+      for (const child of childMarkets) {
+        const childTitle = child.market_title ?? "";
+        const childYesToken = String(child.yes_token_id ?? "");
+        if (childTitle && childYesToken) {
+          outcomes.push(childTitle);
+          tokenIds.push(childYesToken);
+        }
+      }
+    }
+    if (outcomes.length === 0) {
+      outcomes = ["Yes", "No"];
+    }
+    let closeTime;
+    const cutoffTime = data.cutoff_at ?? data.cutoff_time;
+    if (cutoffTime && typeof cutoffTime === "number" && cutoffTime > 0) {
+      closeTime = new Date(cutoffTime * 1e3);
+    }
+    const volume = typeof data.volume === "string" ? Number.parseFloat(data.volume) : data.volume ?? 0;
+    const liquidity = data.liquidity ?? 0;
+    const tickSize = 1e-3;
+    const metadata = {
+      topic_id: marketId,
+      market_id: marketId,
+      condition_id: data.condition_id ?? "",
+      status: data.status ?? "",
+      chain_id: this.chainId,
+      clobTokenIds: tokenIds,
+      token_ids: tokenIds,
+      tokens: Object.fromEntries(outcomes.map((o, i) => [o, tokenIds[i] ?? ""])),
+      description: data.description ?? data.rules ?? "",
+      category: data.category ?? "",
+      image_url: data.image_url ?? "",
+      minimum_tick_size: tickSize,
+      closed: data.status === "RESOLVED"
+    };
+    return {
+      id: marketId,
+      question,
+      outcomes,
+      closeTime,
+      volume,
+      liquidity,
+      prices,
+      tickSize,
+      description: String(metadata.description ?? ""),
+      metadata
+    };
+  }
+  parseOrder(data) {
+    const orderId = String(data.order_id ?? data.id ?? data.orderID ?? "");
+    const marketId = String(data.topic_id ?? data.market_id ?? "");
+    let side;
+    if (data.side_enum) {
+      side = data.side_enum.toLowerCase() === "buy" ? OrderSide.BUY : OrderSide.SELL;
+    } else if (typeof data.side === "string") {
+      side = data.side.toLowerCase() === "buy" ? OrderSide.BUY : OrderSide.SELL;
+    } else {
+      side = data.side === 1 ? OrderSide.BUY : OrderSide.SELL;
+    }
+    const statusVal = data.status;
+    let status;
+    if (typeof statusVal === "number") {
+      const statusMap = {
+        0: OrderStatus.PENDING,
+        1: OrderStatus.OPEN,
+        2: OrderStatus.FILLED,
+        3: OrderStatus.PARTIALLY_FILLED,
+        4: OrderStatus.CANCELLED
+      };
+      status = statusMap[statusVal] ?? OrderStatus.OPEN;
+    } else {
+      const strStatus = String(statusVal).toLowerCase();
+      if (strStatus === "filled" || strStatus === "matched") {
+        status = OrderStatus.FILLED;
+      } else if (strStatus === "cancelled" || strStatus === "canceled") {
+        status = OrderStatus.CANCELLED;
+      } else if (strStatus === "partially_filled") {
+        status = OrderStatus.PARTIALLY_FILLED;
+      } else if (strStatus === "pending") {
+        status = OrderStatus.PENDING;
+      } else {
+        status = OrderStatus.OPEN;
+      }
+    }
+    const price = data.price ?? 0;
+    const size = data.order_shares ?? data.maker_amount ?? data.size ?? 0;
+    const filled = data.filled_shares ?? data.matched_amount ?? data.filled ?? 0;
+    let createdAt = /* @__PURE__ */ new Date();
+    if (data.created_at) {
+      createdAt = typeof data.created_at === "number" ? new Date(data.created_at * 1e3) : new Date(data.created_at);
+    }
+    return {
+      id: orderId,
+      marketId,
+      outcome: data.outcome ?? "",
+      side,
+      price,
+      size,
+      filled,
+      status,
+      createdAt
+    };
+  }
+  parsePosition(data) {
+    return {
+      marketId: String(data.topic_id ?? data.market_id ?? ""),
+      outcome: data.outcome ?? data.token_name ?? "",
+      size: data.shares_owned ?? data.size ?? data.balance ?? 0,
+      averagePrice: data.avg_entry_price ?? data.average_price ?? 0,
+      currentPrice: data.current_price ?? data.price ?? 0
+    };
+  }
+  async fetchMarkets(params) {
+    return this.withRetry(async () => {
+      const queryParams = {
+        topic_type: "ALL",
+        status: params?.active === false ? "ALL" : "ACTIVATED",
+        page: params?.offset ? Math.floor(params.offset / 20) + 1 : 1,
+        limit: Math.min(params?.limit ?? 20, 20)
+      };
+      const response = await this.request("GET", "/api/v1/markets", queryParams);
+      if (response.errno !== 0) {
+        throw new ExchangeError(`Failed to fetch markets: ${response.errmsg}`);
+      }
+      const marketsList = response.result?.list ?? [];
+      const markets = marketsList.map((m) => this.parseMarket(m));
+      if (params?.limit) {
+        return markets.slice(0, params.limit);
+      }
+      return markets;
+    });
+  }
+  async fetchMarket(marketId) {
+    return this.withRetry(async () => {
+      const response = await this.request("GET", `/api/v1/markets/${marketId}`);
+      if (response.errno !== 0 || !response.result?.data) {
+        throw new MarketNotFound(`Market ${marketId} not found`);
+      }
+      return this.parseMarket(response.result.data, true);
+    });
+  }
+  async getOrderbook(tokenId) {
+    return this.withRetry(async () => {
+      const response = await this.request("GET", "/api/v1/orderbook", { token_id: tokenId });
+      const bids = [];
+      const asks = [];
+      if (response.errno === 0 && response.result) {
+        const result = response.result;
+        for (const bid of result.bids ?? []) {
+          const price = Number(bid.price);
+          const size = Number(bid.size);
+          if (price > 0 && size > 0) {
+            bids.push({ price: String(price), size: String(size) });
+          }
+        }
+        for (const ask of result.asks ?? []) {
+          const price = Number(ask.price);
+          const size = Number(ask.size);
+          if (price > 0 && size > 0) {
+            asks.push({ price: String(price), size: String(size) });
+          }
+        }
+        bids.sort((a, b) => Number(b.price) - Number(a.price));
+        asks.sort((a, b) => Number(a.price) - Number(b.price));
+      }
+      return { bids, asks };
+    });
+  }
+  async createOrder(params) {
+    this.ensureAuth();
+    const tokenId = params.tokenId ?? params.params?.token_id;
+    if (!tokenId) {
+      throw new InvalidOrder("token_id required in params");
+    }
+    if (params.price <= 0 || params.price >= 1) {
+      throw new InvalidOrder("Price must be between 0 and 1");
+    }
+    return this.withRetry(async () => {
+      const orderData = {
+        market_id: Number(params.marketId),
+        token_id: tokenId,
+        side: params.side === OrderSide.BUY ? 1 : 2,
+        price: String(params.price),
+        size: String(params.size),
+        order_type: "LIMIT"
+      };
+      const response = await this.request(
+        "POST",
+        "/api/v1/orders",
+        orderData
+      );
+      if (response.errno !== 0) {
+        throw new InvalidOrder(`Order failed: ${response.errmsg}`);
+      }
+      const orderId = response.result?.data?.order_id ?? "";
+      return {
+        id: orderId,
+        marketId: params.marketId,
+        outcome: params.outcome,
+        side: params.side,
+        price: params.price,
+        size: params.size,
+        filled: 0,
+        status: OrderStatus.OPEN,
+        createdAt: /* @__PURE__ */ new Date()
+      };
+    });
+  }
+  async cancelOrder(orderId, marketId) {
+    this.ensureAuth();
+    return this.withRetry(async () => {
+      const response = await this.request("POST", `/api/v1/orders/${orderId}/cancel`);
+      if (response.errno !== 0) {
+        throw new ExchangeError(`Failed to cancel order: ${response.errmsg}`);
+      }
+      return {
+        id: orderId,
+        marketId: marketId ?? "",
+        outcome: "",
+        side: OrderSide.BUY,
+        price: 0,
+        size: 0,
+        filled: 0,
+        status: OrderStatus.CANCELLED,
+        createdAt: /* @__PURE__ */ new Date()
+      };
+    });
+  }
+  async fetchOrder(orderId, _marketId) {
+    this.ensureAuth();
+    return this.withRetry(async () => {
+      const response = await this.request("GET", `/api/v1/orders/${orderId}`);
+      if (response.errno !== 0 || !response.result?.data) {
+        throw new ExchangeError(`Order ${orderId} not found`);
+      }
+      return this.parseOrder(response.result.data);
+    });
+  }
+  async fetchOpenOrders(marketId) {
+    this.ensureAuth();
+    return this.withRetry(async () => {
+      const params = {
+        status: "1",
+        page: 1,
+        limit: 100
+      };
+      if (marketId) {
+        params.market_id = Number(marketId);
+      }
+      const response = await this.request("GET", "/api/v1/orders", params);
+      if (response.errno !== 0) {
+        return [];
+      }
+      const ordersList = response.result?.list ?? [];
+      return ordersList.map((o) => this.parseOrder(o));
+    });
+  }
+  async fetchPositions(marketId) {
+    this.ensureAuth();
+    return this.withRetry(async () => {
+      const params = {
+        page: 1,
+        limit: 100
+      };
+      if (marketId) {
+        params.market_id = Number(marketId);
+      }
+      const response = await this.request("GET", "/api/v1/positions", params);
+      if (response.errno !== 0) {
+        return [];
+      }
+      const positionsList = response.result?.list ?? [];
+      return positionsList.map((p) => this.parsePosition(p));
+    });
+  }
+  async fetchBalance() {
+    this.ensureAuth();
+    return this.withRetry(async () => {
+      const response = await this.request(
+        "GET",
+        "/api/v1/balances"
+      );
+      if (response.errno !== 0) {
+        throw new ExchangeError(`Failed to fetch balance: ${response.errmsg}`);
+      }
+      const result = response.result;
+      const balances = result?.balances ?? [];
+      if (balances.length > 0) {
+        const balance = balances[0]?.available_balance ?? 0;
+        return { USDC: balance };
+      }
+      return { USDC: 0 };
+    });
+  }
+  describe() {
+    return {
+      id: this.id,
+      name: this.name,
+      has: {
+        fetchMarkets: true,
+        fetchMarket: true,
+        createOrder: true,
+        cancelOrder: true,
+        fetchOrder: true,
+        fetchOpenOrders: true,
+        fetchPositions: true,
+        fetchBalance: true,
+        websocket: false
+      }
+    };
+  }
+};
+var BASE_URL3 = "https://gamma-api.polymarket.com";
+var CLOB_URL = "https://clob.polymarket.com";
+var Polymarket = class extends Exchange {
+  id = "polymarket";
+  name = "Polymarket";
+  clobClient = null;
+  wallet = null;
+  address = null;
+  constructor(config = {}) {
+    super(config);
+    if (config.privateKey) {
+      this.initializeClobClient(config);
+    }
+  }
+  describe() {
+    const base = super.describe();
+    return { ...base, has: { ...base.has, websocket: true } };
+  }
+  initializeClobClient(config) {
+    try {
+      const chainId = config.chainId ?? 137;
+      const signatureType = config.signatureType ?? 2;
+      if (!config.privateKey) {
+        return;
+      }
+      this.wallet = new Wallet(config.privateKey);
+      this.clobClient = new ClobClient(
+        CLOB_URL,
+        chainId,
+        this.wallet,
+        void 0,
+        signatureType,
+        config.funder
+      );
+      this.address = this.wallet.address;
+    } catch (error) {
+      throw new AuthenticationError(`Failed to initialize CLOB client: ${error}`);
+    }
+  }
+  async fetchMarkets(params) {
+    return this.withRetry(async () => {
+      const response = await fetch(`${CLOB_URL}/sampling-markets`, {
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (!response.ok) {
+        throw new NetworkError(`Failed to fetch markets: ${response.status}`);
+      }
+      const result = await response.json();
+      const marketsData = result.data ?? (Array.isArray(result) ? result : []);
+      let markets = marketsData.map((item) => this.parseSamplingMarket(item)).filter((m) => m !== null);
+      if (params?.active || !params?.closed) {
+        markets = markets.filter((m) => this.isMarketOpen(m));
+      }
+      if (params?.limit) {
+        markets = markets.slice(0, params.limit);
+      }
+      return markets;
+    });
+  }
+  async fetchMarket(marketId) {
+    return this.withRetry(async () => {
+      const response = await fetch(`${BASE_URL3}/markets/${marketId}`, {
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (response.status === 404) {
+        throw new MarketNotFound(`Market ${marketId} not found`);
+      }
+      if (!response.ok) {
+        throw new NetworkError(`Failed to fetch market: ${response.status}`);
+      }
+      const data = await response.json();
+      return this.parseGammaMarket(data);
+    });
+  }
+  async fetchMarketsBySlug(slugOrUrl) {
+    const slug = this.parseMarketIdentifier(slugOrUrl);
+    if (!slug) throw new Error("Empty slug provided");
+    return this.withRetry(async () => {
+      const response = await fetch(`${BASE_URL3}/events?slug=${slug}`, {
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (response.status === 404) {
+        throw new MarketNotFound(`Event not found: ${slug}`);
+      }
+      if (!response.ok) {
+        throw new ExchangeError(`Failed to fetch event: ${response.status}`);
+      }
+      const eventData = await response.json();
+      if (!eventData.length) {
+        throw new MarketNotFound(`Event not found: ${slug}`);
+      }
+      const event = eventData[0];
+      const marketsData = event?.markets ?? [];
+      return marketsData.map((m) => this.parseGammaMarket(m));
+    });
+  }
+  async createOrder(params) {
+    const client = this.clobClient;
+    if (!client) {
+      throw new AuthenticationError("CLOB client not initialized. Private key required.");
+    }
+    const tokenId = params.tokenId ?? params.params?.token_id;
+    if (!tokenId) {
+      throw new InvalidOrder("token_id required in params");
+    }
+    return this.withRetry(async () => {
+      const signedOrder = await client.createOrder({
+        tokenID: tokenId,
+        price: params.price,
+        size: params.size,
+        side: params.side === OrderSide.BUY ? Side.BUY : Side.SELL
+      });
+      const result = await client.postOrder(signedOrder);
+      const orderId = result.orderID ?? "";
+      const statusStr = result.status ?? "LIVE";
+      return {
+        id: orderId,
+        marketId: params.marketId,
+        outcome: params.outcome,
+        side: params.side,
+        price: params.price,
+        size: params.size,
+        filled: 0,
+        status: this.parseOrderStatus(statusStr),
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+    });
+  }
+  async cancelOrder(orderId, marketId) {
+    const client = this.clobClient;
+    if (!client) {
+      throw new AuthenticationError("CLOB client not initialized. Private key required.");
+    }
+    return this.withRetry(async () => {
+      await client.cancelOrder({ orderID: orderId });
+      return {
+        id: orderId,
+        marketId: marketId ?? "",
+        outcome: "",
+        side: OrderSide.BUY,
+        price: 0,
+        size: 0,
+        filled: 0,
+        status: OrderStatus.CANCELLED,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+    });
+  }
+  async fetchOrder(orderId, _marketId) {
+    const client = this.clobClient;
+    if (!client) {
+      throw new AuthenticationError("CLOB client not initialized. Private key required.");
+    }
+    return this.withRetry(async () => {
+      const data = await client.getOrder(orderId);
+      return this.parseOrder(data);
+    });
+  }
+  async fetchOpenOrders(marketId) {
+    const client = this.clobClient;
+    if (!client) {
+      throw new AuthenticationError("CLOB client not initialized. Private key required.");
+    }
+    return this.withRetry(async () => {
+      const response = await client.getOpenOrders();
+      let orders = response;
+      if (marketId) {
+        orders = orders.filter((o) => o.market === marketId);
+      }
+      return orders.map((o) => this.parseOrder(o));
+    });
+  }
+  async fetchPositions(_marketId) {
+    if (!this.clobClient) {
+      throw new AuthenticationError("CLOB client not initialized. Private key required.");
+    }
+    return [];
+  }
+  async fetchBalance() {
+    const client = this.clobClient;
+    if (!client) {
+      throw new AuthenticationError("CLOB client not initialized. Private key required.");
+    }
+    return this.withRetry(async () => {
+      const balanceData = await client.getBalanceAllowance({
+        asset_type: AssetType.COLLATERAL
+      });
+      const balance = balanceData.balance ? Number.parseFloat(balanceData.balance) / 1e6 : 0;
+      return { USDC: balance };
+    });
+  }
+  async getOrderbook(tokenId) {
+    return this.withRetry(async () => {
+      const response = await fetch(`${CLOB_URL}/book?token_id=${tokenId}`, {
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (!response.ok) {
+        return { bids: [], asks: [] };
+      }
+      return response.json();
+    });
+  }
+  parseMarketIdentifier(identifier) {
+    if (!identifier) return "";
+    if (identifier.startsWith("http")) {
+      const url = identifier.split("?")[0] ?? "";
+      const parts = url.replace(/\/$/, "").split("/");
+      const eventIndex = parts.indexOf("event");
+      if (eventIndex !== -1 && eventIndex + 1 < parts.length) {
+        return parts[eventIndex + 1] ?? "";
+      }
+      return parts[parts.length - 1] ?? "";
+    }
+    return identifier;
+  }
+  parseSamplingMarket(data) {
+    const conditionId = data.condition_id;
+    if (!conditionId) return null;
+    const tokens = data.tokens ?? [];
+    const tokenIds = [];
+    const outcomes = [];
+    const prices = {};
+    for (const token of tokens) {
+      if (token.token_id) tokenIds.push(String(token.token_id));
+      if (token.outcome) outcomes.push(String(token.outcome));
+      if (token.outcome && token.price != null) {
+        prices[String(token.outcome)] = Number(token.price);
+      }
+    }
+    const tickSize = data.minimum_tick_size ?? 0.01;
+    return {
+      id: conditionId,
+      question: data.question ?? "",
+      outcomes: outcomes.length ? outcomes : ["Yes", "No"],
+      closeTime: void 0,
+      volume: 0,
+      liquidity: 0,
+      prices,
+      tickSize,
+      description: data.description ?? "",
+      metadata: {
+        ...data,
+        clobTokenIds: tokenIds,
+        conditionId,
+        minimumTickSize: tickSize
+      }
+    };
+  }
+  parseGammaMarket(data) {
+    let outcomes = data.outcomes ?? [];
+    if (typeof data.outcomes === "string") {
+      try {
+        outcomes = JSON.parse(data.outcomes);
+      } catch {
+        outcomes = [];
+      }
+    }
+    let pricesList = [];
+    if (data.outcomePrices != null) {
+      if (typeof data.outcomePrices === "string") {
+        try {
+          pricesList = JSON.parse(data.outcomePrices);
+        } catch {
+          pricesList = [];
+        }
+      } else if (Array.isArray(data.outcomePrices)) {
+        pricesList = data.outcomePrices;
+      }
+    }
+    const prices = {};
+    for (let i = 0; i < outcomes.length && i < pricesList.length; i++) {
+      const outcome = outcomes[i];
+      const price = pricesList[i];
+      if (outcome && price != null) {
+        const priceVal = Number(price);
+        if (priceVal > 0) {
+          prices[outcome] = priceVal;
+        }
+      }
+    }
+    const closeTime = this.parseDateTime(data.endDate);
+    const volume = Number(data.volumeNum ?? data.volume ?? 0);
+    const liquidity = Number(data.liquidityNum ?? data.liquidity ?? 0);
+    const tickSize = data.minimum_tick_size ?? 0.01;
+    let clobTokenIds = data.clobTokenIds;
+    if (typeof clobTokenIds === "string") {
+      try {
+        clobTokenIds = JSON.parse(clobTokenIds);
+      } catch {
+        clobTokenIds = void 0;
+      }
+    }
+    return {
+      id: data.id ?? "",
+      question: data.question ?? "",
+      outcomes,
+      closeTime,
+      volume,
+      liquidity,
+      prices,
+      tickSize,
+      description: data.description ?? "",
+      metadata: {
+        ...data,
+        clobTokenIds,
+        minimumTickSize: tickSize
+      }
+    };
+  }
+  parseOrder(data) {
+    const orderId = data.id ?? data.orderID ?? "";
+    const size = Number(data.size ?? data.original_size ?? data.amount ?? 0);
+    const filled = Number(data.filled ?? data.matched ?? 0);
+    return {
+      id: orderId,
+      marketId: data.market_id ?? data.market ?? "",
+      outcome: data.outcome ?? "",
+      side: (data.side ?? "buy").toLowerCase() === "buy" ? OrderSide.BUY : OrderSide.SELL,
+      price: Number(data.price ?? 0),
+      size,
+      filled,
+      status: this.parseOrderStatus(data.status),
+      createdAt: this.parseDateTime(data.created_at) ?? /* @__PURE__ */ new Date(),
+      updatedAt: this.parseDateTime(data.updated_at)
+    };
+  }
+  parseOrderStatus(status) {
+    const statusMap = {
+      pending: OrderStatus.PENDING,
+      open: OrderStatus.OPEN,
+      live: OrderStatus.OPEN,
+      filled: OrderStatus.FILLED,
+      matched: OrderStatus.FILLED,
+      partially_filled: OrderStatus.PARTIALLY_FILLED,
+      cancelled: OrderStatus.CANCELLED,
+      canceled: OrderStatus.CANCELLED,
+      rejected: OrderStatus.REJECTED
+    };
+    return statusMap[(status ?? "").toLowerCase()] ?? OrderStatus.OPEN;
+  }
+  isMarketOpen(market) {
+    if (market.metadata.closed) return false;
+    if (!market.closeTime) return true;
+    return /* @__PURE__ */ new Date() < market.closeTime;
+  }
+  get walletAddress() {
+    return this.address;
+  }
+  async fetchTokenIds(conditionId) {
+    return this.withRetry(async () => {
+      const response = await fetch(`${CLOB_URL}/simplified-markets`, {
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (!response.ok) {
+        throw new ExchangeError(`Failed to fetch markets: ${response.status}`);
+      }
+      const result = await response.json();
+      const markets = result.data ?? [];
+      for (const market of markets) {
+        const marketId = market.condition_id ?? market.id;
+        if (marketId === conditionId) {
+          const tokens = market.tokens ?? [];
+          return tokens.map((t) => String(t.token_id ?? "")).filter(Boolean);
+        }
+      }
+      throw new ExchangeError(`Token IDs not found for market ${conditionId}`);
+    });
+  }
+  async fetchPositionsForMarket(market) {
+    const client = this.clobClient;
+    if (!client) {
+      throw new AuthenticationError("CLOB client not initialized. Private key required.");
+    }
+    const positions = [];
+    const tokenIds = MarketUtils.getTokenIds(market);
+    if (tokenIds.length < 2) return positions;
+    for (let i = 0; i < tokenIds.length; i++) {
+      const tokenId = tokenIds[i];
+      if (!tokenId) continue;
+      try {
+        const balanceData = await client.getBalanceAllowance({
+          asset_type: AssetType.CONDITIONAL,
+          token_id: tokenId
+        });
+        const balance = balanceData.balance ? Number.parseFloat(balanceData.balance) / 1e6 : 0;
+        if (balance > 0) {
+          const outcome = market.outcomes[i] ?? (i === 0 ? "Yes" : "No");
+          const currentPrice = market.prices[outcome] ?? 0;
+          positions.push({
+            marketId: market.id,
+            outcome,
+            size: balance,
+            averagePrice: 0,
+            currentPrice
+          });
+        }
+      } catch {
+      }
+    }
+    return positions;
+  }
+  async fetchPriceHistory(marketOrId, options = {}) {
+    const { outcome = 0, interval = "1m", fidelity = 10 } = options;
+    const market = typeof marketOrId === "string" ? await this.fetchMarket(marketOrId) : marketOrId;
+    const tokenIds = MarketUtils.getTokenIds(market);
+    let outcomeIndex;
+    if (typeof outcome === "number") {
+      outcomeIndex = outcome;
+    } else {
+      outcomeIndex = market.outcomes.indexOf(outcome);
+      if (outcomeIndex === -1) outcomeIndex = 0;
+    }
+    const tokenId = tokenIds[outcomeIndex];
+    if (!tokenId) {
+      throw new ExchangeError("Cannot fetch price history without token ID");
+    }
+    return this.withRetry(async () => {
+      const url = `${CLOB_URL}/prices-history?market=${tokenId}&interval=${interval}&fidelity=${fidelity}`;
+      const response = await fetch(url, { signal: AbortSignal.timeout(this.timeout) });
+      if (!response.ok) {
+        throw new NetworkError(`Failed to fetch price history: ${response.status}`);
+      }
+      const data = await response.json();
+      const history = data.history ?? [];
+      return history.filter((h) => h.t != null && h.p != null).map((h) => ({
+        timestamp: new Date((h.t ?? 0) * 1e3),
+        price: h.p ?? 0,
+        raw: h
+      })).sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    });
+  }
+  async searchMarkets(options = {}) {
+    const {
+      limit = 200,
+      offset = 0,
+      order = "volume",
+      ascending = false,
+      closed = false,
+      tagId,
+      query,
+      binary,
+      minLiquidity = 0
+    } = options;
+    return this.withRetry(async () => {
+      const params = new URLSearchParams({
+        limit: String(limit),
+        offset: String(offset),
+        order,
+        ascending: String(ascending),
+        closed: String(closed)
+      });
+      if (tagId) params.set("tag_id", tagId);
+      const response = await fetch(`${BASE_URL3}/markets?${params}`, {
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (!response.ok) {
+        throw new NetworkError(`Failed to search markets: ${response.status}`);
+      }
+      const data = await response.json();
+      let markets = data.map((m) => this.parseGammaMarket(m));
+      if (binary !== void 0) {
+        markets = markets.filter((m) => MarketUtils.isBinary(m) === binary);
+      }
+      if (minLiquidity > 0) {
+        markets = markets.filter((m) => m.liquidity >= minLiquidity);
+      }
+      if (query) {
+        const q = query.toLowerCase();
+        markets = markets.filter(
+          (m) => m.question.toLowerCase().includes(q) || m.description.toLowerCase().includes(q)
+        );
+      }
+      return markets;
+    });
+  }
+  async fetchPublicTrades(options = {}) {
+    const { limit = 100, offset = 0, side, user } = options;
+    let conditionId;
+    if (options.market) {
+      conditionId = typeof options.market === "string" ? options.market : options.market.metadata.conditionId ?? options.market.id;
+    }
+    return this.withRetry(async () => {
+      const params = new URLSearchParams({
+        limit: String(limit),
+        offset: String(offset),
+        takerOnly: "true"
+      });
+      if (conditionId) params.set("market", conditionId);
+      if (side) params.set("side", side);
+      if (user) params.set("user", user);
+      const response = await fetch(`https://data-api.polymarket.com/trades?${params}`, {
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (!response.ok) {
+        throw new NetworkError(`Failed to fetch trades: ${response.status}`);
+      }
+      const data = await response.json();
+      return data.map((row) => {
+        const ts = row.timestamp;
+        let timestamp;
+        if (typeof ts === "number") {
+          timestamp = new Date(ts * 1e3);
+        } else if (typeof ts === "string" && /^\d+$/.test(ts)) {
+          timestamp = new Date(Number.parseInt(ts, 10) * 1e3);
+        } else {
+          timestamp = /* @__PURE__ */ new Date(0);
+        }
+        return {
+          proxyWallet: String(row.proxyWallet ?? ""),
+          side: String(row.side ?? ""),
+          asset: String(row.asset ?? ""),
+          conditionId: String(row.conditionId ?? ""),
+          size: Number(row.size ?? 0),
+          price: Number(row.price ?? 0),
+          timestamp,
+          title: row.title,
+          slug: row.slug,
+          icon: row.icon,
+          eventSlug: row.eventSlug,
+          outcome: row.outcome,
+          outcomeIndex: row.outcomeIndex,
+          name: row.name,
+          pseudonym: row.pseudonym,
+          bio: row.bio,
+          profileImage: row.profileImage,
+          profileImageOptimized: row.profileImageOptimized,
+          transactionHash: row.transactionHash
+        };
+      });
+    });
+  }
+  async getTagBySlug(slug) {
+    if (!slug) throw new Error("slug must be a non-empty string");
+    return this.withRetry(async () => {
+      const response = await fetch(`${BASE_URL3}/tags/slug/${slug}`, {
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (!response.ok) {
+        throw new ExchangeError(`Failed to fetch tag: ${response.status}`);
+      }
+      const data = await response.json();
+      return {
+        id: String(data.id ?? ""),
+        label: data.label,
+        slug: data.slug,
+        forceShow: data.forceShow,
+        forceHide: data.forceHide,
+        isCarousel: data.isCarousel,
+        publishedAt: data.publishedAt,
+        createdAt: data.createdAt,
+        updatedAt: data.UpdatedAt ?? data.updatedAt,
+        raw: data
+      };
+    });
+  }
+  async findCryptoHourlyMarket(options = {}) {
+    const {
+      tokenSymbol,
+      minLiquidity = 0,
+      limit = 100,
+      isActive = true,
+      isExpired = false
+    } = options;
+    const TAG_1H = "102175";
+    const markets = await this.searchMarkets({
+      limit,
+      tagId: TAG_1H,
+      closed: false,
+      minLiquidity
+    });
+    const upDownPattern = /(?<token>Bitcoin|Ethereum|Solana|BTC|ETH|SOL)\s+Up or Down/i;
+    const strikePattern = /(?:(?<token1>BTC|ETH|SOL|BITCOIN|ETHEREUM|SOLANA)\s+.*?(?<direction>above|below|over|under|reach)\s+[\$]?(?<price1>[\d,]+(?:\.\d+)?))|(?:[\$]?(?<price2>[\d,]+(?:\.\d+)?)\s+.*?(?<token2>BTC|ETH|SOL|BITCOIN|ETHEREUM|SOLANA))/i;
+    for (const market of markets) {
+      if (!MarketUtils.isBinary(market) || !MarketUtils.isOpen(market)) continue;
+      if (market.closeTime) {
+        const now = /* @__PURE__ */ new Date();
+        const timeUntilExpiry = market.closeTime.getTime() - now.getTime();
+        if (isExpired && timeUntilExpiry > 0) continue;
+        if (!isExpired && timeUntilExpiry <= 0) continue;
+        if (isActive && !isExpired && timeUntilExpiry > 36e5) continue;
+      }
+      const upDownMatch = upDownPattern.exec(market.question);
+      if (upDownMatch?.groups) {
+        const parsedToken = normalizeTokenSymbol(upDownMatch.groups.token ?? "");
+        if (tokenSymbol && parsedToken !== normalizeTokenSymbol(tokenSymbol)) continue;
+        return {
+          market,
+          crypto: {
+            tokenSymbol: parsedToken,
+            expiryTime: market.closeTime ?? new Date(Date.now() + 36e5),
+            strikePrice: null,
+            marketType: "up_down"
+          }
+        };
+      }
+      const strikeMatch = strikePattern.exec(market.question);
+      if (strikeMatch?.groups) {
+        const parsedToken = normalizeTokenSymbol(
+          strikeMatch.groups.token1 ?? strikeMatch.groups.token2 ?? ""
+        );
+        const priceStr = strikeMatch.groups.price1 ?? strikeMatch.groups.price2 ?? "0";
+        const parsedPrice = Number.parseFloat(priceStr.replace(/,/g, ""));
+        if (tokenSymbol && parsedToken !== normalizeTokenSymbol(tokenSymbol)) continue;
+        return {
+          market,
+          crypto: {
+            tokenSymbol: parsedToken,
+            expiryTime: market.closeTime ?? new Date(Date.now() + 36e5),
+            strikePrice: parsedPrice,
+            marketType: "strike_price"
+          }
+        };
+      }
+    }
+    return null;
+  }
+};
+
+// src/exchanges/polymarket/polymarket-ws.ts
+var WS_URL = "wss://ws-subscriptions-clob.polymarket.com/ws/market";
+var PolymarketWebSocket = class extends OrderBookWebSocket {
+  wsUrl = WS_URL;
+  apiKey;
+  assetSubscriptions = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    super(config);
+    this.apiKey = config.apiKey;
+  }
+  async authenticate() {
+    if (this.apiKey) {
+      this.send({
+        type: "auth",
+        apiKey: this.apiKey
+      });
+    }
+  }
+  async subscribeOrderbook(marketId) {
+    const assetIds = this.assetSubscriptions.get(marketId);
+    if (!assetIds) return;
+    this.send({
+      type: "subscribe",
+      channel: "book",
+      assets_id: assetIds
+    });
+  }
+  async unsubscribeOrderbook(marketId) {
+    const assetIds = this.assetSubscriptions.get(marketId);
+    if (!assetIds) return;
+    this.send({
+      type: "unsubscribe",
+      channel: "book",
+      assets_id: assetIds
+    });
+  }
+  parseOrderbookMessage(message) {
+    if (message.event_type !== "book") return null;
+    const assetId = message.asset_id;
+    if (!assetId) return null;
+    const marketId = this.findMarketIdByAsset(assetId);
+    if (!marketId) return null;
+    const bids = [];
+    const asks = [];
+    const rawBids = message.bids;
+    const rawAsks = message.asks;
+    if (rawBids) {
+      for (const bid of rawBids) {
+        const price = Number.parseFloat(bid.price);
+        const size = Number.parseFloat(bid.size);
+        if (price > 0 && size > 0) {
+          bids.push([price, size]);
+        }
+      }
+    }
+    if (rawAsks) {
+      for (const ask of rawAsks) {
+        const price = Number.parseFloat(ask.price);
+        const size = Number.parseFloat(ask.size);
+        if (price > 0 && size > 0) {
+          asks.push([price, size]);
+        }
+      }
+    }
+    bids.sort((a, b) => b[0] - a[0]);
+    asks.sort((a, b) => a[0] - b[0]);
+    return {
+      marketId,
+      bids,
+      asks,
+      timestamp: Date.now()
+    };
+  }
+  async watchOrderbookWithAsset(marketId, assetId, callback) {
+    this.assetSubscriptions.set(marketId, assetId);
+    await this.watchOrderbook(marketId, callback);
+  }
+  findMarketIdByAsset(assetId) {
+    for (const [marketId, asset] of this.assetSubscriptions) {
+      if (asset === assetId) {
+        return marketId;
+      }
+    }
+    return void 0;
+  }
+};
+
+// src/exchanges/index.ts
+var exchanges = {
+  polymarket: Polymarket,
+  opinion: Opinion,
+  limitless: Limitless
+};
+function listExchanges() {
+  return Object.keys(exchanges);
+}
+function createExchange(exchangeId, config) {
+  const ExchangeClass = exchanges[exchangeId.toLowerCase()];
+  if (!ExchangeClass) {
+    throw new Error(`Exchange '${exchangeId}' not found. Available: ${listExchanges().join(", ")}`);
+  }
+  return new ExchangeClass(config);
+}
+var logger = pino({
+  transport: {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      translateTime: "HH:MM:ss",
+      ignore: "pid,hostname"
+    }
+  }
+});
+function createLogger(name) {
+  return logger.child({ name });
+}
+var Colors = {
+  bold: (text) => `\x1B[1m${text}\x1B[0m`,
+  red: (text) => `\x1B[31m${text}\x1B[0m`,
+  green: (text) => `\x1B[32m${text}\x1B[0m`,
+  yellow: (text) => `\x1B[33m${text}\x1B[0m`,
+  blue: (text) => `\x1B[34m${text}\x1B[0m`,
+  magenta: (text) => `\x1B[35m${text}\x1B[0m`,
+  cyan: (text) => `\x1B[36m${text}\x1B[0m`,
+  gray: (text) => `\x1B[90m${text}\x1B[0m`
+};
+
+// src/utils/price.ts
+function roundToTickSize(price, tickSize) {
+  return Math.round(price / tickSize) * tickSize;
+}
+function clampPrice(price, min = 0, max = 1) {
+  return Math.max(min, Math.min(max, price));
+}
+function formatPrice(price, decimals = 4) {
+  return price.toFixed(decimals);
+}
+function formatUsd(amount) {
+  return `$${amount.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+
+export { AuthenticationError, Colors, DrManhattanError, Exchange, ExchangeError, InsufficientFunds, InvalidOrder, Limitless, MarketNotFound, MarketUtils, NetworkError, Opinion, OrderBookWebSocket, OrderSide, OrderStatus, OrderUtils, OrderbookManager, OrderbookUtils, Polymarket, PolymarketWebSocket, PositionUtils, RateLimitError, Strategy, StrategyState, WebSocketState, calculateDelta, clampPrice, createExchange, createLogger, formatPrice, formatUsd, listExchanges, logger, roundToTickSize };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map