@alango/dr-manhattan 0.1.3 → 0.1.4

package/dist/index.d.ts

@@ -3,70 +3,14 @@ import WebSocket from 'ws';
 import pino from 'pino';
 import { Socket } from 'socket.io-client';
 
-/**
- * Order-related types for prediction market trading.
- */
-/** Order side - buy or sell */
-declare const OrderSide: {
-    readonly BUY: "buy";
-    readonly SELL: "sell";
-};
-type OrderSide = (typeof OrderSide)[keyof typeof OrderSide];
-/** Order status */
-declare const OrderStatus: {
-    readonly PENDING: "pending";
-    readonly OPEN: "open";
-    readonly FILLED: "filled";
-    readonly PARTIALLY_FILLED: "partially_filled";
-    readonly CANCELLED: "cancelled";
-    readonly REJECTED: "rejected";
-};
-type OrderStatus = (typeof OrderStatus)[keyof typeof OrderStatus];
-/** Order representation */
-interface Order {
-    /** Unique order identifier */
-    id: string;
-    /** Market identifier */
-    marketId: string;
-    /** Outcome being traded */
-    outcome: string;
-    /** Buy or sell */
-    side: OrderSide;
-    /** Price per share (0-1) */
-    price: number;
-    /** Total order size */
-    size: number;
-    /** Amount filled */
-    filled: number;
-    /** Current status */
-    status: OrderStatus;
-    /** Creation timestamp */
-    createdAt: Date;
-    /** Last update timestamp */
-    updatedAt?: Date;
-}
-/** Helper functions for Order */
-declare const OrderUtils: {
-    /** Get remaining unfilled amount */
-    readonly remaining: (order: Order) => number;
-    /** Check if order is still active */
-    readonly isActive: (order: Order) => boolean;
-    /** Check if order is completely filled */
-    readonly isFilled: (order: Order) => boolean;
-    /** Get fill percentage (0-1) */
-    readonly fillPercentage: (order: Order) => number;
-};
-/** Parameters for creating a new order */
-interface CreateOrderParams {
-    marketId: string;
-    outcome: string;
-    side: OrderSide;
-    price: number;
-    size: number;
-    /** Token ID (required for some exchanges) */
-    tokenId?: string;
-    /** Additional exchange-specific parameters */
-    params?: Record<string, unknown>;
+type MarketDirection = 'up' | 'down';
+type CryptoMarketType = 'up_down' | 'strike_price';
+interface CryptoHourlyMarket {
+    tokenSymbol: string;
+    expiryTime: Date;
+    strikePrice: number | null;
+    direction?: MarketDirection;
+    marketType?: CryptoMarketType;
 }
 
 /**
@@ -130,43 +74,70 @@ interface FetchMarketsParams {
 }
 
 /**
- * Position-related types for tracking holdings.
+ * Order-related types for prediction market trading.
  */
-/** Represents a position in a prediction market */
-interface Position {
+/** Order side - buy or sell */
+declare const OrderSide: {
+    readonly BUY: "buy";
+    readonly SELL: "sell";
+};
+type OrderSide = (typeof OrderSide)[keyof typeof OrderSide];
+/** Order status */
+declare const OrderStatus: {
+    readonly PENDING: "pending";
+    readonly OPEN: "open";
+    readonly FILLED: "filled";
+    readonly PARTIALLY_FILLED: "partially_filled";
+    readonly CANCELLED: "cancelled";
+    readonly REJECTED: "rejected";
+};
+type OrderStatus = (typeof OrderStatus)[keyof typeof OrderStatus];
+/** Order representation */
+interface Order {
+    /** Unique order identifier */
+    id: string;
     /** Market identifier */
     marketId: string;
-    /** Outcome held */
+    /** Outcome being traded */
     outcome: string;
-    /** Position size (number of shares) */
+    /** Buy or sell */
+    side: OrderSide;
+    /** Price per share (0-1) */
+    price: number;
+    /** Total order size */
     size: number;
-    /** Average entry price */
-    averagePrice: number;
-    /** Current market price */
-    currentPrice: number;
+    /** Amount filled */
+    filled: number;
+    /** Current status */
+    status: OrderStatus;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Last update timestamp */
+    updatedAt?: Date;
 }
-/** Helper functions for Position */
-declare const PositionUtils: {
-    /** Get total cost basis */
-    readonly costBasis: (position: Position) => number;
-    /** Get current market value */
-    readonly currentValue: (position: Position) => number;
-    /** Get unrealized profit/loss */
-    readonly unrealizedPnl: (position: Position) => number;
-    /** Get unrealized P&L as percentage */
-    readonly unrealizedPnlPercent: (position: Position) => number;
+/** Helper functions for Order */
+declare const OrderUtils: {
+    /** Get remaining unfilled amount */
+    readonly remaining: (order: Order) => number;
+    /** Check if order is still active */
+    readonly isActive: (order: Order) => boolean;
+    /** Check if order is completely filled */
+    readonly isFilled: (order: Order) => boolean;
+    /** Get fill percentage (0-1) */
+    readonly fillPercentage: (order: Order) => number;
 };
-/** Aggregated position info for delta calculations */
-interface DeltaInfo {
-    /** Net delta (positive = long bias) */
-    delta: number;
-    /** Outcome with maximum position */
-    maxOutcome: string | null;
-    /** Maximum position size */
-    maxPosition: number;
+/** Parameters for creating a new order */
+interface CreateOrderParams {
+    marketId: string;
+    outcome: string;
+    side: OrderSide;
+    price: number;
+    size: number;
+    /** Token ID (required for some exchanges) */
+    tokenId?: string;
+    /** Additional exchange-specific parameters */
+    params?: Record<string, unknown>;
 }
-/** Calculate delta from positions map */
-declare function calculateDelta(positions: Record<string, number>): DeltaInfo;
 
 /**
  * Orderbook-related types for market data.
@@ -225,15 +196,44 @@ declare class OrderbookManager {
     clear(): void;
 }
 
-type MarketDirection = 'up' | 'down';
-type CryptoMarketType = 'up_down' | 'strike_price';
-interface CryptoHourlyMarket {
-    tokenSymbol: string;
-    expiryTime: Date;
-    strikePrice: number | null;
-    direction?: MarketDirection;
-    marketType?: CryptoMarketType;
+/**
+ * Position-related types for tracking holdings.
+ */
+/** Represents a position in a prediction market */
+interface Position {
+    /** Market identifier */
+    marketId: string;
+    /** Outcome held */
+    outcome: string;
+    /** Position size (number of shares) */
+    size: number;
+    /** Average entry price */
+    averagePrice: number;
+    /** Current market price */
+    currentPrice: number;
+}
+/** Helper functions for Position */
+declare const PositionUtils: {
+    /** Get total cost basis */
+    readonly costBasis: (position: Position) => number;
+    /** Get current market value */
+    readonly currentValue: (position: Position) => number;
+    /** Get unrealized profit/loss */
+    readonly unrealizedPnl: (position: Position) => number;
+    /** Get unrealized P&L as percentage */
+    readonly unrealizedPnlPercent: (position: Position) => number;
+};
+/** Aggregated position info for delta calculations */
+interface DeltaInfo {
+    /** Net delta (positive = long bias) */
+    delta: number;
+    /** Outcome with maximum position */
+    maxOutcome: string | null;
+    /** Maximum position size */
+    maxPosition: number;
 }
+/** Calculate delta from positions map */
+declare function calculateDelta(positions: Record<string, number>): DeltaInfo;
 
 interface PublicTrade {
     proxyWallet: string;
@@ -275,32 +275,6 @@ interface Tag {
 }
 type PriceHistoryInterval = '1m' | '1h' | '6h' | '1d' | '1w' | 'max';
 
-declare class DrManhattanError extends Error {
-    constructor(message: string);
-}
-declare class ExchangeError extends DrManhattanError {
-    constructor(message: string);
-}
-declare class NetworkError extends DrManhattanError {
-    constructor(message: string);
-}
-declare class RateLimitError extends DrManhattanError {
-    retryAfter: number | undefined;
-    constructor(message: string, retryAfter?: number);
-}
-declare class AuthenticationError extends DrManhattanError {
-    constructor(message: string);
-}
-declare class InsufficientFunds extends DrManhattanError {
-    constructor(message: string);
-}
-declare class InvalidOrder extends DrManhattanError {
-    constructor(message: string);
-}
-declare class MarketNotFound extends DrManhattanError {
-    constructor(message: string);
-}
-
 interface ExchangeConfig {
     apiKey?: string;
     apiSecret?: string;
@@ -361,27 +335,64 @@ declare abstract class Exchange {
     getOptimalOrderSize(market: Market, maxPositionSize: number): number;
 }
 
-declare const WebSocketState: {
-    readonly DISCONNECTED: "disconnected";
-    readonly CONNECTING: "connecting";
-    readonly CONNECTED: "connected";
-    readonly RECONNECTING: "reconnecting";
-    readonly CLOSED: "closed";
+declare const StrategyState: {
+    readonly STOPPED: "stopped";
+    readonly RUNNING: "running";
+    readonly PAUSED: "paused";
 };
-type WebSocketState = (typeof WebSocketState)[keyof typeof WebSocketState];
-interface WebSocketConfig {
+type StrategyState = (typeof StrategyState)[keyof typeof StrategyState];
+interface StrategyConfig {
+    tickInterval?: number;
+    maxPositionSize?: number;
+    spreadBps?: number;
     verbose?: boolean;
-    autoReconnect?: boolean;
-    maxReconnectAttempts?: number;
-    reconnectDelay?: number;
-    pingInterval?: number;
-    pingTimeout?: number;
-}
-interface OrderbookUpdate {
-    marketId: string;
-    bids: [number, number][];
-    asks: [number, number][];
-    timestamp: number;
+}
+declare abstract class Strategy extends EventEmitter {
+    protected exchange: Exchange;
+    protected marketId: string;
+    protected market: Market | null;
+    protected state: StrategyState;
+    protected config: StrategyConfig;
+    protected tickTimer: ReturnType<typeof setInterval> | null;
+    protected positions: Position[];
+    protected openOrders: Order[];
+    constructor(exchange: Exchange, marketId: string, config?: StrategyConfig);
+    abstract onTick(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    pause(): void;
+    resume(): void;
+    protected refreshState(): Promise<void>;
+    protected cancelAllOrders(): Promise<void>;
+    protected getPosition(outcome: string): Position | undefined;
+    protected getNetPosition(): number;
+    protected placeOrder(outcome: string, side: OrderSide, price: number, size: number, tokenId?: string): Promise<Order | null>;
+    protected log(message: string): void;
+    get isRunning(): boolean;
+    get currentState(): StrategyState;
+}
+
+declare const WebSocketState: {
+    readonly DISCONNECTED: "disconnected";
+    readonly CONNECTING: "connecting";
+    readonly CONNECTED: "connected";
+    readonly RECONNECTING: "reconnecting";
+    readonly CLOSED: "closed";
+};
+type WebSocketState = (typeof WebSocketState)[keyof typeof WebSocketState];
+interface WebSocketConfig {
+    verbose?: boolean;
+    autoReconnect?: boolean;
+    maxReconnectAttempts?: number;
+    reconnectDelay?: number;
+    pingInterval?: number;
+    pingTimeout?: number;
+}
+interface OrderbookUpdate {
+    marketId: string;
+    bids: [number, number][];
+    asks: [number, number][];
+    timestamp: number;
 }
 type OrderbookCallback = (marketId: string, orderbook: OrderbookUpdate) => void | Promise<void>;
 declare abstract class OrderBookWebSocket extends EventEmitter {
@@ -413,184 +424,62 @@ declare abstract class OrderBookWebSocket extends EventEmitter {
     protected send(data: unknown): void;
 }
 
-declare const StrategyState: {
-    readonly STOPPED: "stopped";
-    readonly RUNNING: "running";
-    readonly PAUSED: "paused";
-};
-type StrategyState = (typeof StrategyState)[keyof typeof StrategyState];
-interface StrategyConfig {
-    tickInterval?: number;
-    maxPositionSize?: number;
-    spreadBps?: number;
-    verbose?: boolean;
+declare class DrManhattanError extends Error {
+    constructor(message: string);
 }
-declare abstract class Strategy extends EventEmitter {
-    protected exchange: Exchange;
-    protected marketId: string;
-    protected market: Market | null;
-    protected state: StrategyState;
-    protected config: StrategyConfig;
-    protected tickTimer: ReturnType<typeof setInterval> | null;
-    protected positions: Position[];
-    protected openOrders: Order[];
-    constructor(exchange: Exchange, marketId: string, config?: StrategyConfig);
-    abstract onTick(): Promise<void>;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    pause(): void;
-    resume(): void;
-    protected refreshState(): Promise<void>;
-    protected cancelAllOrders(): Promise<void>;
-    protected getPosition(outcome: string): Position | undefined;
-    protected getNetPosition(): number;
-    protected placeOrder(outcome: string, side: OrderSide, price: number, size: number, tokenId?: string): Promise<Order | null>;
-    protected log(message: string): void;
-    get isRunning(): boolean;
-    get currentState(): StrategyState;
+declare class ExchangeError extends DrManhattanError {
+    constructor(message: string);
 }
-
-interface PolymarketConfig extends ExchangeConfig {
-    chainId?: number;
-    signatureType?: number;
+declare class NetworkError extends DrManhattanError {
+    constructor(message: string);
 }
-declare class Polymarket extends Exchange {
-    readonly id = "polymarket";
-    readonly name = "Polymarket";
-    private clobClient;
-    private wallet;
-    private address;
-    constructor(config?: PolymarketConfig);
-    describe(): {
-        has: {
-            websocket: boolean;
-            fetchMarkets: boolean;
-            fetchMarket: boolean;
-            createOrder: boolean;
-            cancelOrder: boolean;
-            fetchOrder: boolean;
-            fetchOpenOrders: boolean;
-            fetchPositions: boolean;
-            fetchBalance: boolean;
-        };
-        id: string;
-        name: string;
-    };
-    private initializeClobClient;
-    fetchMarkets(params?: FetchMarketsParams): Promise<Market[]>;
-    fetchMarket(marketId: string): Promise<Market>;
-    fetchMarketsBySlug(slugOrUrl: string): Promise<Market[]>;
-    createOrder(params: CreateOrderParams): Promise<Order>;
-    cancelOrder(orderId: string, marketId?: string): Promise<Order>;
-    fetchOrder(orderId: string, _marketId?: string): Promise<Order>;
-    fetchOpenOrders(marketId?: string): Promise<Order[]>;
-    fetchPositions(_marketId?: string): Promise<Position[]>;
-    fetchBalance(): Promise<Record<string, number>>;
-    getOrderbook(tokenId: string): Promise<{
-        bids: Array<{
-            price: string;
-            size: string;
-        }>;
-        asks: Array<{
-            price: string;
-            size: string;
-        }>;
-    }>;
-    private parseMarketIdentifier;
-    private parseSamplingMarket;
-    private parseGammaMarket;
-    private parseOrder;
-    private parseOrderStatus;
-    private isMarketOpen;
-    get walletAddress(): string | null;
-    fetchTokenIds(conditionId: string): Promise<string[]>;
-    fetchPositionsForMarket(market: Market): Promise<Position[]>;
-    fetchPriceHistory(marketOrId: Market | string, options?: {
-        outcome?: number | string;
-        interval?: PriceHistoryInterval;
-        fidelity?: number;
-    }): Promise<PricePoint[]>;
-    searchMarkets(options?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-        ascending?: boolean;
-        closed?: boolean;
-        tagId?: string;
-        query?: string;
-        binary?: boolean;
-        minLiquidity?: number;
-    }): Promise<Market[]>;
-    fetchPublicTrades(options?: {
-        market?: Market | string;
-        limit?: number;
-        offset?: number;
-        side?: 'BUY' | 'SELL';
-        user?: string;
-    }): Promise<PublicTrade[]>;
-    getTagBySlug(slug: string): Promise<Tag>;
-    findCryptoHourlyMarket(options?: {
-        tokenSymbol?: string;
-        minLiquidity?: number;
-        limit?: number;
-        isActive?: boolean;
-        isExpired?: boolean;
-    }): Promise<{
-        market: Market;
-        crypto: CryptoHourlyMarket;
-    } | null>;
+declare class RateLimitError extends DrManhattanError {
+    retryAfter: number | undefined;
+    constructor(message: string, retryAfter?: number);
 }
-
-interface PolymarketWsConfig extends WebSocketConfig {
-    apiKey?: string;
+declare class AuthenticationError extends DrManhattanError {
+    constructor(message: string);
 }
-declare class PolymarketWebSocket extends OrderBookWebSocket {
-    readonly wsUrl = "wss://ws-subscriptions-clob.polymarket.com/ws/market";
-    private apiKey?;
-    private assetSubscriptions;
-    constructor(config?: PolymarketWsConfig);
-    protected authenticate(): Promise<void>;
-    protected subscribeOrderbook(marketId: string): Promise<void>;
-    protected unsubscribeOrderbook(marketId: string): Promise<void>;
-    protected parseOrderbookMessage(message: Record<string, unknown>): OrderbookUpdate | null;
-    watchOrderbookWithAsset(marketId: string, assetId: string, callback: (marketId: string, orderbook: OrderbookUpdate) => void | Promise<void>): Promise<void>;
-    private findMarketIdByAsset;
+declare class InsufficientFunds extends DrManhattanError {
+    constructor(message: string);
+}
+declare class InvalidOrder extends DrManhattanError {
+    constructor(message: string);
+}
+declare class MarketNotFound extends DrManhattanError {
+    constructor(message: string);
 }
 
-interface OpinionConfig extends ExchangeConfig {
-    apiKey?: string;
-    multiSigAddr?: string;
-    chainId?: number;
-    host?: string;
+interface KalshiConfig extends ExchangeConfig {
+    /** API key ID (the public key identifier) */
+    apiKeyId?: string;
+    /** Path to RSA private key PEM file */
+    privateKeyPath?: string;
+    /** RSA private key PEM content (alternative to path) */
+    privateKeyPem?: string;
+    /** Use demo environment */
+    demo?: boolean;
+    /** Custom API URL */
+    apiUrl?: string;
 }
-declare class Opinion extends Exchange {
-    readonly id = "opinion";
-    readonly name = "Opinion";
-    private readonly apiKey;
-    private readonly multiSigAddr;
-    private readonly chainId;
-    private readonly host;
-    private wallet;
-    constructor(config?: OpinionConfig);
-    private request;
+declare class Kalshi extends Exchange {
+    readonly id = "kalshi";
+    readonly name = "Kalshi";
+    private readonly apiUrl;
+    private readonly apiKeyId;
+    private auth;
+    constructor(config?: KalshiConfig);
+    private isAuthenticated;
     private ensureAuth;
+    private request;
     private parseMarket;
     private parseOrder;
     private parsePosition;
     fetchMarkets(params?: FetchMarketsParams): Promise<Market[]>;
     fetchMarket(marketId: string): Promise<Market>;
-    getOrderbook(tokenId: string): Promise<{
-        bids: Array<{
-            price: string;
-            size: string;
-        }>;
-        asks: Array<{
-            price: string;
-            size: string;
-        }>;
-    }>;
+    fetchOrderbook(ticker: string): Promise<Orderbook>;
     createOrder(params: CreateOrderParams): Promise<Order>;
-    cancelOrder(orderId: string, marketId?: string): Promise<Order>;
+    cancelOrder(orderId: string, _marketId?: string): Promise<Order>;
     fetchOrder(orderId: string, _marketId?: string): Promise<Order>;
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
     fetchPositions(marketId?: string): Promise<Position[]>;
@@ -740,36 +629,40 @@ declare class Limitless extends Exchange {
     };
 }
 
-interface KalshiConfig extends ExchangeConfig {
-    /** API key ID (the public key identifier) */
-    apiKeyId?: string;
-    /** Path to RSA private key PEM file */
-    privateKeyPath?: string;
-    /** RSA private key PEM content (alternative to path) */
-    privateKeyPem?: string;
-    /** Use demo environment */
-    demo?: boolean;
-    /** Custom API URL */
-    apiUrl?: string;
+interface OpinionConfig extends ExchangeConfig {
+    apiKey?: string;
+    multiSigAddr?: string;
+    chainId?: number;
+    host?: string;
 }
-declare class Kalshi extends Exchange {
-    readonly id = "kalshi";
-    readonly name = "Kalshi";
-    private readonly apiUrl;
-    private readonly apiKeyId;
-    private auth;
-    constructor(config?: KalshiConfig);
-    private isAuthenticated;
-    private ensureAuth;
+declare class Opinion extends Exchange {
+    readonly id = "opinion";
+    readonly name = "Opinion";
+    private readonly apiKey;
+    private readonly multiSigAddr;
+    private readonly chainId;
+    private readonly host;
+    private wallet;
+    constructor(config?: OpinionConfig);
     private request;
+    private ensureAuth;
     private parseMarket;
     private parseOrder;
     private parsePosition;
     fetchMarkets(params?: FetchMarketsParams): Promise<Market[]>;
     fetchMarket(marketId: string): Promise<Market>;
-    fetchOrderbook(ticker: string): Promise<Orderbook>;
+    getOrderbook(tokenId: string): Promise<{
+        bids: Array<{
+            price: string;
+            size: string;
+        }>;
+        asks: Array<{
+            price: string;
+            size: string;
+        }>;
+    }>;
     createOrder(params: CreateOrderParams): Promise<Order>;
-    cancelOrder(orderId: string, _marketId?: string): Promise<Order>;
+    cancelOrder(orderId: string, marketId?: string): Promise<Order>;
     fetchOrder(orderId: string, _marketId?: string): Promise<Order>;
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
     fetchPositions(marketId?: string): Promise<Position[]>;
@@ -791,6 +684,113 @@ declare class Kalshi extends Exchange {
     };
 }
 
+interface PolymarketConfig extends ExchangeConfig {
+    chainId?: number;
+    signatureType?: number;
+}
+declare class Polymarket extends Exchange {
+    readonly id = "polymarket";
+    readonly name = "Polymarket";
+    private clobClient;
+    private wallet;
+    private address;
+    constructor(config?: PolymarketConfig);
+    describe(): {
+        has: {
+            websocket: boolean;
+            fetchMarkets: boolean;
+            fetchMarket: boolean;
+            createOrder: boolean;
+            cancelOrder: boolean;
+            fetchOrder: boolean;
+            fetchOpenOrders: boolean;
+            fetchPositions: boolean;
+            fetchBalance: boolean;
+        };
+        id: string;
+        name: string;
+    };
+    private initializeClobClient;
+    fetchMarkets(params?: FetchMarketsParams): Promise<Market[]>;
+    fetchMarket(marketId: string): Promise<Market>;
+    fetchMarketsBySlug(slugOrUrl: string): Promise<Market[]>;
+    createOrder(params: CreateOrderParams): Promise<Order>;
+    cancelOrder(orderId: string, marketId?: string): Promise<Order>;
+    fetchOrder(orderId: string, _marketId?: string): Promise<Order>;
+    fetchOpenOrders(marketId?: string): Promise<Order[]>;
+    fetchPositions(_marketId?: string): Promise<Position[]>;
+    fetchBalance(): Promise<Record<string, number>>;
+    getOrderbook(tokenId: string): Promise<{
+        bids: Array<{
+            price: string;
+            size: string;
+        }>;
+        asks: Array<{
+            price: string;
+            size: string;
+        }>;
+    }>;
+    private parseMarketIdentifier;
+    private parseSamplingMarket;
+    private parseGammaMarket;
+    private parseOrder;
+    private parseOrderStatus;
+    private isMarketOpen;
+    get walletAddress(): string | null;
+    fetchTokenIds(conditionId: string): Promise<string[]>;
+    fetchPositionsForMarket(market: Market): Promise<Position[]>;
+    fetchPriceHistory(marketOrId: Market | string, options?: {
+        outcome?: number | string;
+        interval?: PriceHistoryInterval;
+        fidelity?: number;
+    }): Promise<PricePoint[]>;
+    searchMarkets(options?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        ascending?: boolean;
+        closed?: boolean;
+        tagId?: string;
+        query?: string;
+        binary?: boolean;
+        minLiquidity?: number;
+    }): Promise<Market[]>;
+    fetchPublicTrades(options?: {
+        market?: Market | string;
+        limit?: number;
+        offset?: number;
+        side?: 'BUY' | 'SELL';
+        user?: string;
+    }): Promise<PublicTrade[]>;
+    getTagBySlug(slug: string): Promise<Tag>;
+    findCryptoHourlyMarket(options?: {
+        tokenSymbol?: string;
+        minLiquidity?: number;
+        limit?: number;
+        isActive?: boolean;
+        isExpired?: boolean;
+    }): Promise<{
+        market: Market;
+        crypto: CryptoHourlyMarket;
+    } | null>;
+}
+
+interface PolymarketWsConfig extends WebSocketConfig {
+    apiKey?: string;
+}
+declare class PolymarketWebSocket extends OrderBookWebSocket {
+    readonly wsUrl = "wss://ws-subscriptions-clob.polymarket.com/ws/market";
+    private apiKey?;
+    private assetSubscriptions;
+    constructor(config?: PolymarketWsConfig);
+    protected authenticate(): Promise<void>;
+    protected subscribeOrderbook(marketId: string): Promise<void>;
+    protected unsubscribeOrderbook(marketId: string): Promise<void>;
+    protected parseOrderbookMessage(message: Record<string, unknown>): OrderbookUpdate | null;
+    watchOrderbookWithAsset(marketId: string, assetId: string, callback: (marketId: string, orderbook: OrderbookUpdate) => void | Promise<void>): Promise<void>;
+    private findMarketIdByAsset;
+}
+
 declare function listExchanges(): string[];
 declare function createExchange(exchangeId: string, config?: ExchangeConfig): Exchange;