@alango/dr-manhattan 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,696 @@
+import { EventEmitter } from 'node:events';
+import WebSocket from 'ws';
+import pino from 'pino';
+
+/**
+ * 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>;
+}
+
+/**
+ * Market-related types for prediction markets.
+ */
+/** Represents a tradeable outcome with its token ID */
+interface OutcomeToken {
+    /** Outcome name (e.g., "Yes", "No") */
+    outcome: string;
+    /** Token ID for trading */
+    tokenId: string;
+}
+/** Represents a prediction market */
+interface Market {
+    /** Unique market identifier */
+    id: string;
+    /** Market question */
+    question: string;
+    /** List of possible outcomes */
+    outcomes: string[];
+    /** Market close/resolution time */
+    closeTime?: Date;
+    /** Total trading volume */
+    volume: number;
+    /** Available liquidity */
+    liquidity: number;
+    /** Current prices for each outcome (0-1) */
+    prices: Record<string, number>;
+    /** Minimum price increment */
+    tickSize: number;
+    /** Resolution criteria description */
+    description: string;
+    /** Additional exchange-specific metadata */
+    metadata: Record<string, unknown>;
+}
+/** Helper functions for Market */
+declare const MarketUtils: {
+    /** Check if market is binary (Yes/No) */
+    readonly isBinary: (market: Market) => boolean;
+    /** Check if market is still open for trading */
+    readonly isOpen: (market: Market) => boolean;
+    /** Get bid-ask spread for binary markets */
+    readonly spread: (market: Market) => number | null;
+    /** Get token IDs from market metadata */
+    readonly getTokenIds: (market: Market) => string[];
+    /** Create OutcomeToken array from market */
+    readonly getOutcomeTokens: (market: Market) => OutcomeToken[];
+};
+/** Parameters for fetching markets */
+interface FetchMarketsParams {
+    /** Maximum number of markets to return */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+    /** Only return active markets */
+    active?: boolean;
+    /** Include closed markets */
+    closed?: boolean;
+    /** Additional exchange-specific filters */
+    [key: string]: unknown;
+}
+
+/**
+ * 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;
+
+/**
+ * Orderbook-related types for market data.
+ */
+/** Price level: [price, size] */
+type PriceLevel = [price: number, size: number];
+/** Normalized orderbook data structure */
+interface Orderbook {
+    /** Bids sorted descending by price */
+    bids: PriceLevel[];
+    /** Asks sorted ascending by price */
+    asks: PriceLevel[];
+    /** Timestamp (ms since epoch) */
+    timestamp: number;
+    /** Asset/token ID */
+    assetId: string;
+    /** Market ID */
+    marketId: string;
+}
+/** Helper functions for Orderbook */
+declare const OrderbookUtils: {
+    /** Get best bid price */
+    readonly bestBid: (orderbook: Orderbook) => number | null;
+    /** Get best ask price */
+    readonly bestAsk: (orderbook: Orderbook) => number | null;
+    /** Get mid price */
+    readonly midPrice: (orderbook: Orderbook) => number | null;
+    /** Get bid-ask spread */
+    readonly spread: (orderbook: Orderbook) => number | null;
+    /** Create orderbook from REST API response */
+    readonly fromRestResponse: (data: {
+        bids?: Array<{
+            price: string;
+            size: string;
+        }>;
+        asks?: Array<{
+            price: string;
+            size: string;
+        }>;
+    }, tokenId?: string) => Orderbook;
+};
+/** Manages multiple orderbooks efficiently */
+declare class OrderbookManager {
+    private orderbooks;
+    /** Update orderbook for a token */
+    update(tokenId: string, orderbook: Orderbook): void;
+    /** Get orderbook for a token */
+    get(tokenId: string): Orderbook | undefined;
+    /** Get best bid and ask for a token */
+    getBestBidAsk(tokenId: string): [bid: number | null, ask: number | null];
+    /** Check if we have data for a token */
+    hasData(tokenId: string): boolean;
+    /** Check if we have data for all tokens */
+    hasAllData(tokenIds: string[]): boolean;
+    /** Clear all orderbooks */
+    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;
+}
+
+interface PublicTrade {
+    proxyWallet: string;
+    side: string;
+    asset: string;
+    conditionId: string;
+    size: number;
+    price: number;
+    timestamp: Date;
+    title?: string;
+    slug?: string;
+    icon?: string;
+    eventSlug?: string;
+    outcome?: string;
+    outcomeIndex?: number;
+    name?: string;
+    pseudonym?: string;
+    bio?: string;
+    profileImage?: string;
+    profileImageOptimized?: string;
+    transactionHash?: string;
+}
+interface PricePoint {
+    timestamp: Date;
+    price: number;
+    raw: Record<string, unknown>;
+}
+interface Tag {
+    id: string;
+    label?: string;
+    slug?: string;
+    forceShow?: boolean;
+    forceHide?: boolean;
+    isCarousel?: boolean;
+    publishedAt?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    raw: Record<string, unknown>;
+}
+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;
+    privateKey?: string;
+    funder?: string;
+    timeout?: number;
+    verbose?: boolean;
+    rateLimit?: number;
+    maxRetries?: number;
+    retryDelay?: number;
+    retryBackoff?: number;
+}
+interface ExchangeCapabilities {
+    fetchMarkets: boolean;
+    fetchMarket: boolean;
+    createOrder: boolean;
+    cancelOrder: boolean;
+    fetchOrder: boolean;
+    fetchOpenOrders: boolean;
+    fetchPositions: boolean;
+    fetchBalance: boolean;
+    websocket: boolean;
+}
+declare abstract class Exchange {
+    protected config: ExchangeConfig;
+    protected requestTimes: number[];
+    protected lastRequestTime: number;
+    abstract readonly id: string;
+    abstract readonly name: string;
+    constructor(config?: ExchangeConfig);
+    get verbose(): boolean;
+    get timeout(): number;
+    abstract fetchMarkets(params?: FetchMarketsParams): Promise<Market[]>;
+    abstract fetchMarket(marketId: string): Promise<Market>;
+    abstract createOrder(params: CreateOrderParams): Promise<Order>;
+    abstract cancelOrder(orderId: string, marketId?: string): Promise<Order>;
+    abstract fetchOrder(orderId: string, marketId?: string): Promise<Order>;
+    abstract fetchOpenOrders(marketId?: string): Promise<Order[]>;
+    abstract fetchPositions(marketId?: string): Promise<Position[]>;
+    abstract fetchBalance(): Promise<Record<string, number>>;
+    describe(): {
+        id: string;
+        name: string;
+        has: ExchangeCapabilities;
+    };
+    protected checkRateLimit(): void;
+    protected withRetry<T>(fn: () => Promise<T>): Promise<T>;
+    protected sleep(ms: number): Promise<void>;
+    protected parseDateTime(timestamp: unknown): Date | undefined;
+    findTradeableMarket(options?: {
+        binary?: boolean;
+        limit?: number;
+        minLiquidity?: number;
+    }): Promise<Market | null>;
+    calculateSpread(market: Market): number | null;
+    calculateImpliedProbability(price: number): number;
+    calculateExpectedValue(market: Market, outcome: string, price: number): number;
+    getOptimalOrderSize(market: Market, maxPositionSize: number): number;
+}
+
+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 {
+    protected config: WebSocketConfig;
+    protected ws: WebSocket | null;
+    protected state: WebSocketState;
+    protected reconnectAttempts: number;
+    protected subscriptions: Map<string, OrderbookCallback>;
+    protected pingTimer: ReturnType<typeof setInterval> | null;
+    protected lastMessageTime: number;
+    abstract readonly wsUrl: string;
+    constructor(config?: WebSocketConfig);
+    get isConnected(): boolean;
+    protected abstract authenticate(): Promise<void>;
+    protected abstract subscribeOrderbook(marketId: string): Promise<void>;
+    protected abstract unsubscribeOrderbook(marketId: string): Promise<void>;
+    protected abstract parseOrderbookMessage(message: Record<string, unknown>): OrderbookUpdate | null;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    watchOrderbook(marketId: string, callback: OrderbookCallback): Promise<void>;
+    unwatchOrderbook(marketId: string): Promise<void>;
+    protected handleMessage(data: WebSocket.RawData): void;
+    protected handleError(error: Error): void;
+    protected handleClose(): void;
+    protected reconnect(): Promise<void>;
+    protected startPingTimer(): void;
+    protected stopPingTimer(): void;
+    protected sleep(ms: number): Promise<void>;
+    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 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;
+}
+
+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;
+}
+
+interface OpinionConfig extends ExchangeConfig {
+    apiKey?: string;
+    multiSigAddr?: string;
+    chainId?: number;
+    host?: 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;
+    private ensureAuth;
+    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;
+        }>;
+    }>;
+    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>>;
+    describe(): {
+        id: string;
+        name: string;
+        has: {
+            fetchMarkets: boolean;
+            fetchMarket: boolean;
+            createOrder: boolean;
+            cancelOrder: boolean;
+            fetchOrder: boolean;
+            fetchOpenOrders: boolean;
+            fetchPositions: boolean;
+            fetchBalance: boolean;
+            websocket: boolean;
+        };
+    };
+}
+
+interface LimitlessConfig extends ExchangeConfig {
+    host?: string;
+    chainId?: number;
+}
+declare class Limitless extends Exchange {
+    readonly id = "limitless";
+    readonly name = "Limitless";
+    private readonly host;
+    private readonly chainId;
+    private wallet;
+    private address;
+    private authenticated;
+    private ownerId;
+    private sessionCookie;
+    private tokenToSlug;
+    private noTokens;
+    constructor(config?: LimitlessConfig);
+    private authenticate;
+    private ensureAuth;
+    private request;
+    private parseMarket;
+    private parseOrder;
+    private parseOrderStatus;
+    private parsePortfolioPositions;
+    fetchMarkets(params?: FetchMarketsParams): Promise<Market[]>;
+    fetchMarket(marketId: string): Promise<Market>;
+    getOrderbook(marketSlugOrTokenId: string): Promise<{
+        bids: Array<{
+            price: string;
+            size: string;
+        }>;
+        asks: Array<{
+            price: string;
+            size: string;
+        }>;
+    }>;
+    createOrder(params: CreateOrderParams): Promise<Order>;
+    private buildSignedOrder;
+    private signOrderEip712;
+    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>>;
+    describe(): {
+        id: string;
+        name: string;
+        has: {
+            fetchMarkets: boolean;
+            fetchMarket: boolean;
+            createOrder: boolean;
+            cancelOrder: boolean;
+            fetchOrder: boolean;
+            fetchOpenOrders: boolean;
+            fetchPositions: boolean;
+            fetchBalance: boolean;
+            websocket: boolean;
+        };
+    };
+}
+
+declare function listExchanges(): string[];
+declare function createExchange(exchangeId: string, config?: ExchangeConfig): Exchange;
+
+declare const logger: pino.Logger<never, boolean>;
+declare function createLogger(name: string): pino.Logger<never, boolean>;
+declare const Colors: {
+    readonly bold: (text: string) => string;
+    readonly red: (text: string) => string;
+    readonly green: (text: string) => string;
+    readonly yellow: (text: string) => string;
+    readonly blue: (text: string) => string;
+    readonly magenta: (text: string) => string;
+    readonly cyan: (text: string) => string;
+    readonly gray: (text: string) => string;
+};
+
+declare function roundToTickSize(price: number, tickSize: number): number;
+declare function clampPrice(price: number, min?: number, max?: number): number;
+declare function formatPrice(price: number, decimals?: number): string;
+declare function formatUsd(amount: number): string;
+
+export { AuthenticationError, Colors, type CreateOrderParams, type DeltaInfo, DrManhattanError, Exchange, type ExchangeCapabilities, type ExchangeConfig, ExchangeError, type FetchMarketsParams, InsufficientFunds, InvalidOrder, Limitless, type Market, MarketNotFound, MarketUtils, NetworkError, Opinion, type Order, OrderBookWebSocket, OrderSide, OrderStatus, OrderUtils, type Orderbook, type OrderbookCallback, OrderbookManager, type OrderbookUpdate, OrderbookUtils, type OutcomeToken, Polymarket, PolymarketWebSocket, type Position, PositionUtils, type PriceLevel, RateLimitError, Strategy, type StrategyConfig, StrategyState, type WebSocketConfig, WebSocketState, calculateDelta, clampPrice, createExchange, createLogger, formatPrice, formatUsd, listExchanges, logger, roundToTickSize };