feat: implement dynamic tick size and improve Limitless error handling

- Add tickSize support to UnifiedMarket and CreateOrderParams
- Implement inferTickSize in Limitless and Polymarket exchanges
- Improve error logging across Limitless exchange methods
- Handle 404 in fetchPositions for new accounts
- Add Limitless setup documentation and auth test script

Author: realfishsam

core/docs/SETUP_LIMITLESS.md

@@ -0,0 +1 @@
+See [Polymarket setup](./SETUP_POLYMARKET.md), and use the ETH private key related to your Limitless account instead.

core/examples/account/test_limitless_auth.ts

@@ -0,0 +1,50 @@
+import { config } from 'dotenv';
+import path from 'path';
+// Load .env from the root directory
+config({ path: path.resolve(__dirname, '../../../.env') });
+
+import pmxt from '../../src/index';
+
+async function testLimitless() {
+    console.log('--- Initializing Limitless Client ---');
+    if (!process.env.LIMITLESS_PRIVATE_KEY) {
+        throw new Error('LIMITLESS_PRIVATE_KEY not found in .env');
+    }
+
+    const client = new pmxt.Limitless({
+        privateKey: process.env.LIMITLESS_PRIVATE_KEY
+    });
+
+    try {
+        console.log('\n--- Fetching Active Markets ---');
+        const markets = await client.fetchMarkets({ limit: 5 });
+        if (markets.length === 0) {
+            console.log('No active markets found.');
+        } else {
+            console.table(markets.map(m => ({
+                id: m.id,
+                title: m.title.substring(0, 50),
+                outcomes: m.outcomes.length,
+                vol: m.volume24h
+            })));
+        }
+
+        console.log('\n--- Fetching Account Balance ---');
+        const balance = await client.fetchBalance();
+        console.table(balance);
+
+        console.log('\n--- Fetching Account Positions (REST API) ---');
+        const positions = await client.fetchPositions();
+        if (positions.length === 0) {
+            const address = (client as any).ensureAuth().getAddress();
+            console.log(`No open positions found for address: ${address}`);
+        } else {
+            console.table(positions);
+        }
+
+    } catch (error: any) {
+        console.error(`\nTest failed: ${error.message}`);
+    }
+}
+
+testLimitless();

core/src/exchanges/limitless/fetchMarkets.ts

@@ -39,8 +39,8 @@ export async function fetchMarkets(params?: MarketFilterParams): Promise<Unified
 
         return unifiedMarkets.slice(offset, offset + limit);
 
-    } catch (error) {
-        console.error("Error fetching Limitless data:", error);
+    } catch (error: any) {
+        console.error("Error fetching Limitless markets:", error.message);
         return [];
     }
 }

core/src/exchanges/limitless/fetchOHLCV.ts

@@ -38,7 +38,7 @@ export async function fetchOHLCV(id: string, params: HistoryFilterParams): Promi
         }).sort((a: any, b: any) => a.timestamp - b.timestamp);
 
     } catch (error: any) {
-        console.error(`Error fetching Limitless history for ${id}:`, error);
+        console.error(`Error fetching Limitless history for ${id}:`, error.message);
         return [];
     }
 }

core/src/exchanges/limitless/fetchOrderBook.ts

@@ -32,8 +32,8 @@ export async function fetchOrderBook(id: string): Promise<OrderBook> {
             timestamp: Date.now() // API doesn't seem to return a specific timestamp in the root anymore
         };
 
-    } catch (error) {
-        console.error(`Error fetching Limitless orderbook for ${id}:`, error);
+    } catch (error: any) {
+        console.error(`Error fetching Limitless orderbook for ${id}:`, error.message);
         return { bids: [], asks: [] };
     }
 }

core/src/exchanges/limitless/fetchPositions.ts

@@ -19,8 +19,13 @@ export async function fetchPositions(userAddress: string): Promise<Position[]> {
             unrealizedPnL: parseFloat(p.cashPnl || '0'),
             realizedPnL: parseFloat(p.realizedPnl || '0')
         }));
-    } catch (error) {
-        console.error(`Error fetching Limitless positions for ${userAddress}:`, error);
+    } catch (error: any) {
+        // Limitless returns 404 if the user has no history on the platform.
+        // We treat this as an empty portfolio rather than an error.
+        if (error.response?.status === 404) {
+            return [];
+        }
+        console.error(`Error fetching Limitless positions: ${error.message}`);
         return [];
     }
 }

core/src/exchanges/limitless/fetchTrades.ts

@@ -30,7 +30,7 @@ export async function fetchTrades(id: string, params: HistoryFilterParams): Prom
         }));
 
     } catch (error: any) {
-        console.error(`Error fetching Limitless trades for ${id}:`, error);
+        console.error(`Error fetching Limitless trades for ${id}:`, error.message);
         return [];
     }
 }

core/src/exchanges/limitless/getMarketsBySlug.ts

@@ -16,8 +16,8 @@ export async function getMarketsBySlug(slug: string): Promise<UnifiedMarket[]> {
         const unifiedMarket = mapMarketToUnified(market);
         return unifiedMarket ? [unifiedMarket] : [];
 
-    } catch (error) {
-        console.error(`Error fetching Limitless slug ${slug}:`, error);
+    } catch (error: any) {
+        console.error(`Error fetching Limitless slug ${slug}:`, error.message);
         return [];
     }
 }

core/src/exchanges/limitless/index.ts

@@ -33,6 +33,9 @@ export class LimitlessExchange extends PredictionMarketExchange {
             // New signature: LimitlessExchangeOptions
             credentials = options.credentials;
             wsConfig = options.websocket;
+        } else if (options && 'privateKey' in options) {
+            // Support direct privateKey for easier initialization
+            credentials = options as ExchangeCredentials;
         } else {
             // Old signature: ExchangeCredentials directly
             credentials = options as ExchangeCredentials | undefined;
@@ -111,6 +114,21 @@ export class LimitlessExchange extends PredictionMarketExchange {
         // For market orders, use max slippage: 0.99 for BUY (willing to pay up to 99%), 0.01 for SELL (willing to accept down to 1%)
         const price = params.price || (side === Side.BUY ? 0.99 : 0.01);
 
+        // Auto-detect tick size if not provided
+        let tickSize: string;
+        if (params.tickSize) {
+            tickSize = params.tickSize.toString();
+        } else {
+            // Fetch the order book to infer tick size from price levels
+            try {
+                const orderBook = await this.fetchOrderBook(params.outcomeId);
+                tickSize = this.inferTickSize(orderBook);
+            } catch (error) {
+                // Fallback to 0.001 if order book fetch fails
+                tickSize = "0.001";
+            }
+        }
+
         try {
             // We use createAndPostOrder which handles signing and posting
             const response = await client.createAndPostOrder({
@@ -120,7 +138,7 @@ export class LimitlessExchange extends PredictionMarketExchange {
                 size: params.amount,
                 feeRateBps: 0,
             }, {
-                tickSize: "0.01"
+                tickSize: tickSize as any
             });
 
             if (!response || !response.success) {
@@ -145,6 +163,41 @@ export class LimitlessExchange extends PredictionMarketExchange {
         }
     }
 
+    /**
+     * Infer the tick size from order book price levels.
+     * Analyzes the decimal precision of existing orders to determine the market's tick size.
+     */
+    private inferTickSize(orderBook: OrderBook): string {
+        const allPrices = [
+            ...orderBook.bids.map(b => b.price),
+            ...orderBook.asks.map(a => a.price)
+        ];
+
+        if (allPrices.length === 0) {
+            return "0.001"; // Default fallback
+        }
+
+        // Find the smallest non-zero decimal increment
+        let minIncrement = 1;
+        for (const price of allPrices) {
+            const priceStr = price.toString();
+            const decimalPart = priceStr.split('.')[1];
+            if (decimalPart) {
+                const decimals = decimalPart.length;
+                const increment = Math.pow(10, -decimals);
+                if (increment < minIncrement) {
+                    minIncrement = increment;
+                }
+            }
+        }
+
+        // Map to valid tick sizes: 0.1, 0.01, 0.001, 0.0001
+        if (minIncrement >= 0.1) return "0.1";
+        if (minIncrement >= 0.01) return "0.01";
+        if (minIncrement >= 0.001) return "0.001";
+        return "0.0001";
+    }
+
     async cancelOrder(orderId: string): Promise<Order> {
         const auth = this.ensureAuth();
         const client = await auth.getClobClient();
@@ -216,7 +269,7 @@ export class LimitlessExchange extends PredictionMarketExchange {
                 timestamp: o.created_at * 1000
             }));
         } catch (error: any) {
-            console.error('Error fetching Limitless open orders:', error);
+            console.error('Error fetching Limitless open orders:', error.message);
             return [];
         }
     }

core/src/exchanges/limitless/searchEvents.ts

@@ -38,8 +38,8 @@ export async function searchEvents(query: string, params?: MarketFilterParams):
             } as UnifiedEvent;
         });
 
-    } catch (error) {
-        console.error("Error searching Limitless events:", error);
+    } catch (error: any) {
+        console.error("Error searching Limitless events:", error.message);
         return [];
     }
 }