@gaberoo/kalshitools 1.0.0

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

@@ -0,0 +1,86 @@
+import type { Balance, CreateOrderRequest, Fill, FillsQuery, Market, MarketsQuery, Order, OrderBook, OrdersQuery, Position } from './types.js';
+/**
+ * Kalshi API client
+ */
+export declare class KalshiClient {
+    private axios;
+    private auth;
+    private baseUrl;
+    constructor(baseUrl: string, keyId: string, privateKey: string);
+    /**
+     * Make a rate-limited GET request
+     */
+    private get;
+    /**
+     * Make a rate-limited POST request
+     */
+    private post;
+    /**
+     * Make a rate-limited DELETE request
+     */
+    private delete;
+    /**
+     * Get account balance
+     */
+    getBalance(): Promise<Balance>;
+    /**
+     * Get portfolio positions
+     */
+    getPositions(params?: {
+        ticker?: string;
+        settlement_status?: string;
+    }): Promise<Position[]>;
+    /**
+     * Get markets
+     */
+    getMarkets(query?: MarketsQuery): Promise<{
+        markets: Market[];
+        cursor?: string;
+    }>;
+    /**
+     * Get single market by ticker
+     */
+    getMarket(ticker: string): Promise<Market>;
+    /**
+     * Get order book for a market
+     */
+    getOrderBook(ticker: string, depth?: number): Promise<OrderBook>;
+    /**
+     * Get user orders
+     */
+    getOrders(query?: OrdersQuery): Promise<{
+        orders: Order[];
+        cursor?: string;
+    }>;
+    /**
+     * Get single order by ID
+     */
+    getOrder(orderId: string): Promise<Order>;
+    /**
+     * Create an order
+     */
+    createOrder(request: CreateOrderRequest): Promise<Order>;
+    /**
+     * Cancel an order
+     */
+    cancelOrder(orderId: string): Promise<Order>;
+    /**
+     * Get fills (executed trades)
+     */
+    getFills(query?: FillsQuery): Promise<{
+        fills: Fill[];
+        cursor?: string;
+    }>;
+    /**
+     * Test connection to API
+     */
+    testConnection(): Promise<boolean>;
+    /**
+     * Get the base URL
+     */
+    getBaseUrl(): string;
+}
+/**
+ * Create a Kalshi client instance
+ */
+export declare function createKalshiClient(baseUrl: string, keyId: string, privateKey: string): KalshiClient;

package/dist/lib/kalshi/client.js

@@ -0,0 +1,228 @@
+import axios from 'axios';
+import Bottleneck from 'bottleneck';
+import { APIError, NetworkError, RateLimitError, TimeoutError } from '../errors/base.js';
+import { logger } from '../logger.js';
+import { KalshiAuth } from './auth.js';
+/**
+ * Rate limiter configuration for Kalshi API
+ * Basic tier: 20 req/sec for reads, 10 req/sec for writes
+ */
+const READ_LIMITER = new Bottleneck({
+    maxConcurrent: 5,
+    minTime: 50, // 20 requests per second = 1000ms / 20 = 50ms
+    reservoir: 20,
+    reservoirRefreshAmount: 20,
+    reservoirRefreshInterval: 1000, // Refresh every second
+});
+const WRITE_LIMITER = new Bottleneck({
+    maxConcurrent: 3,
+    minTime: 100, // 10 requests per second = 1000ms / 10 = 100ms
+    reservoir: 10,
+    reservoirRefreshAmount: 10,
+    reservoirRefreshInterval: 1000,
+});
+/**
+ * Kalshi API client
+ */
+export class KalshiClient {
+    axios;
+    auth;
+    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',
+            },
+        });
+        // 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);
+            // Set auth headers
+            for (const [key, value] of Object.entries(authHeaders)) {
+                config.headers.set(key, value);
+            }
+            logger.debug({ method, path }, 'Making API request');
+            return config;
+        });
+        // Add response interceptor for error handling
+        this.axios.interceptors.response.use((response) => response, (error) => {
+            if (axios.isAxiosError(error)) {
+                if (error.code === 'ECONNABORTED') {
+                    throw new TimeoutError('Request timed out', {
+                        url: error.config?.url,
+                        timeout: error.config?.timeout,
+                    });
+                }
+                if (!error.response) {
+                    throw new NetworkError('Network error - no response received', {
+                        message: error.message,
+                    });
+                }
+                const status = error.response.status;
+                const data = error.response.data;
+                if (status === 429) {
+                    throw new RateLimitError('Rate limit exceeded', {
+                        status,
+                        retryAfter: error.response.headers['retry-after'],
+                    });
+                }
+                throw new APIError(data.error?.message || `API error: ${status}`, {
+                    status,
+                    code: data.error?.code,
+                    details: data.error?.details,
+                });
+            }
+            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
+     */
+    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;
+        });
+    }
+    /**
+     * Make a rate-limited DELETE request
+     */
+    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;
+        });
+    }
+    /**
+     * Get account balance
+     */
+    async getBalance() {
+        logger.info('Fetching account balance');
+        return this.get('/portfolio/balance');
+    }
+    /**
+     * Get portfolio positions
+     */
+    async getPositions(params) {
+        logger.info({ params }, 'Fetching portfolio positions');
+        return this.get('/portfolio/positions', { params });
+    }
+    /**
+     * Get markets
+     */
+    async getMarkets(query) {
+        logger.info({ query }, 'Fetching markets');
+        return this.get('/markets', { 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,
+        });
+    }
+    /**
+     * Get user orders
+     */
+    async getOrders(query) {
+        logger.info({ query }, 'Fetching orders');
+        return this.get('/portfolio/orders', { params: query });
+    }
+    /**
+     * Get single order by ID
+     */
+    async getOrder(orderId) {
+        logger.info({ orderId }, 'Fetching order details');
+        return this.get(`/portfolio/orders/${orderId}`);
+    }
+    /**
+     * Create an order
+     */
+    async createOrder(request) {
+        logger.info({ ticker: request.ticker, side: request.side, action: request.action }, 'Creating order');
+        return this.post('/portfolio/orders', request);
+    }
+    /**
+     * Cancel an order
+     */
+    async cancelOrder(orderId) {
+        logger.info({ orderId }, 'Canceling order');
+        return this.delete(`/portfolio/orders/${orderId}`);
+    }
+    /**
+     * Get fills (executed trades)
+     */
+    async getFills(query) {
+        logger.info({ query }, 'Fetching fills');
+        return this.get('/portfolio/fills', { params: query });
+    }
+    /**
+     * Test connection to API
+     */
+    async testConnection() {
+        try {
+            await this.getBalance();
+            logger.info('API connection test successful');
+            return true;
+        }
+        catch (error) {
+            logger.error({ error }, 'API connection test failed');
+            return false;
+        }
+    }
+    /**
+     * Get the base URL
+     */
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+}
+/**
+ * Create a Kalshi client instance
+ */
+export function createKalshiClient(baseUrl, keyId, privateKey) {
+    return new KalshiClient(baseUrl, keyId, privateKey);
+}

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

@@ -0,0 +1,8 @@
+import { KalshiClient } from './client.js';
+export * from './client.js';
+export * from './types.js';
+export * from './auth.js';
+/**
+ * Create a Kalshi client from the current configuration
+ */
+export declare function createClientFromConfig(): KalshiClient;

package/dist/lib/kalshi/index.js

@@ -0,0 +1,19 @@
+import { getConfig } from '../config/manager.js';
+import { logger } from '../logger.js';
+import { createKalshiClient } from './client.js';
+export * from './client.js';
+export * from './types.js';
+export * from './auth.js';
+/**
+ * Create a Kalshi client from the current configuration
+ */
+export function createClientFromConfig() {
+    const configManager = getConfig();
+    const apiConfig = configManager.getApiConfig();
+    const privateKey = configManager.readPrivateKey();
+    logger.info({
+        baseUrl: apiConfig.baseUrl,
+        environment: configManager.getEnvironment(),
+    }, 'Creating Kalshi client from config');
+    return createKalshiClient(apiConfig.baseUrl, apiConfig.keyId, privateKey);
+}

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

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

package/dist/lib/kalshi/types.js

@@ -0,0 +1,4 @@
+/**
+ * Kalshi API types and interfaces
+ */
+export {};

package/dist/lib/logger.d.ts

@@ -0,0 +1,9 @@
+import pino from 'pino';
+/**
+ * Create a logger instance with redaction for sensitive fields
+ */
+export declare function createLogger(options?: {
+    level?: string;
+    pretty?: boolean;
+}): pino.Logger<never, boolean>;
+export declare const logger: pino.Logger<never, boolean>;

package/dist/lib/logger.js

@@ -0,0 +1,41 @@
+import pino from 'pino';
+/**
+ * Create a logger instance with redaction for sensitive fields
+ */
+export function createLogger(options = {}) {
+    const { level = 'info', pretty = false } = options;
+    const pinoOptions = {
+        level,
+        // Redact sensitive fields
+        redact: {
+            paths: [
+                'keyId',
+                'privateKey',
+                'privateKeyPath',
+                'password',
+                'token',
+                'apiKey',
+                'api.*.keyId',
+                'api.*.privateKey',
+                'api.*.privateKeyPath',
+                '*.privateKey',
+                '*.password',
+                '*.token',
+            ],
+            censor: '[REDACTED]',
+        },
+    };
+    if (pretty) {
+        return pino(pinoOptions, pino.transport({
+            target: 'pino-pretty',
+            options: {
+                colorize: true,
+                translateTime: 'HH:MM:ss',
+                ignore: 'pid,hostname',
+            },
+        }));
+    }
+    return pino(pinoOptions);
+}
+// Default logger instance
+export const logger = createLogger({ level: process.env.LOG_LEVEL || 'info', pretty: true });

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

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