@gaberoo/kalshitools 1.0.1 → 1.0.3

package/dist/lib/kalshi/client.js

@@ -25,30 +25,35 @@ const WRITE_LIMITER = new Bottleneck({
  * Kalshi API client
  */
 export class KalshiClient {
-    axios;
     auth;
+    axios;
     baseUrl;
     constructor(baseUrl, keyId, privateKey) {
         this.baseUrl = baseUrl;
         this.auth = new KalshiAuth(keyId, privateKey);
         this.axios = axios.create({
             baseURL: baseUrl,
-            timeout: 30000, // 30 second default timeout
             headers: {
-                'Content-Type': 'application/json',
                 'Accept': 'application/json',
+                'Content-Type': 'application/json',
             },
+            timeout: 30_000, // 30 second default timeout
         });
         // Add request interceptor for authentication
         this.axios.interceptors.request.use((config) => {
             const method = (config.method || 'GET').toUpperCase();
-            const path = config.url || '/';
-            const authHeaders = this.auth.generateAuthHeaders(method, path);
+            // CRITICAL: Include baseURL pathname in signature
+            // Kalshi expects signature over full path: /trade-api/v2/portfolio/balance
+            // Not just the relative path: /portfolio/balance
+            const baseUrlPath = new URL(baseUrl).pathname;
+            const relativePath = config.url || '/';
+            const fullPath = baseUrlPath + relativePath;
+            const authHeaders = this.auth.generateAuthHeaders(method, fullPath);
             // Set auth headers
             for (const [key, value] of Object.entries(authHeaders)) {
                 config.headers.set(key, value);
             }
-            logger.debug({ method, path }, 'Making API request');
+            logger.debug({ method, path: fullPath }, 'Making API request');
             return config;
         });
         // Add response interceptor for error handling
@@ -56,8 +61,8 @@ export class KalshiClient {
             if (axios.isAxiosError(error)) {
                 if (error.code === 'ECONNABORTED') {
                     throw new TimeoutError('Request timed out', {
-                        url: error.config?.url,
                         timeout: error.config?.timeout,
+                        url: error.config?.url,
                     });
                 }
                 if (!error.response) {
@@ -65,67 +70,36 @@ export class KalshiClient {
                         message: error.message,
                     });
                 }
-                const status = error.response.status;
+                const { status } = error.response;
                 const data = error.response.data;
                 if (status === 429) {
                     throw new RateLimitError('Rate limit exceeded', {
-                        status,
                         retryAfter: error.response.headers['retry-after'],
+                        status,
                     });
                 }
                 throw new APIError(data.error?.message || `API error: ${status}`, {
-                    status,
                     code: data.error?.code,
                     details: data.error?.details,
+                    status,
                 });
             }
             throw error;
         });
     }
     /**
-     * Make a rate-limited GET request
-     */
-    async get(path, config) {
-        return READ_LIMITER.schedule(async () => {
-            const response = await this.axios.get(path, config);
-            if (response.data.error) {
-                throw new APIError(response.data.error.message, {
-                    code: response.data.error.code,
-                    details: response.data.error.details,
-                });
-            }
-            return response.data.data;
-        });
-    }
-    /**
-     * Make a rate-limited POST request
+     * Cancel an order
      */
-    async post(path, data, config) {
-        return WRITE_LIMITER.schedule(async () => {
-            const response = await this.axios.post(path, data, config);
-            if (response.data.error) {
-                throw new APIError(response.data.error.message, {
-                    code: response.data.error.code,
-                    details: response.data.error.details,
-                });
-            }
-            return response.data.data;
-        });
+    async cancelOrder(orderId) {
+        logger.info({ orderId }, 'Canceling order');
+        return this.delete(`/portfolio/orders/${orderId}`);
     }
     /**
-     * Make a rate-limited DELETE request
+     * Create an order
      */
-    async delete(path, config) {
-        return WRITE_LIMITER.schedule(async () => {
-            const response = await this.axios.delete(path, config);
-            if (response.data.error) {
-                throw new APIError(response.data.error.message, {
-                    code: response.data.error.code,
-                    details: response.data.error.details,
-                });
-            }
-            return response.data.data;
-        });
+    async createOrder(request) {
+        logger.info({ action: request.action, side: request.side, ticker: request.ticker }, 'Creating order');
+        return this.post('/portfolio/orders', request);
     }
     /**
      * Get account balance
@@ -135,41 +109,33 @@ export class KalshiClient {
         return this.get('/portfolio/balance');
     }
     /**
-     * Get portfolio positions
+     * Get the base URL
      */
-    async getPositions(params) {
-        logger.info({ params }, 'Fetching portfolio positions');
-        return this.get('/portfolio/positions', { params });
+    getBaseUrl() {
+        return this.baseUrl;
     }
     /**
-     * Get markets
+     * Get fills (executed trades)
      */
-    async getMarkets(query) {
-        logger.info({ query }, 'Fetching markets');
-        return this.get('/markets', { params: query });
+    async getFills(query) {
+        logger.info({ query }, 'Fetching fills');
+        return this.get('/portfolio/fills', { params: query });
     }
     /**
      * Get single market by ticker
      */
     async getMarket(ticker) {
         logger.info({ ticker }, 'Fetching market details');
-        return this.get(`/markets/${ticker}`);
-    }
-    /**
-     * Get order book for a market
-     */
-    async getOrderBook(ticker, depth) {
-        logger.info({ ticker, depth }, 'Fetching order book');
-        return this.get(`/markets/${ticker}/orderbook`, {
-            params: depth ? { depth } : undefined,
-        });
+        const response = await this.get(`/markets/${ticker}`);
+        // Kalshi returns { market: {...} }
+        return response.market;
     }
     /**
-     * Get user orders
+     * Get markets
      */
-    async getOrders(query) {
-        logger.info({ query }, 'Fetching orders');
-        return this.get('/portfolio/orders', { params: query });
+    async getMarkets(query) {
+        logger.info({ query }, 'Fetching markets');
+        return this.get('/markets', { params: query });
     }
     /**
      * Get single order by ID
@@ -179,25 +145,29 @@ export class KalshiClient {
         return this.get(`/portfolio/orders/${orderId}`);
     }
     /**
-     * Create an order
+     * Get order book for a market
      */
-    async createOrder(request) {
-        logger.info({ ticker: request.ticker, side: request.side, action: request.action }, 'Creating order');
-        return this.post('/portfolio/orders', request);
+    async getOrderBook(ticker, depth) {
+        logger.info({ depth, ticker }, 'Fetching order book');
+        return this.get(`/markets/${ticker}/orderbook`, {
+            params: depth ? { depth } : undefined,
+        });
     }
     /**
-     * Cancel an order
+     * Get user orders
      */
-    async cancelOrder(orderId) {
-        logger.info({ orderId }, 'Canceling order');
-        return this.delete(`/portfolio/orders/${orderId}`);
+    async getOrders(query) {
+        logger.info({ query }, 'Fetching orders');
+        return this.get('/portfolio/orders', { params: query });
     }
     /**
-     * Get fills (executed trades)
+     * Get portfolio positions
      */
-    async getFills(query) {
-        logger.info({ query }, 'Fetching fills');
-        return this.get('/portfolio/fills', { params: query });
+    async getPositions(params) {
+        logger.info({ params }, 'Fetching portfolio positions');
+        const response = await this.get('/portfolio/positions', { params });
+        // Kalshi returns { market_positions: [...] }, not just the array
+        return response.market_positions || [];
     }
     /**
      * Test connection to API
@@ -214,10 +184,55 @@ export class KalshiClient {
         }
     }
     /**
-     * Get the base URL
+     * Make a rate-limited DELETE request
      */
-    getBaseUrl() {
-        return this.baseUrl;
+    async delete(path, config) {
+        return WRITE_LIMITER.schedule(async () => {
+            const response = await this.axios.delete(path, config);
+            if (response.data.error) {
+                throw new APIError(response.data.error.message, {
+                    code: response.data.error.code,
+                    details: response.data.error.details,
+                });
+            }
+            // Kalshi API doesn't always wrap in a data envelope
+            // Return response.data.data if it exists, otherwise response.data
+            return (response.data.data ?? response.data);
+        });
+    }
+    /**
+     * Make a rate-limited GET request
+     */
+    async get(path, config) {
+        return READ_LIMITER.schedule(async () => {
+            const response = await this.axios.get(path, config);
+            if (response.data.error) {
+                throw new APIError(response.data.error.message, {
+                    code: response.data.error.code,
+                    details: response.data.error.details,
+                });
+            }
+            // Kalshi API doesn't always wrap in a data envelope
+            // Return response.data.data if it exists, otherwise response.data
+            return (response.data.data ?? response.data);
+        });
+    }
+    /**
+     * Make a rate-limited POST request
+     */
+    async post(path, data, config) {
+        return WRITE_LIMITER.schedule(async () => {
+            const response = await this.axios.post(path, data, config);
+            if (response.data.error) {
+                throw new APIError(response.data.error.message, {
+                    code: response.data.error.code,
+                    details: response.data.error.details,
+                });
+            }
+            // Kalshi API doesn't always wrap in a data envelope
+            // Return response.data.data if it exists, otherwise response.data
+            return (response.data.data ?? response.data);
+        });
     }
 }
 /**

package/dist/lib/kalshi/index.d.ts

@@ -1,7 +1,7 @@
 import { KalshiClient } from './client.js';
+export * from './auth.js';
 export * from './client.js';
 export * from './types.js';
-export * from './auth.js';
 /**
  * Create a Kalshi client from the current configuration
  */

package/dist/lib/kalshi/index.js

@@ -1,9 +1,9 @@
 import { getConfig } from '../config/manager.js';
 import { logger } from '../logger.js';
 import { createKalshiClient } from './client.js';
+export * from './auth.js';
 export * from './client.js';
 export * from './types.js';
-export * from './auth.js';
 /**
  * Create a Kalshi client from the current configuration
  */

package/dist/lib/kalshi/types.d.ts

@@ -8,8 +8,8 @@ export interface KalshiResponse<T> {
     data?: T;
     error?: {
         code: string;
-        message: string;
         details?: Record<string, unknown>;
+        message: string;
     };
 }
 /**
@@ -17,119 +17,119 @@ export interface KalshiResponse<T> {
  */
 export interface Balance {
     balance: number;
-    payout: number;
+    portfolio_value: number;
 }
 /**
  * Market data
  */
 export interface Market {
-    ticker: string;
+    close_time: string;
     event_ticker: string;
+    expiration_time: string;
+    last_price?: number;
+    liquidity?: number;
     market_type: string;
-    title: string;
-    subtitle: string;
+    no_ask?: number;
+    no_bid?: number;
     open_time: string;
-    close_time: string;
-    expiration_time: string;
-    status: 'active' | 'closed' | 'settled' | 'finalized';
-    result?: 'yes' | 'no';
+    result?: 'no' | 'yes';
+    status: 'active' | 'closed' | 'finalized' | 'settled';
+    subtitle: string;
+    ticker: string;
+    title: string;
     volume?: number;
     volume_24h?: number;
-    liquidity?: number;
-    yes_bid?: number;
     yes_ask?: number;
-    no_bid?: number;
-    no_ask?: number;
-    last_price?: number;
+    yes_bid?: number;
 }
 /**
  * Position data
  */
 export interface Position {
-    ticker: string;
+    fees_paid: number;
+    market_exposure: number;
     market_ticker: string;
     position: number;
-    market_exposure: number;
-    total_cost: number;
-    fees_paid: number;
     realized_pnl: number;
+    ticker: string;
+    total_cost: number;
 }
 /**
  * Order data
  */
 export interface Order {
-    order_id: string;
-    user_id: string;
-    ticker: string;
-    status: 'pending' | 'resting' | 'canceled' | 'executed' | 'expired';
-    yes_price?: number;
-    no_price?: number;
-    count: number;
-    side: 'yes' | 'no';
     action: 'buy' | 'sell';
-    type: 'market' | 'limit';
+    avg_fill_price?: number;
+    count: number;
     created_time: string;
-    updated_time: string;
     expiration_time?: string;
-    remaining_count: number;
     filled_count: number;
-    avg_fill_price?: number;
+    no_price?: number;
+    order_id: string;
+    remaining_count: number;
+    side: 'no' | 'yes';
+    status: 'canceled' | 'executed' | 'expired' | 'pending' | 'resting';
+    ticker: string;
+    type: 'limit' | 'market';
+    updated_time: string;
+    user_id: string;
+    yes_price?: number;
 }
 /**
  * Fill (executed trade) data
  */
 export interface Fill {
-    fill_id: string;
-    order_id: string;
-    ticker: string;
-    side: 'yes' | 'no';
     action: 'buy' | 'sell';
     count: number;
-    price: number;
     created_time: string;
+    fill_id: string;
     is_taker: boolean;
+    order_id: string;
+    price: number;
+    side: 'no' | 'yes';
+    ticker: string;
     trade_id: string;
 }
 /**
  * Order book level
  */
 export interface OrderBookLevel {
-    price: number;
     count: number;
+    price: number;
 }
 /**
  * Order book data
  */
 export interface OrderBook {
+    no: OrderBookLevel[];
     ticker: string;
     yes: OrderBookLevel[];
-    no: OrderBookLevel[];
 }
 /**
  * Create order request
  */
 export interface CreateOrderRequest {
-    ticker: string;
-    client_order_id?: string;
-    side: 'yes' | 'no';
     action: 'buy' | 'sell';
+    buy_max_cost?: number;
+    client_order_id?: string;
     count: number;
-    type: 'market' | 'limit';
-    yes_price?: number;
-    no_price?: number;
     expiration_ts?: number;
+    no_price?: number;
     sell_position_floor?: number;
-    buy_max_cost?: number;
+    side: 'no' | 'yes';
+    ticker: string;
+    type: 'limit' | 'market';
+    yes_price?: number;
 }
 /**
  * Markets query parameters
  */
 export interface MarketsQuery {
-    limit?: number;
     cursor?: string;
     event_ticker?: string;
+    limit?: number;
     series_ticker?: string;
-    status?: 'active' | 'closed' | 'settled' | 'finalized';
+    status?: 'active' | 'closed' | 'finalized' | 'settled';
     tickers?: string;
     with_nested_markets?: boolean;
 }
@@ -137,19 +137,19 @@ export interface MarketsQuery {
  * Orders query parameters
  */
 export interface OrdersQuery {
-    ticker?: string;
-    status?: 'pending' | 'resting' | 'canceled' | 'executed' | 'expired';
-    limit?: number;
     cursor?: string;
+    limit?: number;
+    status?: 'canceled' | 'executed' | 'expired' | 'pending' | 'resting';
+    ticker?: string;
 }
 /**
  * Fills query parameters
  */
 export interface FillsQuery {
-    ticker?: string;
-    order_id?: string;
-    min_ts?: number;
-    max_ts?: number;
-    limit?: number;
     cursor?: string;
+    limit?: number;
+    max_ts?: number;
+    min_ts?: number;
+    order_id?: string;
+    ticker?: string;
 }

package/dist/lib/logger.js

@@ -8,6 +8,7 @@ export function createLogger(options = {}) {
         level,
         // Redact sensitive fields
         redact: {
+            censor: '[REDACTED]',
             paths: [
                 'keyId',
                 'privateKey',
@@ -22,17 +23,16 @@ export function createLogger(options = {}) {
                 '*.password',
                 '*.token',
             ],
-            censor: '[REDACTED]',
         },
     };
     if (pretty) {
         return pino(pinoOptions, pino.transport({
-            target: 'pino-pretty',
             options: {
                 colorize: true,
-                translateTime: 'HH:MM:ss',
                 ignore: 'pid,hostname',
+                translateTime: 'HH:MM:ss',
             },
+            target: 'pino-pretty',
         }));
     }
     return pino(pinoOptions);

package/dist/lib/output/formatter.d.ts

@@ -3,67 +3,67 @@ import Table from 'cli-table3';
  * Standard success response structure
  */
 export interface SuccessResponse<T = unknown> {
-    success: true;
     data: T;
     metadata: {
-        timestamp: string;
         command?: string;
         duration_ms?: number;
+        timestamp: string;
     };
+    success: true;
 }
 /**
  * Standard error response structure
  */
 export interface ErrorResponse {
-    success: false;
     error: {
         code: string;
-        message: string;
         details?: Record<string, unknown>;
+        message: string;
     };
     metadata: {
-        timestamp: string;
         command?: string;
+        timestamp: string;
     };
+    success: false;
 }
 /**
  * Output formatter for both human and JSON formats
  */
 export declare class OutputFormatter {
+    private command?;
     private jsonMode;
     private startTime;
-    private command?;
     constructor(jsonMode?: boolean, command?: string);
     /**
-     * Output a success response
+     * Create an error response object
      */
-    success<T>(data: T): void;
+    createErrorResponse(code: string, message: string, details?: Record<string, unknown>): ErrorResponse;
     /**
-     * Output an error response
+     * Create a success response object
      */
-    error(code: string, message: string, details?: Record<string, unknown>): void;
+    createSuccessResponse<T>(data: T): SuccessResponse<T>;
     /**
      * Create a table for human-readable output
      */
     createTable(head: string[], rows: string[][]): Table.Table;
     /**
-     * Output a table
+     * Output an error response
      */
-    outputTable(head: string[], rows: string[][]): void;
+    error(code: string, message: string, details?: Record<string, unknown>): void;
     /**
-     * Create a success response object
+     * Check if JSON mode is enabled
      */
-    createSuccessResponse<T>(data: T): SuccessResponse<T>;
+    isJSONMode(): boolean;
     /**
-     * Create an error response object
+     * Output a table
      */
-    createErrorResponse(code: string, message: string, details?: Record<string, unknown>): ErrorResponse;
+    outputTable(head: string[], rows: string[][]): void;
     /**
-     * Output JSON to stdout
+     * Output a success response
      */
-    private outputJSON;
+    success<T>(data: T): void;
     /**
-     * Check if JSON mode is enabled
+     * Output JSON to stdout
      */
-    isJSONMode(): boolean;
+    private outputJSON;
 }