pmxt-core 2.0.0-b0 → 2.0.0-b10

package/dist/BaseExchange.d.ts

@@ -5,10 +5,12 @@ export interface MarketFilterParams {
     offset?: number;
     sort?: 'volume' | 'liquidity' | 'newest';
     searchIn?: 'title' | 'description' | 'both';
-}
-export interface MarketFetchParams extends MarketFilterParams {
     query?: string;
     slug?: string;
+    page?: number;
+    similarityThreshold?: number;
+}
+export interface MarketFetchParams extends MarketFilterParams {
 }
 export interface EventFetchParams {
     query?: string;
@@ -126,44 +128,15 @@ export declare abstract class PredictionMarketExchange {
     fetchEvents(params?: EventFetchParams): Promise<UnifiedEvent[]>;
     /**
      * @internal
-     * Implementation for fetching all markets.
-     */
-    protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
-    /**
-     * @internal
-     * Implementation for searching markets by keyword.
-     */
-    protected searchMarketsImpl(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]>;
-    /**
-     * @internal
-     * Implementation for fetching markets by slug/ticker.
+     * Implementation for fetching/searching markets.
+     * Exchanges should handle query, slug, and plain fetch cases based on params.
      */
-    protected fetchMarketsBySlugImpl(slug: string): Promise<UnifiedMarket[]>;
+    protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     /**
      * @internal
      * Implementation for searching events by keyword.
      */
-    protected searchEventsImpl(query: string, params?: MarketFilterParams | EventFetchParams): Promise<UnifiedEvent[]>;
-    /**
-     * @deprecated Use fetchMarkets({ query: '...' }) instead. Will be removed in v2.0
-     * Search for markets matching a keyword query.
-     * By default, searches only in market titles. Use params.searchIn to search descriptions or both.
-     */
-    searchMarkets(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]>;
-    /**
-     * @deprecated Use fetchMarkets({ slug: '...' }) instead. Will be removed in v2.0
-     * Fetch markets by URL slug (Polymarket) or ticker (Kalshi).
-     * @param slug - Market slug or ticker
-     */
-    getMarketsBySlug(slug: string): Promise<UnifiedMarket[]>;
-    /**
-     * @deprecated Use fetchEvents({ query: '...' }) instead. Will be removed in v2.0
-     * Search for events matching a keyword query.
-     * Returns grouped events, each containing related markets.
-     * @param query - Search term
-     * @param params - Optional filter parameters
-     */
-    searchEvents(query: string, params?: MarketFilterParams): Promise<UnifiedEvent[]>;
+    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
     /**
      * 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.

package/dist/BaseExchange.js

@@ -32,13 +32,6 @@ class PredictionMarketExchange {
      * await exchange.fetchMarkets({ slug: 'will-trump-win' })
      */
     async fetchMarkets(params) {
-        // Route based on params
-        if (params?.slug) {
-            return this.fetchMarketsBySlugImpl(params.slug);
-        }
-        if (params?.query) {
-            return this.searchMarketsImpl(params.query, params);
-        }
         return this.fetchMarketsImpl(params);
     }
     /**
@@ -56,73 +49,28 @@ class PredictionMarketExchange {
      * await exchange.fetchEvents({ query: 'Election' })
      */
     async fetchEvents(params) {
-        if (params?.query) {
-            return this.searchEventsImpl(params.query, params);
+        if (!params?.query) {
+            throw new Error("fetchEvents() requires a query parameter");
         }
-        throw new Error("fetchEvents() requires a query parameter");
+        return this.fetchEventsImpl(params);
     }
     // ----------------------------------------------------------------------------
     // Implementation methods (to be overridden by exchanges)
     // ----------------------------------------------------------------------------
     /**
      * @internal
-     * Implementation for fetching all markets.
+     * Implementation for fetching/searching markets.
+     * Exchanges should handle query, slug, and plain fetch cases based on params.
      */
     async fetchMarketsImpl(params) {
         throw new Error("Method fetchMarketsImpl not implemented.");
     }
-    /**
-     * @internal
-     * Implementation for searching markets by keyword.
-     */
-    async searchMarketsImpl(query, params) {
-        throw new Error("Method searchMarketsImpl not implemented.");
-    }
-    /**
-     * @internal
-     * Implementation for fetching markets by slug/ticker.
-     */
-    async fetchMarketsBySlugImpl(slug) {
-        throw new Error("Method fetchMarketsBySlugImpl not implemented.");
-    }
     /**
      * @internal
      * Implementation for searching events by keyword.
      */
-    async searchEventsImpl(query, params) {
-        throw new Error("Method searchEventsImpl not implemented.");
-    }
-    // ----------------------------------------------------------------------------
-    // Deprecated methods (kept for backward compatibility)
-    // ----------------------------------------------------------------------------
-    /**
-     * @deprecated Use fetchMarkets({ query: '...' }) instead. Will be removed in v2.0
-     * Search for markets matching a keyword query.
-     * By default, searches only in market titles. Use params.searchIn to search descriptions or both.
-     */
-    async searchMarkets(query, params) {
-        console.warn('⚠️  searchMarkets() is deprecated. Use fetchMarkets({ query: "..." }) instead.');
-        return this.fetchMarkets({ ...params, query });
-    }
-    /**
-     * @deprecated Use fetchMarkets({ slug: '...' }) instead. Will be removed in v2.0
-     * Fetch markets by URL slug (Polymarket) or ticker (Kalshi).
-     * @param slug - Market slug or ticker
-     */
-    async getMarketsBySlug(slug) {
-        console.warn('⚠️  getMarketsBySlug() is deprecated. Use fetchMarkets({ slug: "..." }) instead.');
-        return this.fetchMarkets({ slug });
-    }
-    /**
-     * @deprecated Use fetchEvents({ query: '...' }) instead. Will be removed in v2.0
-     * Search for events matching a keyword query.
-     * Returns grouped events, each containing related markets.
-     * @param query - Search term
-     * @param params - Optional filter parameters
-     */
-    async searchEvents(query, params) {
-        console.warn('⚠️  searchEvents() is deprecated. Use fetchEvents({ query: "..." }) instead.');
-        return this.fetchEvents({ ...params, query });
+    async fetchEventsImpl(params) {
+        throw new Error("Method fetchEventsImpl not implemented.");
     }
     /**
      * Fetch historical price data for a specific market outcome.

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

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

package/dist/exchanges/kalshi/{searchEvents.js → fetchEvents.js}

@@ -3,11 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.searchEvents = searchEvents;
+exports.fetchEvents = fetchEvents;
 const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function searchEvents(query, params) {
+async function fetchEvents(params) {
     try {
         const queryParams = {
             limit: 200, // Reasonable batch for search
@@ -16,7 +16,7 @@ async function searchEvents(query, params) {
         };
         const response = await axios_1.default.get(utils_1.KALSHI_API_URL, { params: queryParams });
         const events = response.data.events || [];
-        const lowerQuery = query.toLowerCase();
+        const lowerQuery = (params?.query || '').toLowerCase();
         const filtered = events.filter((event) => {
             return (event.title || '').toLowerCase().includes(lowerQuery);
         });
@@ -39,12 +39,7 @@ async function searchEvents(query, params) {
                 url: `https://kalshi.com/events/${event.event_ticker}`,
                 image: event.image_url,
                 category: event.category,
-                tags: event.tags || [],
-                searchMarkets: function (marketQuery) {
-                    const lowerMarketQuery = marketQuery.toLowerCase();
-                    return this.markets.filter(m => m.title.toLowerCase().includes(lowerMarketQuery) ||
-                        m.outcomes.some(o => o.label.toLowerCase().includes(lowerMarketQuery)));
-                }
+                tags: event.tags || []
             };
             return unifiedEvent;
         });

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

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

package/dist/exchanges/kalshi/fetchMarkets.js

@@ -84,6 +84,77 @@ function resetCache() {
     lastCacheTime = 0;
 }
 async function fetchMarkets(params) {
+    try {
+        // Handle slug-based lookup (event ticker)
+        if (params?.slug) {
+            return await fetchMarketsBySlug(params.slug);
+        }
+        // Handle query-based search
+        if (params?.query) {
+            return await searchMarkets(params.query, params);
+        }
+        // Default: fetch markets
+        return await fetchMarketsDefault(params);
+    }
+    catch (error) {
+        throw errors_1.kalshiErrorMapper.mapError(error);
+    }
+}
+async function fetchMarketsBySlug(eventTicker) {
+    // 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;
+}
+async function searchMarkets(query, params) {
+    // We must fetch ALL markets to search them locally since we don't have server-side search
+    const searchLimit = 5000;
+    const markets = await fetchMarketsDefault({ ...params, limit: searchLimit });
+    const lowerQuery = query.toLowerCase();
+    const searchIn = params?.searchIn || 'title'; // Default to title-only search
+    const filtered = markets.filter(market => {
+        const titleMatch = (market.title || '').toLowerCase().includes(lowerQuery);
+        const descMatch = (market.description || '').toLowerCase().includes(lowerQuery);
+        if (searchIn === 'title')
+            return titleMatch;
+        if (searchIn === 'description')
+            return descMatch;
+        return titleMatch || descMatch; // 'both'
+    });
+    const limit = params?.limit || 20;
+    return filtered.slice(0, limit);
+}
+async function fetchMarketsDefault(params) {
     const limit = params?.limit || 50;
     const offset = params?.offset || 0;
     const now = Date.now();

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

@@ -1,4 +1,4 @@
-import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, ExchangeCredentials } from '../../BaseExchange';
+import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, ExchangeCredentials, EventFetchParams } from '../../BaseExchange';
 import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, Balance, Order, Position, CreateOrderParams } from '../../types';
 import { KalshiWebSocketConfig } from './websocket';
 export { KalshiWebSocketConfig };
@@ -14,9 +14,7 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     private getBaseUrl;
     private ensureAuth;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
-    protected searchMarketsImpl(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]>;
-    protected fetchMarketsBySlugImpl(slug: string): Promise<UnifiedMarket[]>;
-    protected searchEventsImpl(query: string, params?: MarketFilterParams): Promise<UnifiedEvent[]>;
+    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
     fetchOHLCV(id: string, params: HistoryFilterParams): Promise<PriceCandle[]>;
     fetchOrderBook(id: string): Promise<OrderBook>;
     fetchTrades(id: string, params: HistoryFilterParams): Promise<Trade[]>;

package/dist/exchanges/kalshi/index.js

@@ -7,9 +7,7 @@ exports.KalshiExchange = void 0;
 const axios_1 = __importDefault(require("axios"));
 const BaseExchange_1 = require("../../BaseExchange");
 const fetchMarkets_1 = require("./fetchMarkets");
-const searchMarkets_1 = require("./searchMarkets");
-const searchEvents_1 = require("./searchEvents");
-const getMarketsBySlug_1 = require("./getMarketsBySlug");
+const fetchEvents_1 = require("./fetchEvents");
 const fetchOHLCV_1 = require("./fetchOHLCV");
 const fetchOrderBook_1 = require("./fetchOrderBook");
 const fetchTrades_1 = require("./fetchTrades");
@@ -59,14 +57,8 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     async fetchMarketsImpl(params) {
         return (0, fetchMarkets_1.fetchMarkets)(params);
     }
-    async searchMarketsImpl(query, params) {
-        return (0, searchMarkets_1.searchMarkets)(query, params);
-    }
-    async fetchMarketsBySlugImpl(slug) {
-        return (0, getMarketsBySlug_1.getMarketsBySlug)(slug);
-    }
-    async searchEventsImpl(query, params) {
-        return (0, searchEvents_1.searchEvents)(query, params);
+    async fetchEventsImpl(params) {
+        return (0, fetchEvents_1.fetchEvents)(params);
     }
     async fetchOHLCV(id, params) {
         return (0, fetchOHLCV_1.fetchOHLCV)(id, params);

package/dist/exchanges/kalshi/utils.js

@@ -32,14 +32,12 @@ function mapMarketToUnified(event, market) {
     }
     const outcomes = [
         {
-            id: market.ticker, // The actual market ticker (primary tradeable)
             outcomeId: market.ticker,
             label: candidateName || 'Yes',
             price: price,
             priceChange24h: priceChange
         },
         {
-            id: `${market.ticker}-NO`, // Virtual ID for the No outcome
             outcomeId: `${market.ticker}-NO`,
             label: candidateName ? `Not ${candidateName}` : 'No',
             price: 1 - price,

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

@@ -1,36 +1,40 @@
-import { ClobClient } from '@polymarket/clob-client';
-import type { ApiKeyCreds } from '@polymarket/clob-client';
+import { HttpClient } from '@limitless-exchange/sdk';
+import { Wallet } from 'ethers';
 import { ExchangeCredentials } from '../../BaseExchange';
 /**
- * Manages Limitless authentication and API client initialization.
- * Handles authentication for both public data and private trading operations.
+ * Manages Limitless authentication using API keys.
+ * Simplified from cookie-based to API key authentication.
  */
 export declare class LimitlessAuth {
     private credentials;
     private signer?;
-    private clobClient?;
-    private apiCreds?;
+    private httpClient?;
+    private apiKey?;
     constructor(credentials: ExchangeCredentials);
     /**
-     * Get or create API credentials using L1 authentication.
-     * This uses the private key to derive/create API credentials.
+     * Get the API key being used for authentication.
      */
-    getApiCredentials(): Promise<ApiKeyCreds>;
+    getApiKey(): string;
     /**
-     * Maps human-readable signature type names to their numeric values.
+     * Get or create the HTTP client with API key authentication.
+     * This client automatically includes the X-API-Key header in all requests.
      */
-    private mapSignatureType;
+    getHttpClient(): HttpClient;
     /**
-     * Get an authenticated CLOB client for L2 operations (trading).
-     * This client can place orders, cancel orders, query positions, etc.
+     * Get the signer (wallet) for signing orders.
+     * Required for placing orders via EIP-712 signatures.
      */
-    getClobClient(): Promise<ClobClient>;
+    getSigner(): Wallet;
     /**
      * Get the signer's address.
      */
     getAddress(): string;
     /**
-     * Reset cached credentials and client (useful for testing or credential rotation).
+     * Check if the auth has a signer available.
+     */
+    hasSigner(): boolean;
+    /**
+     * Reset cached client (useful for testing or credential rotation).
      */
     reset(): void;
 }

package/dist/exchanges/limitless/auth.js

@@ -1,121 +1,78 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LimitlessAuth = void 0;
-const clob_client_1 = require("@polymarket/clob-client");
+const sdk_1 = require("@limitless-exchange/sdk");
 const ethers_1 = require("ethers");
-const errors_1 = require("./errors");
 const LIMITLESS_HOST = 'https://api.limitless.exchange';
-const BASE_CHAIN_ID = 8453;
 /**
- * Manages Limitless authentication and API client initialization.
- * Handles authentication for both public data and private trading operations.
+ * Manages Limitless authentication using API keys.
+ * Simplified from cookie-based to API key authentication.
  */
 class LimitlessAuth {
     constructor(credentials) {
         this.credentials = credentials;
-        if (!credentials.privateKey) {
-            throw new Error('Limitless requires a privateKey for authentication');
+        // API key is required for authenticated endpoints
+        // Can come from credentials or environment variable
+        this.apiKey = credentials.apiKey || process.env.LIMITLESS_API_KEY;
+        if (!this.apiKey) {
+            throw new Error('Limitless requires an API key. Set LIMITLESS_API_KEY environment variable or provide apiKey in credentials.');
+        }
+        // Initialize signer if private key is provided (needed for order signing)
+        if (credentials.privateKey) {
+            this.signer = new ethers_1.Wallet(credentials.privateKey);
         }
-        // Initialize the signer
-        this.signer = new ethers_1.Wallet(credentials.privateKey);
     }
     /**
-     * Get or create API credentials using L1 authentication.
-     * This uses the private key to derive/create API credentials.
+     * Get the API key being used for authentication.
      */
-    async getApiCredentials() {
-        // Return cached credentials if available
-        if (this.apiCreds) {
-            return this.apiCreds;
-        }
-        // If credentials were provided, use them
-        if (this.credentials.apiKey && this.credentials.apiSecret && this.credentials.passphrase) {
-            this.apiCreds = {
-                key: this.credentials.apiKey,
-                secret: this.credentials.apiSecret,
-                passphrase: this.credentials.passphrase,
-            };
-            return this.apiCreds;
-        }
-        // Otherwise, derive/create them using L1 auth
-        const l1Client = new clob_client_1.ClobClient(LIMITLESS_HOST, BASE_CHAIN_ID, this.signer);
-        // Robust derivation strategy:
-        // 1. Try to DERIVE existing credentials first (most common case).
-        // 2. If that fails (e.g. 404 or 400), try to CREATE new ones.
-        let creds;
-        try {
-            // console.log('Trying to derive existing API key...');
-            creds = await l1Client.deriveApiKey();
-        }
-        catch (deriveError) {
-            // console.log('Derivation failed, trying to create new API key...');
-            try {
-                creds = await l1Client.createApiKey();
-            }
-            catch (createError) {
-                throw errors_1.limitlessErrorMapper.mapError(createError);
-            }
-        }
-        if (!creds) {
-            throw new Error('Authentication failed: Credentials are empty.');
-        }
-        this.apiCreds = creds;
-        return creds;
+    getApiKey() {
+        return this.apiKey;
     }
     /**
-     * Maps human-readable signature type names to their numeric values.
+     * Get or create the HTTP client with API key authentication.
+     * This client automatically includes the X-API-Key header in all requests.
      */
-    mapSignatureType(type) {
-        if (type === undefined || type === null)
-            return 0;
-        if (typeof type === 'number')
-            return type;
-        const normalized = type.toLowerCase().replace(/[^a-z0-9]/g, '');
-        switch (normalized) {
-            case 'eoa':
-                return 0;
-            case 'polyproxy':
-            case 'polymarketproxy':
-                return 1;
-            case 'gnosissafe':
-            case 'safe':
-                return 2;
-            default:
-                const parsed = parseInt(normalized);
-                return isNaN(parsed) ? 0 : parsed;
+    getHttpClient() {
+        if (this.httpClient) {
+            return this.httpClient;
         }
+        this.httpClient = new sdk_1.HttpClient({
+            baseURL: LIMITLESS_HOST,
+            apiKey: this.apiKey,
+            timeout: 30000,
+        });
+        return this.httpClient;
     }
     /**
-     * Get an authenticated CLOB client for L2 operations (trading).
-     * This client can place orders, cancel orders, query positions, etc.
+     * Get the signer (wallet) for signing orders.
+     * Required for placing orders via EIP-712 signatures.
      */
-    async getClobClient() {
-        // Return cached client if available
-        if (this.clobClient) {
-            return this.clobClient;
+    getSigner() {
+        if (!this.signer) {
+            throw new Error('Wallet signer not available. Provide privateKey in credentials to sign orders.');
         }
-        // Get API credentials (L1 auth)
-        const apiCreds = await this.getApiCredentials();
-        // Determine signature type (default to EOA = 0)
-        const signatureType = this.mapSignatureType(this.credentials.signatureType);
-        // Determine funder address (defaults to signer's address)
-        const funderAddress = this.credentials.funderAddress ?? this.signer.address;
-        // Create L2-authenticated client
-        this.clobClient = new clob_client_1.ClobClient(LIMITLESS_HOST, BASE_CHAIN_ID, this.signer, apiCreds, signatureType, funderAddress);
-        return this.clobClient;
+        return this.signer;
     }
     /**
      * Get the signer's address.
      */
     getAddress() {
+        if (!this.signer) {
+            throw new Error('Signer not initialized. Provide privateKey in credentials.');
+        }
         return this.signer.address;
     }
     /**
-     * Reset cached credentials and client (useful for testing or credential rotation).
+     * Check if the auth has a signer available.
+     */
+    hasSigner() {
+        return !!this.signer;
+    }
+    /**
+     * Reset cached client (useful for testing or credential rotation).
      */
     reset() {
-        this.apiCreds = undefined;
-        this.clobClient = undefined;
+        this.httpClient = undefined;
     }
 }
 exports.LimitlessAuth = LimitlessAuth;

package/dist/exchanges/limitless/client.d.ts

@@ -1,3 +1,4 @@
+import { HttpClient, OrderClient, MarketFetcher } from '@limitless-exchange/sdk';
 export interface LimitlessOrderParams {
     marketSlug: string;
     outcomeId: string;
@@ -6,18 +7,63 @@ export interface LimitlessOrderParams {
     amount: number;
     type?: 'limit' | 'market';
 }
+/**
+ * Wrapper client for Limitless Exchange using the official SDK.
+ * Provides a simplified interface for market data and order operations.
+ */
 export declare class LimitlessClient {
-    private api;
+    private httpClient;
+    private orderClient;
+    private marketFetcher;
     private signer;
-    private sessionCookie?;
-    private userId?;
     private marketCache;
-    private userData;
-    constructor(privateKey: string);
-    private ensureAuth;
+    constructor(privateKey: string, apiKey: string);
+    /**
+     * Get market details by slug.
+     * Results are cached to reduce API calls.
+     */
     getMarket(slug: string): Promise<any>;
-    createOrder(params: LimitlessOrderParams): Promise<any>;
-    cancelOrder(orderId: string): Promise<any>;
-    cancelAllOrders(marketSlug: string): Promise<any>;
+    /**
+     * Create a limit order (GTC - Good Till Cancelled).
+     * The SDK handles EIP-712 signing automatically.
+     */
+    createOrder(params: LimitlessOrderParams): Promise<import("@limitless-exchange/sdk").OrderResponse>;
+    /**
+     * Cancel a specific order by ID.
+     */
+    cancelOrder(orderId: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * Cancel all orders for a specific market.
+     */
+    cancelAllOrders(marketSlug: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * Get user orders for a specific market.
+     * @param marketSlug - The market slug
+     * @param statuses - Optional filter by order status
+     */
     getOrders(marketSlug: string, statuses?: ('LIVE' | 'MATCHED' | 'CANCELLED' | 'FILLED')[]): Promise<any>;
+    /**
+     * Get the signer's wallet address.
+     */
+    getAddress(): string;
+    /**
+     * Get the underlying HTTP client for direct API access.
+     */
+    getHttpClient(): HttpClient;
+    /**
+     * Get the underlying OrderClient for advanced order operations.
+     */
+    getOrderClient(): OrderClient;
+    /**
+     * Get the underlying MarketFetcher for advanced market queries.
+     */
+    getMarketFetcher(): MarketFetcher;
+    /**
+     * Clear the market cache.
+     */
+    clearMarketCache(): void;
 }