pmxt-core 0.0.1

package/.env

@@ -0,0 +1,5 @@
+# Polymarket
+POLYMARKET_PRIVATE_KEY=0x331917d429ce4dbbf046c6a29b76b1818b975e6479df4feb396c5881509d6577
+
+# Kalshi
+KALSHI_API_KEY=0x/NA

package/dist/BaseExchange.d.ts

@@ -0,0 +1,74 @@
+import { UnifiedMarket, PriceCandle, CandleInterval, OrderBook, Trade, Order, Position, Balance, CreateOrderParams } from './types';
+export interface MarketFilterParams {
+    limit?: number;
+    offset?: number;
+    sort?: 'volume' | 'liquidity' | 'newest';
+    searchIn?: 'title' | 'description' | 'both';
+}
+export interface HistoryFilterParams {
+    resolution: CandleInterval;
+    start?: Date;
+    end?: Date;
+    limit?: number;
+}
+export interface ExchangeCredentials {
+    apiKey?: string;
+    apiSecret?: string;
+    passphrase?: string;
+    privateKey?: string;
+    signatureType?: number;
+    funderAddress?: string;
+}
+export declare abstract class PredictionMarketExchange {
+    protected credentials?: ExchangeCredentials;
+    constructor(credentials?: ExchangeCredentials);
+    abstract get name(): string;
+    /**
+     * Fetch all relevant markets from the source.
+     */
+    abstract fetchMarkets(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    /**
+     * Search for markets matching a keyword query.
+     * By default, searches only in market titles. Use params.searchIn to search descriptions or both.
+     */
+    abstract searchMarkets(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    /**
+     * Fetch historical price data for a specific market outcome.
+     * @param id - The Outcome ID (MarketOutcome.id). This should be the ID of the specific tradeable asset.
+     */
+    fetchOHLCV(id: string, params: HistoryFilterParams): Promise<PriceCandle[]>;
+    /**
+     * Fetch the current order book (bids/asks) for a specific outcome.
+     * Essential for calculating localized spread and depth.
+     */
+    fetchOrderBook(id: string): Promise<OrderBook>;
+    /**
+     * Fetch raw trade history.
+     */
+    fetchTrades(id: string, params: HistoryFilterParams): Promise<Trade[]>;
+    /**
+     * Place a new order.
+     */
+    createOrder(params: CreateOrderParams): Promise<Order>;
+    /**
+     * Cancel an existing order.
+     */
+    cancelOrder(orderId: string): Promise<Order>;
+    /**
+     * Fetch a specific order by ID.
+     */
+    fetchOrder(orderId: string): Promise<Order>;
+    /**
+     * Fetch all open orders.
+     * @param marketId - Optional filter by market.
+     */
+    fetchOpenOrders(marketId?: string): Promise<Order[]>;
+    /**
+     * Fetch current user positions.
+     */
+    fetchPositions(): Promise<Position[]>;
+    /**
+     * Fetch account balances.
+     */
+    fetchBalance(): Promise<Balance[]>;
+}

package/dist/BaseExchange.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredictionMarketExchange = void 0;
+// ----------------------------------------------------------------------------
+// Base Exchange Class
+// ----------------------------------------------------------------------------
+class PredictionMarketExchange {
+    constructor(credentials) {
+        this.credentials = credentials;
+    }
+    /**
+     * Fetch historical price data for a specific market outcome.
+     * @param id - The Outcome ID (MarketOutcome.id). This should be the ID of the specific tradeable asset.
+     */
+    async fetchOHLCV(id, params) {
+        throw new Error("Method fetchOHLCV not implemented.");
+    }
+    /**
+     * Fetch the current order book (bids/asks) for a specific outcome.
+     * Essential for calculating localized spread and depth.
+     */
+    async fetchOrderBook(id) {
+        throw new Error("Method fetchOrderBook not implemented.");
+    }
+    /**
+     * Fetch raw trade history.
+     */
+    async fetchTrades(id, params) {
+        throw new Error("Method fetchTrades not implemented.");
+    }
+    // ----------------------------------------------------------------------------
+    // Trading Methods
+    // ----------------------------------------------------------------------------
+    /**
+     * Place a new order.
+     */
+    async createOrder(params) {
+        throw new Error("Method createOrder not implemented.");
+    }
+    /**
+     * Cancel an existing order.
+     */
+    async cancelOrder(orderId) {
+        throw new Error("Method cancelOrder not implemented.");
+    }
+    /**
+     * Fetch a specific order by ID.
+     */
+    async fetchOrder(orderId) {
+        throw new Error("Method fetchOrder not implemented.");
+    }
+    /**
+     * Fetch all open orders.
+     * @param marketId - Optional filter by market.
+     */
+    async fetchOpenOrders(marketId) {
+        throw new Error("Method fetchOpenOrders not implemented.");
+    }
+    /**
+     * Fetch current user positions.
+     */
+    async fetchPositions() {
+        throw new Error("Method fetchPositions not implemented.");
+    }
+    /**
+     * Fetch account balances.
+     */
+    async fetchBalance() {
+        throw new Error("Method fetchBalance not implemented.");
+    }
+}
+exports.PredictionMarketExchange = PredictionMarketExchange;

package/dist/exchanges/kalshi/auth.d.ts

@@ -0,0 +1,23 @@
+import { ExchangeCredentials } from '../../BaseExchange';
+/**
+ * Manages Kalshi authentication using RSA-PSS signatures.
+ * Reference: https://docs.kalshi.com/getting_started/quick_start_authenticated_requests
+ */
+export declare class KalshiAuth {
+    private credentials;
+    constructor(credentials: ExchangeCredentials);
+    private validateCredentials;
+    /**
+     * Generates the required headers for an authenticated request.
+     *
+     * @param method The HTTP method (e.g., "GET", "POST").
+     * @param path The request path (e.g., "/trade-api/v2/portfolio/orders").
+     * @returns An object containing the authentication headers.
+     */
+    getHeaders(method: string, path: string): Record<string, string>;
+    /**
+     * Signs the request using RSA-PSS.
+     * The message to sign is: timestamp + method + path
+     */
+    private signRequest;
+}

package/dist/exchanges/kalshi/auth.js

@@ -0,0 +1,99 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KalshiAuth = void 0;
+const crypto = __importStar(require("crypto"));
+/**
+ * Manages Kalshi authentication using RSA-PSS signatures.
+ * Reference: https://docs.kalshi.com/getting_started/quick_start_authenticated_requests
+ */
+class KalshiAuth {
+    constructor(credentials) {
+        this.credentials = credentials;
+        this.validateCredentials();
+    }
+    validateCredentials() {
+        if (!this.credentials.apiKey) {
+            throw new Error('Kalshi requires an apiKey (Key ID) for authentication');
+        }
+        if (!this.credentials.privateKey) {
+            throw new Error('Kalshi requires a privateKey (RSA Private Key) for authentication');
+        }
+    }
+    /**
+     * Generates the required headers for an authenticated request.
+     *
+     * @param method The HTTP method (e.g., "GET", "POST").
+     * @param path The request path (e.g., "/trade-api/v2/portfolio/orders").
+     * @returns An object containing the authentication headers.
+     */
+    getHeaders(method, path) {
+        const timestamp = Date.now().toString();
+        const signature = this.signRequest(timestamp, method, path);
+        return {
+            'KALSHI-ACCESS-KEY': this.credentials.apiKey,
+            'KALSHI-ACCESS-TIMESTAMP': timestamp,
+            'KALSHI-ACCESS-SIGNATURE': signature,
+            'Content-Type': 'application/json'
+        };
+    }
+    /**
+     * Signs the request using RSA-PSS.
+     * The message to sign is: timestamp + method + path
+     */
+    signRequest(timestamp, method, path) {
+        const payload = `${timestamp}${method}${path}`;
+        try {
+            const signer = crypto.createSign('SHA256');
+            signer.update(payload);
+            // Allow input of private key in both raw string or PEM format
+            // If it's a raw key without headers, accessing it might be tricky with implicit types,
+            // but standard PEM is best. We assume the user provides a valid PEM.
+            const privateKey = this.credentials.privateKey;
+            // Kalshi uses RSA-PSS for signing
+            const signature = signer.sign({
+                key: privateKey,
+                padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
+                saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST
+            }, 'base64');
+            return signature;
+        }
+        catch (error) {
+            console.error('Error signing Kalshi request:', error);
+            throw new Error(`Failed to sign Kalshi request: ${error.message}`);
+        }
+    }
+}
+exports.KalshiAuth = KalshiAuth;

package/dist/exchanges/kalshi/fetchMarkets.d.ts

@@ -0,0 +1,3 @@
+import { MarketFilterParams } from '../../BaseExchange';
+import { UnifiedMarket } from '../../types';
+export declare function fetchMarkets(params?: MarketFilterParams): Promise<UnifiedMarket[]>;

package/dist/exchanges/kalshi/fetchMarkets.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchMarkets = fetchMarkets;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+async function fetchActiveEvents(targetMarketCount) {
+    let allEvents = [];
+    let totalMarketCount = 0;
+    let cursor = null;
+    let page = 0;
+    // Note: Kalshi API uses cursor-based pagination which requires sequential fetching.
+    // We cannot parallelize requests for a single list because we need the cursor from page N to fetch page N+1.
+    // To optimize, we use the maximum allowed limit (200) and fetch until exhaustion.
+    const MAX_PAGES = 1000; // Safety cap against infinite loops
+    const BATCH_SIZE = 200; // Max limit per Kalshi API docs
+    do {
+        try {
+            const queryParams = {
+                limit: BATCH_SIZE,
+                with_nested_markets: true,
+                status: 'open' // Filter to open markets to improve relevance and speed
+            };
+            if (cursor)
+                queryParams.cursor = cursor;
+            const response = await axios_1.default.get(utils_1.KALSHI_API_URL, { params: queryParams });
+            const events = response.data.events || [];
+            if (events.length === 0)
+                break;
+            allEvents = allEvents.concat(events);
+            // Count markets in this batch for early termination
+            if (targetMarketCount) {
+                for (const event of events) {
+                    totalMarketCount += (event.markets || []).length;
+                }
+                // Early termination: if we have enough markets, stop fetching
+                if (totalMarketCount >= targetMarketCount * 2) {
+                    break;
+                }
+            }
+            cursor = response.data.cursor;
+            page++;
+        }
+        catch (e) {
+            console.error(`Error fetching Kalshi page ${page}:`, e);
+            break;
+        }
+    } while (cursor && page < MAX_PAGES);
+    return allEvents;
+}
+async function fetchSeriesMap() {
+    try {
+        const response = await axios_1.default.get(utils_1.KALSHI_SERIES_URL);
+        const seriesList = response.data.series || [];
+        const map = new Map();
+        for (const series of seriesList) {
+            if (series.tags && series.tags.length > 0) {
+                map.set(series.ticker, series.tags);
+            }
+        }
+        return map;
+    }
+    catch (e) {
+        console.error("Error fetching Kalshi series:", e);
+        return new Map();
+    }
+}
+async function fetchMarkets(params) {
+    const limit = params?.limit || 50;
+    try {
+        // Fetch active events with nested markets
+        // We also fetch Series metadata to get tags (tags are on Series, not Event)
+        const [allEvents, seriesMap] = await Promise.all([
+            fetchActiveEvents(limit),
+            fetchSeriesMap()
+        ]);
+        // Extract ALL markets from all events
+        const allMarkets = [];
+        for (const event of allEvents) {
+            // Enrich event with tags from Series
+            if (event.series_ticker && seriesMap.has(event.series_ticker)) {
+                // If event has no tags or empty tags, use series tags
+                if (!event.tags || event.tags.length === 0) {
+                    event.tags = seriesMap.get(event.series_ticker);
+                }
+            }
+            const markets = event.markets || [];
+            for (const market of markets) {
+                const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market);
+                if (unifiedMarket) {
+                    allMarkets.push(unifiedMarket);
+                }
+            }
+        }
+        // Sort by 24h volume
+        if (params?.sort === 'volume') {
+            allMarkets.sort((a, b) => b.volume24h - a.volume24h);
+        }
+        else if (params?.sort === 'liquidity') {
+            allMarkets.sort((a, b) => b.liquidity - a.liquidity);
+        }
+        return allMarkets.slice(0, limit);
+    }
+    catch (error) {
+        console.error("Error fetching Kalshi data:", error);
+        return [];
+    }
+}

package/dist/exchanges/kalshi/fetchOHLCV.d.ts

@@ -0,0 +1,3 @@
+import { HistoryFilterParams } from '../../BaseExchange';
+import { PriceCandle } from '../../types';
+export declare function fetchOHLCV(id: string, params: HistoryFilterParams): Promise<PriceCandle[]>;

package/dist/exchanges/kalshi/fetchOHLCV.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOHLCV = fetchOHLCV;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+async function fetchOHLCV(id, params) {
+    try {
+        // Kalshi API expects uppercase tickers
+        // Handle virtual "-NO" suffix by stripping it (fetching the underlying market history)
+        const cleanedId = id.replace(/-NO$/, '');
+        const normalizedId = cleanedId.toUpperCase();
+        const interval = (0, utils_1.mapIntervalToKalshi)(params.resolution);
+        // Heuristic for series_ticker
+        const parts = normalizedId.split('-');
+        if (parts.length < 2) {
+            throw new Error(`Invalid Kalshi Ticker format: "${id}". Expected format like "FED-25JAN29-B4.75".`);
+        }
+        const seriesTicker = parts.slice(0, -1).join('-');
+        const url = `https://api.elections.kalshi.com/trade-api/v2/series/${seriesTicker}/markets/${normalizedId}/candlesticks`;
+        const queryParams = { period_interval: interval };
+        const now = Math.floor(Date.now() / 1000);
+        let startTs = now - (24 * 60 * 60);
+        let endTs = now;
+        if (params.start) {
+            startTs = Math.floor(params.start.getTime() / 1000);
+        }
+        if (params.end) {
+            endTs = Math.floor(params.end.getTime() / 1000);
+            if (!params.start) {
+                startTs = endTs - (24 * 60 * 60);
+            }
+        }
+        queryParams.start_ts = startTs;
+        queryParams.end_ts = endTs;
+        const response = await axios_1.default.get(url, { params: queryParams });
+        const candles = response.data.candlesticks || [];
+        const mappedCandles = candles.map((c) => {
+            // Priority:
+            // 1. Transaction price (close)
+            // 2. Mid price (average of yes_ask and yes_bid close)
+            // 3. Fallback to 0 if everything is missing
+            const p = c.price || {};
+            const ask = c.yes_ask || {};
+            const bid = c.yes_bid || {};
+            const getVal = (field) => {
+                if (p[field] !== null && p[field] !== undefined)
+                    return p[field];
+                if (ask[field] !== null && bid[field] !== null && ask[field] !== undefined && bid[field] !== undefined) {
+                    return (ask[field] + bid[field]) / 2;
+                }
+                return p.previous || 0;
+            };
+            return {
+                timestamp: c.end_period_ts * 1000,
+                open: getVal('open') / 100,
+                high: getVal('high') / 100,
+                low: getVal('low') / 100,
+                close: getVal('close') / 100,
+                volume: c.volume || 0
+            };
+        });
+        if (params.limit && mappedCandles.length > params.limit) {
+            return mappedCandles.slice(-params.limit);
+        }
+        return mappedCandles;
+    }
+    catch (error) {
+        if (axios_1.default.isAxiosError(error) && error.response) {
+            const apiError = error.response.data?.error || error.response.data?.message || "Unknown API Error";
+            throw new Error(`Kalshi History API Error (${error.response.status}): ${apiError}. Used Ticker: ${id}`);
+        }
+        console.error(`Unexpected error fetching Kalshi history for ${id}:`, error);
+        throw error;
+    }
+}

package/dist/exchanges/kalshi/fetchOrderBook.d.ts

@@ -0,0 +1,2 @@
+import { OrderBook } from '../../types';
+export declare function fetchOrderBook(id: string): Promise<OrderBook>;

package/dist/exchanges/kalshi/fetchOrderBook.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOrderBook = fetchOrderBook;
+const axios_1 = __importDefault(require("axios"));
+async function fetchOrderBook(id) {
+    try {
+        const ticker = id.replace(/-NO$/, '');
+        const url = `https://api.elections.kalshi.com/trade-api/v2/markets/${ticker}/orderbook`;
+        const response = await axios_1.default.get(url);
+        const data = response.data.orderbook;
+        // Structure: { yes: [[price, qty], ...], no: [[price, qty], ...] }
+        const bids = (data.yes || []).map((level) => ({
+            price: level[0] / 100,
+            size: level[1]
+        }));
+        const asks = (data.no || []).map((level) => ({
+            price: (100 - level[0]) / 100,
+            size: level[1]
+        }));
+        // Sort bids desc, asks asc
+        bids.sort((a, b) => b.price - a.price);
+        asks.sort((a, b) => a.price - b.price);
+        return { bids, asks, timestamp: Date.now() };
+    }
+    catch (error) {
+        console.error(`Error fetching Kalshi orderbook for ${id}:`, error);
+        return { bids: [], asks: [] };
+    }
+}

package/dist/exchanges/kalshi/fetchTrades.d.ts

@@ -0,0 +1,3 @@
+import { HistoryFilterParams } from '../../BaseExchange';
+import { Trade } from '../../types';
+export declare function fetchTrades(id: string, params: HistoryFilterParams): Promise<Trade[]>;

package/dist/exchanges/kalshi/fetchTrades.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTrades = fetchTrades;
+const axios_1 = __importDefault(require("axios"));
+async function fetchTrades(id, params) {
+    try {
+        const ticker = id.replace(/-NO$/, '');
+        const url = `https://api.elections.kalshi.com/trade-api/v2/markets/trades`;
+        const response = await axios_1.default.get(url, {
+            params: {
+                ticker: ticker,
+                limit: params.limit || 100
+            }
+        });
+        const trades = response.data.trades || [];
+        return trades.map((t) => ({
+            id: t.trade_id,
+            timestamp: new Date(t.created_time).getTime(),
+            price: t.yes_price / 100,
+            amount: t.count,
+            side: t.taker_side === 'yes' ? 'buy' : 'sell'
+        }));
+    }
+    catch (error) {
+        console.error(`Error fetching Kalshi trades for ${id}:`, error);
+        return [];
+    }
+}

package/dist/exchanges/kalshi/getMarketsBySlug.d.ts

@@ -0,0 +1,7 @@
+import { UnifiedMarket } from '../../types';
+/**
+ * Fetch specific markets by their event ticker.
+ * Useful for looking up a specific event from a URL.
+ * @param eventTicker - The event ticker (e.g. "FED-25JAN" or "PRES-2024")
+ */
+export declare function getMarketsBySlug(eventTicker: string): Promise<UnifiedMarket[]>;

package/dist/exchanges/kalshi/getMarketsBySlug.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarketsBySlug = getMarketsBySlug;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+/**
+ * Fetch specific markets by their event ticker.
+ * Useful for looking up a specific event from a URL.
+ * @param eventTicker - The event ticker (e.g. "FED-25JAN" or "PRES-2024")
+ */
+async function getMarketsBySlug(eventTicker) {
+    try {
+        // Kalshi API expects uppercase tickers, but URLs use lowercase
+        const normalizedTicker = eventTicker.toUpperCase();
+        const url = `https://api.elections.kalshi.com/trade-api/v2/events/${normalizedTicker}`;
+        const response = await axios_1.default.get(url, {
+            params: { with_nested_markets: true }
+        });
+        const event = response.data.event;
+        if (!event)
+            return [];
+        // Enrichment: Fetch series tags if they exist
+        if (event.series_ticker) {
+            try {
+                const seriesUrl = `${utils_1.KALSHI_SERIES_URL}/${event.series_ticker}`;
+                const seriesResponse = await axios_1.default.get(seriesUrl);
+                const series = seriesResponse.data.series;
+                if (series && series.tags && series.tags.length > 0) {
+                    if (!event.tags || event.tags.length === 0) {
+                        event.tags = series.tags;
+                    }
+                }
+            }
+            catch (e) {
+                // Ignore errors fetching series info - non-critical
+            }
+        }
+        const unifiedMarkets = [];
+        const markets = event.markets || [];
+        for (const market of markets) {
+            const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market);
+            if (unifiedMarket) {
+                unifiedMarkets.push(unifiedMarket);
+            }
+        }
+        return unifiedMarkets;
+    }
+    catch (error) {
+        if (axios_1.default.isAxiosError(error) && error.response) {
+            if (error.response.status === 404) {
+                throw new Error(`Kalshi event not found: "${eventTicker}". Check that the event ticker is correct.`);
+            }
+            const apiError = error.response.data?.error || error.response.data?.message || "Unknown API Error";
+            throw new Error(`Kalshi API Error (${error.response.status}): ${apiError}. Event Ticker: ${eventTicker}`);
+        }
+        console.error(`Unexpected error fetching Kalshi event ${eventTicker}:`, error);
+        throw error;
+    }
+}

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

@@ -0,0 +1,21 @@
+import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, ExchangeCredentials } from '../../BaseExchange';
+import { UnifiedMarket, PriceCandle, OrderBook, Trade, Balance, Order, Position, CreateOrderParams } from '../../types';
+export declare class KalshiExchange extends PredictionMarketExchange {
+    private auth?;
+    constructor(credentials?: ExchangeCredentials);
+    get name(): string;
+    private ensureAuth;
+    fetchMarkets(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    searchMarkets(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    getMarketsBySlug(slug: string): Promise<UnifiedMarket[]>;
+    fetchOHLCV(id: string, params: HistoryFilterParams): Promise<PriceCandle[]>;
+    fetchOrderBook(id: string): Promise<OrderBook>;
+    fetchTrades(id: string, params: HistoryFilterParams): Promise<Trade[]>;
+    fetchBalance(): Promise<Balance[]>;
+    createOrder(params: CreateOrderParams): Promise<Order>;
+    cancelOrder(orderId: string): Promise<Order>;
+    fetchOrder(orderId: string): Promise<Order>;
+    fetchOpenOrders(marketId?: string): Promise<Order[]>;
+    fetchPositions(): Promise<Position[]>;
+    private mapKalshiOrderStatus;
+}