@alango/dr-manhattan 0.1.3 → 0.1.4

package/dist/index.js

@@ -7,39 +7,70 @@ import { io } from '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"
+// src/errors/index.ts
+var DrManhattanError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DrManhattanError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
 };
-var OrderStatus = {
-  PENDING: "pending",
-  OPEN: "open",
-  FILLED: "filled",
-  PARTIALLY_FILLED: "partially_filled",
-  CANCELLED: "cancelled",
-  REJECTED: "rejected"
+var ExchangeError = class extends DrManhattanError {
+  constructor(message) {
+    super(message);
+    this.name = "ExchangeError";
+  }
 };
-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;
+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/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/types/market.ts
 var MarketUtils = {
   /** Check if market is binary (Yes/No) */
@@ -89,49 +120,38 @@ var MarketUtils = {
   }
 };
 
-// src/types/position.ts
-var PositionUtils = {
-  /** Get total cost basis */
-  costBasis(position) {
-    return position.size * position.averagePrice;
+// 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;
   },
-  /** Get current market value */
-  currentValue(position) {
-    return position.size * position.currentPrice;
+  /** Check if order is still active */
+  isActive(order) {
+    return order.status === OrderStatus.OPEN || order.status === OrderStatus.PARTIALLY_FILLED;
   },
-  /** Get unrealized profit/loss */
-  unrealizedPnl(position) {
-    return PositionUtils.currentValue(position) - PositionUtils.costBasis(position);
+  /** Check if order is completely filled */
+  isFilled(order) {
+    return order.status === OrderStatus.FILLED || order.filled >= order.size;
   },
-  /** Get unrealized P&L as percentage */
-  unrealizedPnlPercent(position) {
-    const costBasis = PositionUtils.costBasis(position);
-    if (costBasis === 0) return 0;
-    return PositionUtils.unrealizedPnl(position) / costBasis * 100;
+  /** Get fill percentage (0-1) */
+  fillPercentage(order) {
+    if (order.size === 0) return 0;
+    return order.filled / order.size;
   }
 };
-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 = {
@@ -218,69 +238,49 @@ var OrderbookManager = class {
   }
 };
 
-// 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";
+// 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;
   }
 };
-var InsufficientFunds = class extends DrManhattanError {
-  constructor(message) {
-    super(message);
-    this.name = "InsufficientFunds";
+function calculateDelta(positions) {
+  const entries = Object.entries(positions);
+  if (entries.length === 0) {
+    return { delta: 0, maxOutcome: null, maxPosition: 0 };
   }
-};
-var InvalidOrder = class extends DrManhattanError {
-  constructor(message) {
-    super(message);
-    this.name = "InvalidOrder";
+  let maxOutcome = null;
+  let maxPosition = 0;
+  for (const [outcome, size] of entries) {
+    if (size > maxPosition) {
+      maxPosition = size;
+      maxOutcome = outcome;
+    }
   }
-};
-var MarketNotFound = class extends DrManhattanError {
-  constructor(message) {
-    super(message);
-    this.name = "MarketNotFound";
+  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/core/exchange.ts
 var Exchange = class {
@@ -411,6 +411,131 @@ var Exchange = class {
     return Math.min(maxPositionSize, liquidityBasedSize);
   }
 };
+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;
+  }
+};
 var WebSocketState = {
   DISCONNECTED: "disconnected",
   CONNECTING: "connecting",
@@ -579,142 +704,20 @@ var OrderBookWebSocket = class extends EventEmitter {
     }
   }
 };
-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;
-  }
-};
 var BASE_URL = "https://api.elections.kalshi.com/trade-api/v2";
 var DEMO_URL = "https://demo-api.kalshi.co/trade-api/v2";
 function createAuth(privateKeyPem) {
+  const privateKey = crypto.createPrivateKey(privateKeyPem);
   return {
     sign(timestampMs, method, path) {
-      const message = `${timestampMs}${method.toUpperCase()}${path}`;
-      const sign = crypto.createSign("RSA-SHA256");
-      sign.update(message);
-      sign.end();
-      const signature = sign.sign(privateKeyPem, "base64");
-      return signature;
+      const pathWithoutQuery = path.split("?")[0];
+      const message = `${timestampMs}${method.toUpperCase()}${pathWithoutQuery}`;
+      const signature = crypto.sign("sha256", Buffer.from(message), {
+        key: privateKey,
+        padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
+        saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST
+      });
+      return signature.toString("base64");
     }
   };
 }
@@ -3034,7 +3037,7 @@ var Polymarket = class extends Exchange {
       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;
+    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) {