pmxt 1.5.2__py3-none-any.whl → 1.5.5__py3-none-any.whl

pmxt/__init__.py

@@ -33,7 +33,7 @@ from .models import (
     CreateOrderParams,
 )
 
-__version__ = "1.5.2"
+__version__ = "1.5.5"
 __all__ = [
     # Exchanges
     "Polymarket",

pmxt/_server/server/bundled.js

@@ -38127,12 +38127,13 @@ var require_utils4 = __commonJS({
   "dist/exchanges/polymarket/utils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.CLOB_API_URL = exports2.GAMMA_API_URL = void 0;
+    exports2.DATA_API_URL = exports2.CLOB_API_URL = exports2.GAMMA_API_URL = void 0;
     exports2.mapMarketToUnified = mapMarketToUnified;
     exports2.mapIntervalToFidelity = mapIntervalToFidelity;
     var market_utils_1 = require_market_utils();
     exports2.GAMMA_API_URL = "https://gamma-api.polymarket.com/events";
     exports2.CLOB_API_URL = "https://clob.polymarket.com";
+    exports2.DATA_API_URL = "https://data-api.polymarket.com";
     function mapMarketToUnified(event, market, options = {}) {
       if (!market)
         return null;
@@ -38284,7 +38285,7 @@ var require_searchMarkets = __commonJS({
     exports2.searchMarkets = searchMarkets;
     var fetchMarkets_1 = require_fetchMarkets();
     async function searchMarkets(query, params) {
-      const searchLimit = 1e5;
+      const searchLimit = 5e3;
       try {
         const markets = await (0, fetchMarkets_1.fetchMarkets)({
           ...params,
@@ -38562,7 +38563,8 @@ var require_fetchTrades = __commonJS({
       }
       try {
         const queryParams = {
-          market: id
+          asset_id: id
+          // Uses asset_id for Token ID on Data API
         };
         if (params.start) {
           queryParams.after = Math.floor(params.start.getTime() / 1e3);
@@ -38570,7 +38572,7 @@ var require_fetchTrades = __commonJS({
         if (params.end) {
           queryParams.before = Math.floor(params.end.getTime() / 1e3);
         }
-        const response = await axios_1.default.get(`${utils_1.CLOB_API_URL}/trades`, {
+        const response = await axios_1.default.get(`${utils_1.DATA_API_URL}/trades`, {
           params: queryParams
         });
         const trades = response.data || [];
@@ -38583,13 +38585,14 @@ var require_fetchTrades = __commonJS({
           side: trade.side === "BUY" ? "buy" : trade.side === "SELL" ? "sell" : "unknown"
         }));
         if (params.limit && mappedTrades.length > params.limit) {
-          return mappedTrades.slice(-params.limit);
+          return mappedTrades.slice(0, params.limit);
         }
         return mappedTrades;
       } 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(`Polymarket Trades API Error (${error.response.status}): ${apiError}. Used ID: ${id}`);
+        if (axios_1.default.isAxiosError(error)) {
+          const apiError = error.response?.data?.error || error.response?.data?.message || error.message;
+          console.error(`[Polymarket] fetchTrades failed for ID ${id}: ${apiError}`);
+          throw new Error(`Polymarket Trades API Error: ${apiError}`);
         }
         console.error(`Unexpected error fetching Polymarket trades for ${id}:`, error);
         throw error;
@@ -38608,25 +38611,31 @@ var require_fetchPositions = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.fetchPositions = fetchPositions;
     var axios_1 = __importDefault(require_axios());
-    var DATA_API_URL = "https://data-api.polymarket.com";
+    var utils_1 = require_utils4();
     async function fetchPositions(userAddress) {
-      const response = await axios_1.default.get(`${DATA_API_URL}/positions`, {
-        params: {
-          user: userAddress,
-          limit: 100
-        }
-      });
-      const data = Array.isArray(response.data) ? response.data : [];
-      return data.map((p) => ({
-        marketId: p.conditionId,
-        outcomeId: p.asset,
-        outcomeLabel: p.outcome || "Unknown",
-        size: parseFloat(p.size),
-        entryPrice: parseFloat(p.avgPrice),
-        currentPrice: parseFloat(p.curPrice || "0"),
-        unrealizedPnL: parseFloat(p.cashPnl || "0"),
-        realizedPnL: parseFloat(p.realizedPnl || "0")
-      }));
+      try {
+        const response = await axios_1.default.get(`${utils_1.DATA_API_URL}/positions`, {
+          params: {
+            user: userAddress,
+            limit: 100
+          }
+        });
+        const data = Array.isArray(response.data) ? response.data : [];
+        return data.map((p) => ({
+          marketId: p.conditionId,
+          outcomeId: p.asset,
+          outcomeLabel: p.outcome || "Unknown",
+          size: parseFloat(p.size),
+          entryPrice: parseFloat(p.avgPrice),
+          currentPrice: parseFloat(p.curPrice || "0"),
+          unrealizedPnL: parseFloat(p.cashPnl || "0"),
+          realizedPnL: parseFloat(p.realizedPnl || "0")
+        }));
+      } catch (error) {
+        const apiError = error.response?.data?.error || error.response?.data?.message || error.message;
+        console.error(`[Polymarket] fetchPositions failed for ${userAddress}: ${apiError}`);
+        throw new Error(`Polymarket Positions API Error: ${apiError}`);
+      }
     }
   }
 });
@@ -104861,7 +104870,7 @@ var require_polymarket = __commonJS({
             tickSize
           });
           if (!response || !response.success) {
-            throw new Error(response?.errorMsg || "Order placement failed");
+            throw new Error(`${response?.errorMsg || "Order placement failed"} (Response: ${JSON.stringify(response)})`);
           }
           return {
             id: response.orderID,
@@ -104938,16 +104947,19 @@ var require_polymarket = __commonJS({
         const client = await auth.getClobClient();
         try {
           const order = await client.getOrder(orderId);
+          if (!order || !order.id) {
+            const errorMsg = order?.error || "Order not found (Invalid ID)";
+            throw new Error(errorMsg);
+          }
           return {
             id: order.id,
             marketId: order.market || "unknown",
             outcomeId: order.asset_id,
-            side: order.side.toLowerCase(),
+            side: (order.side || "").toLowerCase(),
             type: order.order_type === "GTC" ? "limit" : "market",
             price: parseFloat(order.price),
             amount: parseFloat(order.original_size),
-            status: order.status,
-            // Needs precise mapping
+            status: typeof order.status === "string" ? order.status.toLowerCase() : order.status,
             filled: parseFloat(order.size_matched),
             remaining: parseFloat(order.original_size) - parseFloat(order.size_matched),
             timestamp: order.created_at * 1e3
@@ -105130,7 +105142,7 @@ var require_fetchMarkets2 = __commonJS({
         const unifiedMarkets = [];
         for (const market of markets) {
           const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
-          if (unifiedMarket) {
+          if (unifiedMarket && unifiedMarket.outcomes.length > 0) {
             unifiedMarkets.push(unifiedMarket);
           }
         }
@@ -105167,8 +105179,22 @@ var require_searchMarkets2 = __commonJS({
             limit: params?.limit || 20
           }
         });
-        const markets = response.data?.markets || [];
-        return markets.map((m) => (0, utils_1.mapMarketToUnified)(m)).filter((m) => m !== null).slice(0, params?.limit || 20);
+        const rawResults = response.data?.markets || [];
+        const allMarkets = [];
+        for (const res of rawResults) {
+          if (res.markets && Array.isArray(res.markets)) {
+            for (const child of res.markets) {
+              const mapped = (0, utils_1.mapMarketToUnified)(child);
+              if (mapped)
+                allMarkets.push(mapped);
+            }
+          } else {
+            const mapped = (0, utils_1.mapMarketToUnified)(res);
+            if (mapped)
+              allMarkets.push(mapped);
+          }
+        }
+        return allMarkets.filter((m) => m !== null && m.outcomes.length > 0).slice(0, params?.limit || 20);
       } catch (error) {
         console.error("Error searching Limitless data:", error.message);
         return [];
@@ -105350,55 +105376,10 @@ var require_fetchOrderBook2 = __commonJS({
 var require_fetchTrades2 = __commonJS({
   "dist/exchanges/limitless/fetchTrades.js"(exports2) {
     "use strict";
-    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.fetchTrades = fetchTrades;
-    var axios_1 = __importDefault(require_axios());
-    var utils_1 = require_utils10();
     async function fetchTrades(id, params) {
-      try {
-        const url2 = `${utils_1.LIMITLESS_API_URL}/portfolio/trades`;
-        const requestParams = {
-          limit: params.limit || 100
-        };
-        if (params.start) {
-          requestParams.after = Math.floor(params.start.getTime() / 1e3);
-        }
-        if (params.end) {
-          requestParams.before = Math.floor(params.end.getTime() / 1e3);
-        }
-        const response = await axios_1.default.get(url2, {
-          params: requestParams
-        });
-        const tradesData = response.data?.data || response.data || [];
-        let trades = tradesData.map((trade) => {
-          const price = parseFloat(trade.price);
-          const timestamp = Number(trade.timestamp);
-          let side = "unknown";
-          const rawSide = trade.side?.toLowerCase();
-          if (rawSide === "buy")
-            side = "buy";
-          else if (rawSide === "sell")
-            side = "sell";
-          return {
-            id: trade.id || `${timestamp}-${price}`,
-            timestamp: timestamp * 1e3,
-            price,
-            amount: parseFloat(trade.size || trade.amount || 0),
-            side
-          };
-        });
-        trades.sort((a, b) => b.timestamp - a.timestamp);
-        if (params.limit) {
-          trades = trades.slice(0, params.limit);
-        }
-        return trades;
-      } catch (error) {
-        console.error(`Error fetching Limitless trades for ${id}:`, error.message);
-        return [];
-      }
+      throw new Error("Limitless fetchTrades not implemented: No public market trades API available.");
     }
   }
 });
@@ -105524,6 +105505,176 @@ var require_auth2 = __commonJS({
   }
 });
 
+// dist/exchanges/limitless/client.js
+var require_client = __commonJS({
+  "dist/exchanges/limitless/client.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LimitlessClient = void 0;
+    var axios_1 = __importDefault(require_axios());
+    var ethers_1 = require_lib36();
+    var LIMITLESS_API_URL = "https://api.limitless.exchange";
+    var BASE_CHAIN_ID = 8453;
+    var ORDER_TYPES = {
+      Order: [
+        { name: "salt", type: "uint256" },
+        { name: "maker", type: "address" },
+        { name: "signer", type: "address" },
+        { name: "taker", type: "address" },
+        { name: "tokenId", type: "uint256" },
+        { name: "makerAmount", type: "uint256" },
+        { name: "takerAmount", type: "uint256" },
+        { name: "expiration", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "feeRateBps", type: "uint256" },
+        { name: "side", type: "uint8" },
+        { name: "signatureType", type: "uint8" }
+      ]
+    };
+    var LimitlessClient = class {
+      constructor(privateKey) {
+        this.marketCache = {};
+        this.signer = new ethers_1.Wallet(privateKey);
+        this.api = axios_1.default.create({
+          baseURL: LIMITLESS_API_URL,
+          headers: {
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+          }
+        });
+      }
+      async ensureAuth() {
+        if (this.sessionCookie && this.userId)
+          return;
+        const msgRes = await this.api.get("/auth/signing-message");
+        const message = msgRes.data;
+        const hexMessage = ethers_1.utils.hexlify(ethers_1.utils.toUtf8Bytes(message));
+        const signature = await this.signer.signMessage(message);
+        const loginRes = await this.api.post("/auth/login", {
+          client: "eoa"
+        }, {
+          headers: {
+            "x-account": this.signer.address,
+            "x-signing-message": hexMessage,
+            "x-signature": signature
+          }
+        });
+        const setCookie = loginRes.headers["set-cookie"];
+        if (setCookie) {
+          const sessionMatch = setCookie.find((c) => c.startsWith("limitless_session="));
+          if (sessionMatch) {
+            this.sessionCookie = sessionMatch.split(";")[0];
+          }
+        }
+        if (!this.sessionCookie) {
+          throw new Error("Failed to retrieve session cookie from login response");
+        }
+        this.userId = loginRes.data.id;
+        this.userData = loginRes.data;
+        this.api.defaults.headers.common["Cookie"] = this.sessionCookie;
+      }
+      async getMarket(slug) {
+        if (this.marketCache[slug])
+          return this.marketCache[slug];
+        const res = await this.api.get(`/markets/${slug}`);
+        const market = res.data;
+        if (!market)
+          throw new Error(`Market not found: ${slug}`);
+        this.marketCache[slug] = market;
+        return market;
+      }
+      async createOrder(params) {
+        await this.ensureAuth();
+        const market = await this.getMarket(params.marketSlug);
+        const venue = market.venue;
+        if (!venue || !venue.exchange) {
+          throw new Error(`Market ${params.marketSlug} has no venue exchange address`);
+        }
+        const SCALING_FACTOR = 1e6;
+        let makerAmount;
+        let takerAmount;
+        const price = params.price;
+        const amount = params.amount;
+        if (params.side === "BUY") {
+          const totalCost = price * amount;
+          makerAmount = Math.round(totalCost * SCALING_FACTOR);
+          takerAmount = Math.round(amount * SCALING_FACTOR);
+        } else {
+          const totalProceeds = price * amount;
+          makerAmount = Math.round(amount * SCALING_FACTOR);
+          takerAmount = Math.round(totalProceeds * SCALING_FACTOR);
+        }
+        const domain = {
+          name: "Limitless CTF Exchange",
+          version: "1",
+          chainId: BASE_CHAIN_ID,
+          // 8453
+          verifyingContract: venue.exchange
+        };
+        const sideInt = params.side === "BUY" ? 0 : 1;
+        const feeRateBps = this.userData?.rank?.feeRateBps ?? 0;
+        const orderData = {
+          salt: Date.now() + 864e5,
+          // 24h expiry
+          maker: this.signer.address,
+          signer: this.signer.address,
+          taker: "0x0000000000000000000000000000000000000000",
+          tokenId: params.outcomeId,
+          // Keep as string for now if big
+          makerAmount,
+          takerAmount,
+          expiration: "0",
+          nonce: 0,
+          feeRateBps,
+          side: sideInt,
+          signatureType: 0
+          // EOA
+        };
+        const signature = await this.signer._signTypedData(domain, ORDER_TYPES, orderData);
+        const payload = {
+          order: {
+            ...orderData,
+            price: params.price,
+            // Send float as per API
+            signature
+          },
+          ownerId: this.userId,
+          orderType: "GTC",
+          // Force Limit Orders for now
+          marketSlug: params.marketSlug
+        };
+        const res = await this.api.post("/orders", payload);
+        return res.data;
+      }
+      async cancelOrder(orderId) {
+        await this.ensureAuth();
+        const res = await this.api.delete(`/orders/${orderId}`, {
+          data: {}
+        });
+        return res.data;
+      }
+      async cancelAllOrders(marketSlug) {
+        await this.ensureAuth();
+        const res = await this.api.delete(`/orders/all/${marketSlug}`);
+        return res.data;
+      }
+      async getOrders(marketSlug, statuses) {
+        await this.ensureAuth();
+        const params = {};
+        if (statuses && statuses.length > 0) {
+          params.statuses = statuses;
+        }
+        const res = await this.api.get(`/markets/${marketSlug}/user-orders`, { params });
+        return res.data.orders || [];
+      }
+    };
+    exports2.LimitlessClient = LimitlessClient;
+  }
+});
+
 // dist/exchanges/limitless/websocket.js
 var require_websocket4 = __commonJS({
   "dist/exchanges/limitless/websocket.js"(exports2) {
@@ -105562,7 +105713,7 @@ var require_limitless = __commonJS({
     var fetchTrades_1 = require_fetchTrades2();
     var fetchPositions_1 = require_fetchPositions2();
     var auth_1 = require_auth2();
-    var clob_client_1 = (init_dist2(), __toCommonJS(dist_exports));
+    var client_1 = require_client();
     var websocket_1 = require_websocket4();
     var LimitlessExchange = class extends BaseExchange_1.PredictionMarketExchange {
       constructor(options) {
@@ -105580,6 +105731,7 @@ var require_limitless = __commonJS({
         this.wsConfig = wsConfig;
         if (credentials?.privateKey) {
           this.auth = new auth_1.LimitlessAuth(credentials);
+          this.client = new client_1.LimitlessClient(credentials.privateKey);
         }
       }
       get name() {
@@ -105609,6 +105761,12 @@ var require_limitless = __commonJS({
       // ----------------------------------------------------------------------------
       // Trading Methods
       // ----------------------------------------------------------------------------
+      ensureClient() {
+        if (!this.client) {
+          throw new Error('Trading operations require authentication. Initialize LimitlessExchange with credentials: new LimitlessExchange({ privateKey: "0x..." })');
+        }
+        return this.client;
+      }
       /**
        * Ensure authentication is initialized before trading operations.
        */
@@ -105619,44 +105777,29 @@ var require_limitless = __commonJS({
         return this.auth;
       }
       async createOrder(params) {
-        const auth = this.ensureAuth();
-        const client = await auth.getClobClient();
-        const side = params.side.toUpperCase() === "BUY" ? clob_client_1.Side.BUY : clob_client_1.Side.SELL;
-        if (params.type === "limit" && !params.price) {
-          throw new Error("Price is required for limit orders");
-        }
-        const price = params.price || (side === clob_client_1.Side.BUY ? 0.99 : 0.01);
-        let tickSize;
-        if (params.tickSize) {
-          tickSize = params.tickSize.toString();
-        } else {
-          try {
-            const orderBook = await this.fetchOrderBook(params.outcomeId);
-            tickSize = this.inferTickSize(orderBook);
-          } catch (error) {
-            tickSize = "0.001";
-          }
-        }
+        const client = this.ensureClient();
         try {
-          const response = await client.createAndPostOrder({
-            tokenID: params.outcomeId,
-            price,
+          const side = params.side.toUpperCase();
+          const marketSlug = params.marketId;
+          if (!params.price) {
+            throw new Error("Limit orders require a price");
+          }
+          const response = await client.createOrder({
+            marketSlug,
+            outcomeId: params.outcomeId,
             side,
-            size: params.amount,
-            feeRateBps: 0
-          }, {
-            tickSize
+            price: params.price,
+            amount: params.amount,
+            type: params.type
           });
-          if (!response || !response.success) {
-            throw new Error(response?.errorMsg || "Order placement failed");
-          }
           return {
-            id: response.orderID,
+            id: response.id || "unknown",
+            // Adjust based on actual response
             marketId: params.marketId,
             outcomeId: params.outcomeId,
             side: params.side,
             type: params.type,
-            price,
+            price: params.price,
             amount: params.amount,
             status: "open",
             filled: 0,
@@ -105664,46 +105807,14 @@ var require_limitless = __commonJS({
             timestamp: Date.now()
           };
         } catch (error) {
+          console.error("Limitless createOrder failed:", error.response?.data || error.message);
           throw error;
         }
       }
-      /**
-       * Infer the tick size from order book price levels.
-       * Analyzes the decimal precision of existing orders to determine the market's tick size.
-       */
-      inferTickSize(orderBook) {
-        const allPrices = [
-          ...orderBook.bids.map((b) => b.price),
-          ...orderBook.asks.map((a) => a.price)
-        ];
-        if (allPrices.length === 0) {
-          return "0.001";
-        }
-        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;
-            }
-          }
-        }
-        if (minIncrement >= 0.1)
-          return "0.1";
-        if (minIncrement >= 0.01)
-          return "0.01";
-        if (minIncrement >= 1e-3)
-          return "0.001";
-        return "0.0001";
-      }
       async cancelOrder(orderId) {
-        const auth = this.ensureAuth();
-        const client = await auth.getClobClient();
+        const client = this.ensureClient();
         try {
-          await client.cancelOrder({ orderID: orderId });
+          await client.cancelOrder(orderId);
           return {
             id: orderId,
             marketId: "unknown",
@@ -105717,51 +105828,36 @@ var require_limitless = __commonJS({
             timestamp: Date.now()
           };
         } catch (error) {
+          console.error("Limitless cancelOrder failed:", error.response?.data || error.message);
           throw error;
         }
       }
       async fetchOrder(orderId) {
-        const auth = this.ensureAuth();
-        const client = await auth.getClobClient();
-        try {
-          const order = await client.getOrder(orderId);
-          return {
-            id: order.id,
-            marketId: order.market || "unknown",
-            outcomeId: order.asset_id,
-            side: order.side.toLowerCase(),
-            type: order.order_type === "GTC" ? "limit" : "market",
-            price: parseFloat(order.price),
-            amount: parseFloat(order.original_size),
-            status: order.status,
-            // Needs precise mapping
-            filled: parseFloat(order.size_matched),
-            remaining: parseFloat(order.original_size) - parseFloat(order.size_matched),
-            timestamp: order.created_at * 1e3
-          };
-        } catch (error) {
-          throw error;
-        }
+        throw new Error("Limitless: fetchOrder(id) is not supported directly. Use fetchOpenOrders(marketSlug).");
       }
       async fetchOpenOrders(marketId) {
-        const auth = this.ensureAuth();
-        const client = await auth.getClobClient();
+        const client = this.ensureClient();
         try {
-          const orders = await client.getOpenOrders({
-            market: marketId
-          });
+          if (!marketId) {
+            console.warn("Limitless: fetchOpenOrders requires marketId (slug) to be efficient. Returning [].");
+            return [];
+          }
+          const orders = await client.getOrders(marketId, ["LIVE"]);
           return orders.map((o) => ({
             id: o.id,
-            marketId: o.market || "unknown",
-            outcomeId: o.asset_id,
+            marketId,
+            outcomeId: "unknown",
+            // API might not return this in the simplified list, need to check response
             side: o.side.toLowerCase(),
             type: "limit",
             price: parseFloat(o.price),
-            amount: parseFloat(o.original_size),
+            amount: parseFloat(o.quantity),
             status: "open",
-            filled: parseFloat(o.size_matched),
-            remaining: parseFloat(o.size_left || parseFloat(o.original_size) - parseFloat(o.size_matched)),
-            timestamp: o.created_at * 1e3
+            filled: 0,
+            // Need to check if API returns filled amount in this view
+            remaining: parseFloat(o.quantity),
+            timestamp: Date.now()
+            // API doesn't always return TS in summary
           }));
         } catch (error) {
           console.error("Error fetching Limitless open orders:", error.message);
@@ -105779,30 +105875,20 @@ var require_limitless = __commonJS({
         try {
           const USDC_DECIMALS = 6;
           const balRes = await client.getBalanceAllowance({
-            asset_type: clob_client_1.AssetType.COLLATERAL
+            asset_type: "COLLATERAL"
           });
           const rawBalance = parseFloat(balRes.balance);
           const total = rawBalance / Math.pow(10, USDC_DECIMALS);
-          const openOrders = await client.getOpenOrders({});
-          let locked = 0;
-          if (openOrders && Array.isArray(openOrders)) {
-            for (const order of openOrders) {
-              if (order.side === clob_client_1.Side.BUY) {
-                const remainingSize = parseFloat(order.original_size) - parseFloat(order.size_matched);
-                const price = parseFloat(order.price);
-                locked += remainingSize * price;
-              }
-            }
-          }
           return [{
             currency: "USDC",
             total,
-            available: total - locked,
-            // Available for new trades
-            locked
+            available: total,
+            // Approximate
+            locked: 0
           }];
         } catch (error) {
-          throw error;
+          console.warn("fetchBalance failed via CLOB client", error.message);
+          return [{ currency: "USDC", total: 0, available: 0, locked: 0 }];
         }
       }
       async watchOrderBook(id, limit) {
@@ -106061,9 +106147,9 @@ var require_searchMarkets3 = __commonJS({
     exports2.searchMarkets = searchMarkets;
     var fetchMarkets_1 = require_fetchMarkets3();
     async function searchMarkets(query, params) {
-      const fetchLimit = 1e5;
+      const searchLimit = 5e3;
       try {
-        const markets = await (0, fetchMarkets_1.fetchMarkets)({ ...params, limit: fetchLimit });
+        const markets = await (0, fetchMarkets_1.fetchMarkets)({ ...params, limit: searchLimit });
         const lowerQuery = query.toLowerCase();
         const searchIn = params?.searchIn || "title";
         const filtered = markets.filter((market) => {
@@ -106494,10 +106580,12 @@ var require_websocket5 = __commonJS({
         this.orderBookResolvers = /* @__PURE__ */ new Map();
         this.tradeResolvers = /* @__PURE__ */ new Map();
         this.orderBooks = /* @__PURE__ */ new Map();
-        this.subscribedTickers = /* @__PURE__ */ new Set();
+        this.subscribedOrderBookTickers = /* @__PURE__ */ new Set();
+        this.subscribedTradeTickers = /* @__PURE__ */ new Set();
         this.messageIdCounter = 1;
         this.isConnecting = false;
         this.isConnected = false;
+        this.isTerminated = false;
         this.auth = auth;
         this.config = {
           wsUrl: config.wsUrl || "wss://api.elections.kalshi.com/trade-api/ws/v2",
@@ -106505,11 +106593,17 @@ var require_websocket5 = __commonJS({
         };
       }
       async connect() {
-        if (this.isConnected || this.isConnecting) {
+        if (this.isConnected) {
+          return;
+        }
+        if (this.isTerminated) {
           return;
         }
+        if (this.connectionPromise) {
+          return this.connectionPromise;
+        }
         this.isConnecting = true;
-        return new Promise((resolve, reject) => {
+        this.connectionPromise = new Promise((resolve, reject) => {
           try {
             const url2 = new URL(this.config.wsUrl);
             const path = url2.pathname;
@@ -106519,9 +106613,13 @@ var require_websocket5 = __commonJS({
             this.ws.on("open", () => {
               this.isConnected = true;
               this.isConnecting = false;
+              this.connectionPromise = void 0;
               console.log("Kalshi WebSocket connected");
-              if (this.subscribedTickers.size > 0) {
-                this.subscribeToOrderbook(Array.from(this.subscribedTickers));
+              if (this.subscribedOrderBookTickers.size > 0) {
+                this.subscribeToOrderbook(Array.from(this.subscribedOrderBookTickers));
+              }
+              if (this.subscribedTradeTickers.size > 0) {
+                this.subscribeToTrades(Array.from(this.subscribedTradeTickers));
               }
               resolve();
             });
@@ -106536,21 +106634,30 @@ var require_websocket5 = __commonJS({
             this.ws.on("error", (error) => {
               console.error("Kalshi WebSocket error:", error);
               this.isConnecting = false;
+              this.connectionPromise = void 0;
               reject(error);
             });
             this.ws.on("close", () => {
-              console.log("Kalshi WebSocket closed");
+              if (!this.isTerminated) {
+                console.log("Kalshi WebSocket closed");
+                this.scheduleReconnect();
+              }
               this.isConnected = false;
               this.isConnecting = false;
-              this.scheduleReconnect();
+              this.connectionPromise = void 0;
             });
           } catch (error) {
             this.isConnecting = false;
+            this.connectionPromise = void 0;
             reject(error);
           }
         });
+        return this.connectionPromise;
       }
       scheduleReconnect() {
+        if (this.isTerminated) {
+          return;
+        }
         if (this.reconnectTimer) {
           clearTimeout(this.reconnectTimer);
         }
@@ -106721,9 +106828,9 @@ var require_websocket5 = __commonJS({
         if (!this.isConnected) {
           await this.connect();
         }
-        if (!this.subscribedTickers.has(ticker)) {
-          this.subscribedTickers.add(ticker);
-          this.subscribeToOrderbook([ticker]);
+        if (!this.subscribedOrderBookTickers.has(ticker)) {
+          this.subscribedOrderBookTickers.add(ticker);
+          this.subscribeToOrderbook(Array.from(this.subscribedOrderBookTickers));
         }
         return new Promise((resolve, reject) => {
           if (!this.orderBookResolvers.has(ticker)) {
@@ -106736,9 +106843,9 @@ var require_websocket5 = __commonJS({
         if (!this.isConnected) {
           await this.connect();
         }
-        if (!this.subscribedTickers.has(ticker)) {
-          this.subscribedTickers.add(ticker);
-          this.subscribeToTrades([ticker]);
+        if (!this.subscribedTradeTickers.has(ticker)) {
+          this.subscribedTradeTickers.add(ticker);
+          this.subscribeToTrades(Array.from(this.subscribedTradeTickers));
         }
         return new Promise((resolve, reject) => {
           if (!this.tradeResolvers.has(ticker)) {
@@ -106748,12 +106855,32 @@ var require_websocket5 = __commonJS({
         });
       }
       async close() {
+        this.isTerminated = true;
         if (this.reconnectTimer) {
           clearTimeout(this.reconnectTimer);
+          this.reconnectTimer = void 0;
         }
+        this.orderBookResolvers.forEach((resolvers, ticker) => {
+          resolvers.forEach((r) => r.reject(new Error(`WebSocket closed for ${ticker}`)));
+        });
+        this.orderBookResolvers.clear();
+        this.tradeResolvers.forEach((resolvers, ticker) => {
+          resolvers.forEach((r) => r.reject(new Error(`WebSocket closed for ${ticker}`)));
+        });
+        this.tradeResolvers.clear();
         if (this.ws) {
-          this.ws.close();
+          const ws = this.ws;
           this.ws = void 0;
+          if (ws.readyState !== ws_1.default.CLOSED && ws.readyState !== ws_1.default.CLOSING) {
+            return new Promise((resolve) => {
+              ws.once("close", () => {
+                this.isConnected = false;
+                this.isConnecting = false;
+                resolve();
+              });
+              ws.close();
+            });
+          }
         }
         this.isConnected = false;
         this.isConnecting = false;
@@ -106802,6 +106929,9 @@ var require_kalshi = __commonJS({
       get name() {
         return "Kalshi";
       }
+      getBaseUrl() {
+        return "https://api.elections.kalshi.com";
+      }
       // ----------------------------------------------------------------------------
       // Helpers
       // ----------------------------------------------------------------------------
@@ -106841,7 +106971,7 @@ var require_kalshi = __commonJS({
       async fetchBalance() {
         const auth = this.ensureAuth();
         const path = "/trade-api/v2/portfolio/balance";
-        const baseUrl = "https://trading-api.kalshi.com";
+        const baseUrl = this.getBaseUrl();
         const headers = auth.getHeaders("GET", path);
         try {
           const response = await axios_1.default.get(`${baseUrl}${path}`, { headers });
@@ -106869,7 +106999,7 @@ var require_kalshi = __commonJS({
       async createOrder(params) {
         const auth = this.ensureAuth();
         const path = "/trade-api/v2/portfolio/orders";
-        const baseUrl = "https://trading-api.kalshi.com";
+        const baseUrl = this.getBaseUrl();
         const headers = auth.getHeaders("POST", path);
         const isYesSide = params.side === "buy";
         const kalshiOrder = {
@@ -106907,13 +107037,13 @@ var require_kalshi = __commonJS({
             timestamp: new Date(order.created_time).getTime()
           };
         } catch (error) {
-          throw error;
+          throw new Error(`${error.response?.data?.error?.message || error.message} (Status: ${error.response?.status} - ${JSON.stringify(error.response?.data || {})})`);
         }
       }
       async cancelOrder(orderId) {
         const auth = this.ensureAuth();
         const path = `/trade-api/v2/portfolio/orders/${orderId}`;
-        const baseUrl = "https://trading-api.kalshi.com";
+        const baseUrl = this.getBaseUrl();
         const headers = auth.getHeaders("DELETE", path);
         try {
           const response = await axios_1.default.delete(`${baseUrl}${path}`, { headers });
@@ -106937,7 +107067,7 @@ var require_kalshi = __commonJS({
       async fetchOrder(orderId) {
         const auth = this.ensureAuth();
         const path = `/trade-api/v2/portfolio/orders/${orderId}`;
-        const baseUrl = "https://trading-api.kalshi.com";
+        const baseUrl = this.getBaseUrl();
         const headers = auth.getHeaders("GET", path);
         try {
           const response = await axios_1.default.get(`${baseUrl}${path}`, { headers });
@@ -106966,7 +107096,7 @@ var require_kalshi = __commonJS({
         if (marketId) {
           queryParams += `&ticker=${marketId}`;
         }
-        const baseUrl = "https://trading-api.kalshi.com";
+        const baseUrl = this.getBaseUrl();
         const headers = auth.getHeaders("GET", basePath);
         try {
           const response = await axios_1.default.get(`${baseUrl}${basePath}${queryParams}`, { headers });
@@ -106991,7 +107121,7 @@ var require_kalshi = __commonJS({
       async fetchPositions() {
         const auth = this.ensureAuth();
         const path = "/trade-api/v2/portfolio/positions";
-        const baseUrl = "https://trading-api.kalshi.com";
+        const baseUrl = this.getBaseUrl();
         const headers = auth.getHeaders("GET", path);
         try {
           const response = await axios_1.default.get(`${baseUrl}${path}`, { headers });
@@ -107036,14 +107166,16 @@ var require_kalshi = __commonJS({
         if (!this.ws) {
           this.ws = new websocket_1.KalshiWebSocket(auth, this.wsConfig);
         }
-        return this.ws.watchOrderBook(id);
+        const marketTicker = id.replace(/-NO$/, "");
+        return this.ws.watchOrderBook(marketTicker);
       }
       async watchTrades(id, since, limit) {
         const auth = this.ensureAuth();
         if (!this.ws) {
           this.ws = new websocket_1.KalshiWebSocket(auth, this.wsConfig);
         }
-        return this.ws.watchTrades(id);
+        const marketTicker = id.replace(/-NO$/, "");
+        return this.ws.watchTrades(marketTicker);
       }
       async close() {
         if (this.ws) {

{pmxt-1.5.2.dist-info → pmxt-1.5.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pmxt
-Version: 1.5.2
+Version: 1.5.5
 Summary: Unified prediction market data API - The ccxt for prediction markets
 Author: PMXT Contributors
 License: MIT

{pmxt-1.5.2.dist-info → pmxt-1.5.5.dist-info}/RECORD

@@ -1,15 +1,15 @@
-pmxt/__init__.py,sha256=paszN64bZUmov6Xstbx--iHnq7dajljWFQOj8bwTG28,1178
+pmxt/__init__.py,sha256=6qFPZyBCm2SSehAXSznTYTxqJuT9Ek-Hf9AbqMy74c0,1178
 pmxt/client.py,sha256=YEArwWnyDbd5Hb_HxMWXIqsihUD0RZDaTrBZh4hOlq4,34026
 pmxt/models.py,sha256=-jiQ9mmv_qnF6mzj3DrvNgEA77tE_Pl0RCblM1VbV7o,8581
 pmxt/server_manager.py,sha256=6uS1LIZ2d5d_K-MtbMUAlCZvbvhZ_iyofKok55HEofc,11606
 pmxt/_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pmxt/_server/bin/pmxt-ensure-server,sha256=kXIond0UbxS52FAVQD7kHmSBaL_s6cbIyapLRr4KZJw,4544
 pmxt/_server/bin/pmxt-ensure-server.js,sha256=kXIond0UbxS52FAVQD7kHmSBaL_s6cbIyapLRr4KZJw,4544
-pmxt/_server/server/bundled.js,sha256=YMUXCGZZZCnoroBJb0VY3mFN_SeMO0TZPWHU-sSUFQI,4229211
-pmxt_internal/__init__.py,sha256=g4Xvuf1ct--iqBOJfjonb8NJUDkYzqxyp9B7CWa0Ed4,7578
-pmxt_internal/api_client.py,sha256=J77BQ7Qr80D0tSRKLo6f8Uw4hN644FfswtFC7zREtog,27889
+pmxt/_server/server/bundled.js,sha256=-Jg0Eb2-XwBjUjIP2T_k7Nnafd4QwyuH8x7WAUKJATE,4234834
+pmxt_internal/__init__.py,sha256=Z84alxRDjv2HvJd2vMVH01BZFe9fHJVSCgAsh2gC50s,7578
+pmxt_internal/api_client.py,sha256=aj54kPWSjpxYOCRYeP2dekJmQIlyBI8-aAMYkII5rYg,27889
 pmxt_internal/api_response.py,sha256=eMxw1mpmJcoGZ3gs9z6jM4oYoZ10Gjk333s9sKxGv7s,652
-pmxt_internal/configuration.py,sha256=0ZIq43H06952X8CqiYmRQ-jZpBssvlRq3IE3U78Hhgs,18320
+pmxt_internal/configuration.py,sha256=opmDpdbEB9TD7KtbNp1vEm6U4o5OxmxberRXhltUz5M,18320
 pmxt_internal/exceptions.py,sha256=txF8A7vlan57JS69kFPs-IZF-Qhp7IZobBTJVa4fOaM,6644
 pmxt_internal/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pmxt_internal/rest.py,sha256=FMj4yaV6XLr842u_ScWHSzQsTFdk0jaUeuWLJoRbogQ,9760
@@ -65,7 +65,7 @@ pmxt_internal/models/unified_market.py,sha256=DoYhiH4HycYGlq858PEeB-CIA7haT6rxmJ
 pmxt_internal/models/watch_order_book_request.py,sha256=kavGUI-SLz2-Kam_jcJ_h0GDe0-9UkxqCmVsAi6Uios,3726
 pmxt_internal/models/watch_order_book_request_args_inner.py,sha256=ZHrjmFDGxRG5MXbuz4mUp9KFfo3XS7zuXWTyMNgi4xI,5464
 pmxt_internal/models/watch_trades_request.py,sha256=brrg8JbEe-aeg7mIe_Y2HzRPogp-IfRhkXChrxzqoLU,3722
-pmxt-1.5.2.dist-info/METADATA,sha256=rEfVz-9U84IYfzvtRQjfeQtHnJjs-_KVf9bJZ0xyAyc,6449
-pmxt-1.5.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pmxt-1.5.2.dist-info/top_level.txt,sha256=J_jrcouJ-x-5lpcXMxeW0GOSi1HsBVR5_PdSfvigVrw,19
-pmxt-1.5.2.dist-info/RECORD,,
+pmxt-1.5.5.dist-info/METADATA,sha256=SJ2tjjOnHYXIcRUWZvaa7tDr_Mge3cdXc5Tuo3SBzUI,6449
+pmxt-1.5.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pmxt-1.5.5.dist-info/top_level.txt,sha256=J_jrcouJ-x-5lpcXMxeW0GOSi1HsBVR5_PdSfvigVrw,19
+pmxt-1.5.5.dist-info/RECORD,,

pmxt_internal/__init__.py

@@ -14,7 +14,7 @@
 """  # noqa: E501
 
 
-__version__ = "1.5.2"
+__version__ = "1.5.5"
 
 # Define package exports
 __all__ = [

pmxt_internal/api_client.py

@@ -91,7 +91,7 @@ class ApiClient:
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'OpenAPI-Generator/1.5.2/python'
+        self.user_agent = 'OpenAPI-Generator/1.5.5/python'
         self.client_side_validation = configuration.client_side_validation
 
     def __enter__(self):

pmxt_internal/configuration.py

@@ -506,7 +506,7 @@ class Configuration:
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
                "Version of the API: 0.4.4\n"\
-               "SDK Package Version: 1.5.2".\
+               "SDK Package Version: 1.5.5".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self) -> List[HostSetting]: