pmxt 1.5.1__tar.gz → 1.5.4__tar.gz

{pmxt-1.5.1 → pmxt-1.5.4}/PKG-INFO

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

{pmxt-1.5.1 → pmxt-1.5.4}/generated/pmxt_internal/__init__.py

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

{pmxt-1.5.1 → pmxt-1.5.4}/generated/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.1/python'
+        self.user_agent = 'OpenAPI-Generator/1.5.4/python'
         self.client_side_validation = configuration.client_side_validation
 
     def __enter__(self):

{pmxt-1.5.1 → pmxt-1.5.4}/generated/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.1".\
+               "SDK Package Version: 1.5.4".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self) -> List[HostSetting]:

{pmxt-1.5.1 → pmxt-1.5.4}/pmxt/__init__.py

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

{pmxt-1.5.1 → pmxt-1.5.4}/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,
@@ -104946,8 +104955,7 @@ var require_polymarket = __commonJS({
             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 +105138,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 +105175,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 [];
@@ -105198,8 +105220,14 @@ var require_searchEvents2 = __commonJS({
         });
         const markets = response.data?.markets || [];
         return markets.map((market) => {
-          const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
-          const marketsList = unifiedMarket ? [unifiedMarket] : [];
+          let marketsList = [];
+          if (market.markets && Array.isArray(market.markets)) {
+            marketsList = market.markets.map((child) => (0, utils_1.mapMarketToUnified)(child)).filter((m) => m !== null);
+          } else {
+            const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
+            if (unifiedMarket)
+              marketsList = [unifiedMarket];
+          }
           return {
             id: market.slug,
             title: market.title || market.question,
@@ -105212,7 +105240,7 @@ var require_searchEvents2 = __commonJS({
             tags: market.tags || [],
             searchMarkets: function(marketQuery) {
               const lowerMarketQuery = marketQuery.toLowerCase();
-              return this.markets.filter((m) => m.title.toLowerCase().includes(lowerMarketQuery) || m.description.toLowerCase().includes(lowerMarketQuery));
+              return this.markets.filter((m) => m.title.toLowerCase().includes(lowerMarketQuery) || m.description && m.description.toLowerCase().includes(lowerMarketQuery));
             }
           };
         });
@@ -105344,55 +105372,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.");
     }
   }
 });
@@ -105518,6 +105501,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) {
@@ -105556,7 +105709,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) {
@@ -105574,6 +105727,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() {
@@ -105603,6 +105757,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.
        */
@@ -105613,44 +105773,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,
@@ -105658,46 +105803,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",
@@ -105711,51 +105824,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);
@@ -105773,30 +105871,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) {
@@ -106055,9 +106143,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) => {
@@ -106796,6 +106884,9 @@ var require_kalshi = __commonJS({
       get name() {
         return "Kalshi";
       }
+      getBaseUrl() {
+        return "https://api.elections.kalshi.com";
+      }
       // ----------------------------------------------------------------------------
       // Helpers
       // ----------------------------------------------------------------------------
@@ -106835,7 +106926,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 });
@@ -106863,7 +106954,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 = {
@@ -106901,13 +106992,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 });
@@ -106931,7 +107022,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 });
@@ -106960,7 +107051,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 });
@@ -106985,7 +107076,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 });

{pmxt-1.5.1 → pmxt-1.5.4}/pmxt.egg-info/PKG-INFO

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

{pmxt-1.5.1 → pmxt-1.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pmxt"
-version = "1.5.1"
+version = "1.5.4"
 description = "Unified prediction market data API - The ccxt for prediction markets"
 readme = "README.md"
 requires-python = ">=3.8"