@gaberoo/kalshitools 1.0.2 → 1.1.0

package/dist/lib/scanner.js

@@ -0,0 +1,160 @@
+/**
+ * Market scanning and opportunity detection utilities
+ */
+/**
+ * Calculate total liquidity from an orderbook
+ */
+export function calculateOrderbookLiquidity(orderbook) {
+    const yesTotal = orderbook.yes.reduce((sum, level) => sum + level.count * level.price, 0);
+    const noTotal = orderbook.no.reduce((sum, level) => sum + level.count * level.price, 0);
+    return {
+        noTotal,
+        total: yesTotal + noTotal,
+        yesTotal,
+    };
+}
+/**
+ * Calculate bid-ask spread from an orderbook
+ *
+ * In Kalshi orderbooks:
+ * - Lower prices in the yes array are bids (buyers)
+ * - Higher prices in the yes array are asks (sellers)
+ * - Spread = ask - bid
+ */
+export function calculateSpread(orderbook) {
+    if (orderbook.yes.length === 0) {
+        return null;
+    }
+    const prices = orderbook.yes.map(level => level.price).sort((a, b) => a - b);
+    // Best bid is the lowest price (buyers)
+    const yesBid = prices[0];
+    // Best ask is the highest price (sellers)
+    const yesAsk = prices.at(-1);
+    if (!yesAsk || !yesBid) {
+        return null;
+    }
+    // If bid and ask are the same, there's no spread
+    const spreadCents = yesAsk - yesBid;
+    const midPrice = (yesBid + yesAsk) / 2;
+    const spreadPct = midPrice > 0 ? (spreadCents / midPrice) * 100 : 0;
+    return {
+        spreadCents,
+        spreadPct,
+        yesAsk,
+        yesBid,
+    };
+}
+const DEFAULT_WEIGHTS = {
+    liquidity: 40,
+    spread: 30,
+    volume: 30,
+};
+/**
+ * Score a market based on liquidity, spread, and volume
+ * Returns score from 0-100
+ */
+export function scoreMarket(market, orderbook, weights = DEFAULT_WEIGHTS) {
+    let score = 0;
+    // Liquidity score (0-40 points)
+    const liquidity = calculateOrderbookLiquidity(orderbook);
+    const liquidityScore = Math.min(weights.liquidity, (liquidity.total / 5000) * weights.liquidity);
+    score += liquidityScore;
+    // Spread score (0-30 points) - wider spreads are better for market making
+    const spread = calculateSpread(orderbook);
+    if (spread) {
+        // Spread between 0.03 (3 cents) and 0.20 (20 cents) is ideal
+        const { spreadCents } = spread;
+        let spreadScore = 0;
+        if (spreadCents >= 0.03 && spreadCents <= 0.2) {
+            spreadScore = weights.spread;
+        }
+        else if (spreadCents > 0.2) {
+            // Too wide - gradually decrease score
+            spreadScore = Math.max(0, weights.spread * (1 - (spreadCents - 0.2) / 0.3));
+        }
+        else {
+            // Too narrow - gradually decrease score
+            spreadScore = (spreadCents / 0.03) * weights.spread;
+        }
+        score += spreadScore;
+    }
+    // Volume score (0-30 points)
+    const volume = market.volume_24h || market.volume || 0;
+    const volumeScore = Math.min(weights.volume, (volume / 10_000) * weights.volume);
+    score += volumeScore;
+    return Math.round(score);
+}
+/**
+ * Classify the type of opportunity a market presents
+ */
+export function classifyOpportunity(spread, liquidity, volume) {
+    const hasWideSpread = spread >= 0.05;
+    const hasHighLiquidity = liquidity >= 2000;
+    const hasHighVolume = volume >= 5000;
+    // Check combinations
+    if (hasWideSpread && hasHighLiquidity && hasHighVolume) {
+        return 'balanced';
+    }
+    if (hasWideSpread) {
+        return 'wide_spread';
+    }
+    if (hasHighLiquidity) {
+        return 'high_liquidity';
+    }
+    if (hasHighVolume) {
+        return 'high_volume';
+    }
+    // Default to balanced if none of the above
+    return 'balanced';
+}
+/**
+ * Generate human-readable reason for opportunity
+ */
+export function generateOpportunityReason(type, spread, liquidity, volume) {
+    const spreadCents = Math.round(spread * 100);
+    switch (type) {
+        case 'balanced': {
+            return `Balanced opportunity: ${spreadCents} cent spread, $${Math.round(liquidity)} liquidity, $${Math.round(volume)} volume`;
+        }
+        case 'high_liquidity': {
+            return `Strong liquidity ($${Math.round(liquidity).toLocaleString()})`;
+        }
+        case 'high_volume': {
+            return `High trading volume ($${Math.round(volume).toLocaleString()} 24h)`;
+        }
+        case 'wide_spread': {
+            return `High liquidity with ${spreadCents} cent spread`;
+        }
+    }
+}
+/**
+ * Filter markets based on criteria
+ */
+export function filterMarketsByCriteria(markets, criteria) {
+    return markets.filter(m => {
+        // Liquidity check
+        if (criteria.minLiquidity && m.liquidity < criteria.minLiquidity) {
+            return false;
+        }
+        // Spread checks
+        if (m.spread === null) {
+            // No spread data - exclude if spread filters are specified
+            if (criteria.minSpread || criteria.maxSpread) {
+                return false;
+            }
+        }
+        else {
+            if (criteria.minSpread && m.spread < criteria.minSpread) {
+                return false;
+            }
+            if (criteria.maxSpread && m.spread > criteria.maxSpread) {
+                return false;
+            }
+        }
+        // Volume check
+        if (criteria.minVolume && m.volume < criteria.minVolume) {
+            return false;
+        }
+        return true;
+    });
+}

package/dist/lib/shutdown.d.ts

@@ -10,6 +10,10 @@ declare class ShutdownManager {
     private isShuttingDown;
     private shutdownTimeout;
     constructor();
+    /**
+     * Check if shutdown is in progress
+     */
+    isShutdownInProgress(): boolean;
     /**
      * Register a cleanup function to be called on shutdown
      */
@@ -26,10 +30,6 @@ declare class ShutdownManager {
      * Perform graceful shutdown
      */
     private shutdown;
-    /**
-     * Check if shutdown is in progress
-     */
-    isShutdownInProgress(): boolean;
 }
 export declare const shutdownManager: ShutdownManager;
 /**

package/dist/lib/shutdown.js

@@ -10,6 +10,12 @@ class ShutdownManager {
         // Register signal handlers
         this.registerSignalHandlers();
     }
+    /**
+     * Check if shutdown is in progress
+     */
+    isShutdownInProgress() {
+        return this.isShuttingDown;
+    }
     /**
      * Register a cleanup function to be called on shutdown
      */
@@ -56,7 +62,7 @@ class ShutdownManager {
             return;
         }
         this.isShuttingDown = true;
-        logger.info({ signal, cleanupCount: this.cleanupFunctions.length }, 'Starting graceful shutdown');
+        logger.info({ cleanupCount: this.cleanupFunctions.length, signal }, 'Starting graceful shutdown');
         // Set timeout for shutdown
         const shutdownTimer = setTimeout(() => {
             logger.error({ timeout: this.shutdownTimeout }, 'Shutdown timeout exceeded, forcing exit');
@@ -83,12 +89,6 @@ class ShutdownManager {
             process.exit(1);
         }
     }
-    /**
-     * Check if shutdown is in progress
-     */
-    isShutdownInProgress() {
-        return this.isShuttingDown;
-    }
 }
 // Singleton instance
 export const shutdownManager = new ShutdownManager();

package/dist/lib/validation.d.ts

@@ -18,7 +18,7 @@ export declare function validatePrice(price: number): void;
 /**
  * Validate side
  */
-export declare function validateSide(side: string): 'yes' | 'no';
+export declare function validateSide(side: string): 'no' | 'yes';
 /**
  * Validate action
  */
@@ -26,12 +26,12 @@ export declare function validateAction(action: string): 'buy' | 'sell';
 /**
  * Validate order type
  */
-export declare function validateOrderType(type: string): 'market' | 'limit';
+export declare function validateOrderType(type: string): 'limit' | 'market';
 /**
  * Calculate order cost estimate
  */
-export declare function estimateOrderCost(side: 'yes' | 'no', action: 'buy' | 'sell', quantity: number, price?: number): {
-    min: number;
-    max: number;
+export declare function estimateOrderCost(side: 'no' | 'yes', action: 'buy' | 'sell', quantity: number, price?: number): {
     estimate: number;
+    max: number;
+    min: number;
 };

package/dist/lib/validation.js

@@ -18,8 +18,8 @@ export function validateTicker(ticker) {
     }
     if (ticker.length < 3 || ticker.length > 100) {
         throw new ValidationError('Ticker must be between 3 and 100 characters', {
-            ticker,
             length: ticker.length,
+            ticker,
         });
     }
 }
@@ -35,8 +35,8 @@ export function validateQuantity(quantity, maxOrderSize) {
     }
     if (quantity > maxOrderSize) {
         throw new ValidationError(`Quantity exceeds maximum order size of ${maxOrderSize}`, {
-            quantity,
             maxOrderSize,
+            quantity,
         });
     }
 }
@@ -52,8 +52,8 @@ export function validatePrice(price) {
     const decimalPlaces = (price.toString().split('.')[1] || '').length;
     if (decimalPlaces > 2) {
         throw new ValidationError('Price cannot have more than 2 decimal places', {
-            price,
             decimalPlaces,
+            price,
         });
     }
 }
@@ -97,24 +97,18 @@ export function estimateOrderCost(side, action, quantity, price) {
         if (price) {
             // Limit buy - exact price known
             const cost = quantity * price;
-            return { min: cost, max: cost, estimate: cost };
-        }
-        else {
-            // Market buy - could fill at any price
-            // Estimate mid-range
-            const estimate = quantity * 0.5;
-            return { min: quantity * 0.01, max: quantity * 0.99, estimate };
+            return { estimate: cost, max: cost, min: cost };
         }
+        // Market buy - could fill at any price
+        // Estimate mid-range
+        const estimate = quantity * 0.5;
+        return { estimate, max: quantity * 0.99, min: quantity * 0.01 };
     }
-    else {
-        // Sell orders
-        if (price) {
-            const proceeds = quantity * price;
-            return { min: proceeds, max: proceeds, estimate: proceeds };
-        }
-        else {
-            const estimate = quantity * 0.5;
-            return { min: quantity * 0.01, max: quantity * 0.99, estimate };
-        }
+    // Sell orders
+    if (price) {
+        const proceeds = quantity * price;
+        return { estimate: proceeds, max: proceeds, min: proceeds };
     }
+    const estimate = quantity * 0.5;
+    return { estimate, max: quantity * 0.99, min: quantity * 0.01 };
 }