pmxt 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

pmxt/__init__.py

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

pmxt/_server/bin/pmxt-ensure-server.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+/**
+ * PMXT Server Launcher
+ * 
+ * This script ensures the PMXT sidecar server is running.
+ * It's designed to be called by SDKs in any language (Python, Java, C#, Go, etc.)
+ * 
+ * Behavior:
+ * 1. Check if server is already running (via lock file)
+ * 2. If running, exit successfully
+ * 3. If not running, spawn the server and wait for health check
+ * 4. Exit with code 0 on success, 1 on failure
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+const http = require('http');
+
+const LOCK_FILE = path.join(os.homedir(), '.pmxt', 'server.lock');
+const DEFAULT_PORT = 3847;
+const HEALTH_CHECK_TIMEOUT = 10000; // 10 seconds
+const HEALTH_CHECK_INTERVAL = 100; // 100ms
+
+/**
+ * Check if the server is currently running
+ */
+function isServerRunning() {
+    try {
+        if (!fs.existsSync(LOCK_FILE)) {
+            return false;
+        }
+
+        const lockData = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf-8'));
+        const { pid, port } = lockData;
+
+        // Check if process exists
+        try {
+            process.kill(pid, 0); // Signal 0 checks existence without killing
+            return { running: true, port };
+        } catch (err) {
+            // Process doesn't exist, remove stale lock file
+            fs.unlinkSync(LOCK_FILE);
+            return false;
+        }
+    } catch (err) {
+        return false;
+    }
+}
+
+/**
+ * Wait for server to respond to health check
+ */
+function waitForHealth(port, timeout = HEALTH_CHECK_TIMEOUT) {
+    return new Promise((resolve, reject) => {
+        const startTime = Date.now();
+
+        const checkHealth = () => {
+            const req = http.get(`http://localhost:${port}/health`, (res) => {
+                if (res.statusCode === 200) {
+                    resolve(true);
+                } else {
+                    scheduleNextCheck();
+                }
+            });
+
+            req.on('error', () => {
+                scheduleNextCheck();
+            });
+
+            req.setTimeout(1000);
+        };
+
+        const scheduleNextCheck = () => {
+            if (Date.now() - startTime > timeout) {
+                reject(new Error('Server health check timeout'));
+            } else {
+                setTimeout(checkHealth, HEALTH_CHECK_INTERVAL);
+            }
+        };
+
+        checkHealth();
+    });
+}
+
+/**
+ * Start the PMXT server
+ */
+async function startServer() {
+    // 1. Try to find the server binary/script
+    let serverCmd = 'pmxt-server';
+    let args = [];
+
+    // Check for Python-bundled server (when bundled in pip package)
+    const pythonBundledServer = path.join(__dirname, '..', 'server', 'bundled.js');
+    // Check for local dev bundled server
+    const localBundledServer = path.join(__dirname, '..', 'dist', 'server', 'bundled.js');
+    const localDistServer = path.join(__dirname, '..', 'dist', 'server', 'index.js');
+    const localBinServer = path.join(__dirname, 'pmxt-server');
+
+    if (fs.existsSync(pythonBundledServer)) {
+        serverCmd = 'node';
+        args = [pythonBundledServer];
+    } else if (fs.existsSync(localBundledServer)) {
+        serverCmd = 'node';
+        args = [localBundledServer];
+    } else if (fs.existsSync(localDistServer)) {
+        serverCmd = 'node';
+        args = [localDistServer];
+    } else if (fs.existsSync(localBinServer)) {
+        serverCmd = localBinServer;
+    }
+
+    // Spawn server as detached process
+    const serverProcess = spawn(serverCmd, args, {
+        detached: true,
+        stdio: 'ignore',
+        env: process.env
+    });
+
+    // Detach from parent process
+    serverProcess.unref();
+
+    // Wait for server to be ready
+    await waitForHealth(DEFAULT_PORT);
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+    try {
+        // Check if server is already running
+        const serverStatus = isServerRunning();
+
+        if (serverStatus && serverStatus.running) {
+            // Server is running, verify it's healthy
+            try {
+                await waitForHealth(serverStatus.port, 2000);
+                process.exit(0);
+            } catch (err) {
+                // Server process exists but not responding, try to start fresh
+                console.error('Server process exists but not responding, starting fresh...');
+            }
+        }
+
+        // Start the server
+        await startServer();
+        process.exit(0);
+    } catch (err) {
+        console.error('Failed to ensure server is running:', err.message);
+        process.exit(1);
+    }
+}
+
+main();

pmxt/_server/server/bundled.js

@@ -104839,6 +104839,798 @@ var require_polymarket = __commonJS({
           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.01";
+          }
+        }
+        try {
+          const response = await client.createAndPostOrder({
+            tokenID: params.outcomeId,
+            price,
+            side,
+            size: params.amount,
+            feeRateBps: 0
+          }, {
+            tickSize
+          });
+          if (!response || !response.success) {
+            throw new Error(response?.errorMsg || "Order placement failed");
+          }
+          return {
+            id: response.orderID,
+            marketId: params.marketId,
+            outcomeId: params.outcomeId,
+            side: params.side,
+            type: params.type,
+            price,
+            amount: params.amount,
+            status: "open",
+            filled: 0,
+            remaining: params.amount,
+            timestamp: Date.now()
+          };
+        } catch (error) {
+          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.01";
+        }
+        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();
+        try {
+          await client.cancelOrder({ orderID: orderId });
+          return {
+            id: orderId,
+            marketId: "unknown",
+            outcomeId: "unknown",
+            side: "buy",
+            type: "limit",
+            amount: 0,
+            status: "cancelled",
+            filled: 0,
+            remaining: 0,
+            timestamp: Date.now()
+          };
+        } catch (error) {
+          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;
+        }
+      }
+      async fetchOpenOrders(marketId) {
+        const auth = this.ensureAuth();
+        const client = await auth.getClobClient();
+        try {
+          const orders = await client.getOpenOrders({
+            market: marketId
+          });
+          return orders.map((o) => ({
+            id: o.id,
+            marketId: o.market || "unknown",
+            outcomeId: o.asset_id,
+            side: o.side.toLowerCase(),
+            type: "limit",
+            price: parseFloat(o.price),
+            amount: parseFloat(o.original_size),
+            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
+          }));
+        } catch (error) {
+          console.error("Error fetching Polymarket open orders:", error);
+          return [];
+        }
+      }
+      async fetchPositions() {
+        const auth = this.ensureAuth();
+        const address = auth.getAddress();
+        return (0, fetchPositions_1.fetchPositions)(address);
+      }
+      async fetchBalance() {
+        const auth = this.ensureAuth();
+        const client = await auth.getClobClient();
+        try {
+          const USDC_DECIMALS = 6;
+          const balRes = await client.getBalanceAllowance({
+            asset_type: clob_client_1.AssetType.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
+          }];
+        } catch (error) {
+          throw error;
+        }
+      }
+      async watchOrderBook(id, limit) {
+        if (!this.ws) {
+          this.ws = new websocket_1.PolymarketWebSocket(this.wsConfig);
+        }
+        return this.ws.watchOrderBook(id);
+      }
+      async watchTrades(id, since, limit) {
+        if (!this.ws) {
+          this.ws = new websocket_1.PolymarketWebSocket(this.wsConfig);
+        }
+        return this.ws.watchTrades(id);
+      }
+      async close() {
+        if (this.ws) {
+          this.ws.close();
+          this.ws = void 0;
+        }
+      }
+    };
+    exports2.PolymarketExchange = PolymarketExchange;
+  }
+});
+
+// dist/exchanges/limitless/utils.js
+var require_utils10 = __commonJS({
+  "dist/exchanges/limitless/utils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LIMITLESS_API_URL = void 0;
+    exports2.mapMarketToUnified = mapMarketToUnified;
+    exports2.mapIntervalToFidelity = mapIntervalToFidelity;
+    var market_utils_1 = require_market_utils();
+    exports2.LIMITLESS_API_URL = "https://api.limitless.exchange";
+    function mapMarketToUnified(market) {
+      if (!market)
+        return null;
+      const outcomes = [];
+      if (market.tokens && market.prices) {
+        const tokenEntries = Object.entries(market.tokens);
+        tokenEntries.forEach(([label, tokenId], index) => {
+          const outcomePrice = market.prices[index] || 0;
+          outcomes.push({
+            id: tokenId,
+            label: label.charAt(0).toUpperCase() + label.slice(1),
+            // Capitalize 'yes'/'no'
+            price: outcomePrice,
+            priceChange24h: 0,
+            // Not directly available in this flat list, can be computed if needed
+            metadata: {
+              clobTokenId: tokenId
+            }
+          });
+        });
+      }
+      const um = {
+        id: market.slug,
+        title: market.title || market.question,
+        description: market.description,
+        outcomes,
+        resolutionDate: market.expirationTimestamp ? new Date(market.expirationTimestamp) : /* @__PURE__ */ new Date(),
+        volume24h: Number(market.volumeFormatted || 0),
+        volume: Number(market.volume || 0),
+        liquidity: 0,
+        // Not directly in the flat market list
+        openInterest: 0,
+        // Not directly in the flat market list
+        url: `https://limitless.exchange/markets/${market.slug}`,
+        image: market.logo || `https://limitless.exchange/api/og?slug=${market.slug}`,
+        category: market.categories?.[0],
+        tags: market.tags || []
+      };
+      (0, market_utils_1.addBinaryOutcomes)(um);
+      return um;
+    }
+    function mapIntervalToFidelity(interval) {
+      const mapping = {
+        "1m": 1,
+        "5m": 5,
+        "15m": 15,
+        "1h": 60,
+        "6h": 360,
+        "1d": 1440
+      };
+      return mapping[interval];
+    }
+  }
+});
+
+// dist/exchanges/limitless/fetchMarkets.js
+var require_fetchMarkets2 = __commonJS({
+  "dist/exchanges/limitless/fetchMarkets.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.fetchMarkets = fetchMarkets;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function fetchMarkets(params) {
+      const limit = params?.limit || 200;
+      const offset = params?.offset || 0;
+      const url2 = `${utils_1.LIMITLESS_API_URL}/markets/active`;
+      try {
+        const response = await axios_1.default.get(url2);
+        const markets = response.data?.data || response.data;
+        if (!markets || !Array.isArray(markets)) {
+          return [];
+        }
+        const unifiedMarkets = [];
+        for (const market of markets) {
+          const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
+          if (unifiedMarket) {
+            unifiedMarkets.push(unifiedMarket);
+          }
+        }
+        if (params?.sort === "volume") {
+          unifiedMarkets.sort((a, b) => (b.volume ?? 0) - (a.volume ?? 0));
+        } else {
+          unifiedMarkets.sort((a, b) => (b.volume ?? 0) - (a.volume ?? 0));
+        }
+        return unifiedMarkets.slice(offset, offset + limit);
+      } catch (error) {
+        console.error("Error fetching Limitless markets:", error.message);
+        return [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/searchMarkets.js
+var require_searchMarkets2 = __commonJS({
+  "dist/exchanges/limitless/searchMarkets.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.searchMarkets = searchMarkets;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function searchMarkets(query, params) {
+      try {
+        const response = await axios_1.default.get(`${utils_1.LIMITLESS_API_URL}/markets/search`, {
+          params: {
+            query,
+            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);
+      } catch (error) {
+        console.error("Error searching Limitless data:", error.message);
+        return [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/searchEvents.js
+var require_searchEvents2 = __commonJS({
+  "dist/exchanges/limitless/searchEvents.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.searchEvents = searchEvents;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function searchEvents(query, params) {
+      try {
+        const response = await axios_1.default.get(`${utils_1.LIMITLESS_API_URL}/markets/search`, {
+          params: {
+            query,
+            limit: params?.limit || 20
+          }
+        });
+        const markets = response.data?.markets || [];
+        return markets.map((market) => {
+          const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
+          const marketsList = unifiedMarket ? [unifiedMarket] : [];
+          return {
+            id: market.slug,
+            title: market.title || market.question,
+            description: market.description || "",
+            slug: market.slug,
+            markets: marketsList,
+            url: `https://limitless.exchange/markets/${market.slug}`,
+            image: market.logo || `https://limitless.exchange/api/og?slug=${market.slug}`,
+            category: market.categories?.[0],
+            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));
+            }
+          };
+        });
+      } catch (error) {
+        console.error("Error searching Limitless events:", error.message);
+        return [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/getMarketsBySlug.js
+var require_getMarketsBySlug2 = __commonJS({
+  "dist/exchanges/limitless/getMarketsBySlug.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.getMarketsBySlug = getMarketsBySlug;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function getMarketsBySlug(slug) {
+      try {
+        const response = await axios_1.default.get(`${utils_1.LIMITLESS_API_URL}/markets/${slug}`);
+        const market = response.data;
+        if (!market)
+          return [];
+        const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
+        return unifiedMarket ? [unifiedMarket] : [];
+      } catch (error) {
+        console.error(`Error fetching Limitless slug ${slug}:`, error.message);
+        return [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/fetchOHLCV.js
+var require_fetchOHLCV2 = __commonJS({
+  "dist/exchanges/limitless/fetchOHLCV.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.fetchOHLCV = fetchOHLCV;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function fetchOHLCV(id, params) {
+      try {
+        const fidelity = (0, utils_1.mapIntervalToFidelity)(params.resolution);
+        const url2 = `${utils_1.LIMITLESS_API_URL}/markets/${id}/historical-price`;
+        const response = await axios_1.default.get(url2, {
+          params: { fidelity }
+        });
+        const data = response.data;
+        const prices = data.prices || [];
+        let candles = prices.map((p) => {
+          const price = Number(p.price);
+          const ts = Number(p.timestamp);
+          return {
+            timestamp: ts,
+            open: price,
+            high: price,
+            low: price,
+            close: price,
+            volume: 0
+            // Volume not provided in this specific endpoint
+          };
+        }).sort((a, b) => a.timestamp - b.timestamp);
+        if (params.start) {
+          candles = candles.filter((c) => c.timestamp >= params.start.getTime());
+        }
+        if (params.end) {
+          candles = candles.filter((c) => c.timestamp <= params.end.getTime());
+        }
+        if (params.limit) {
+          candles = candles.slice(0, params.limit);
+        }
+        return candles;
+      } catch (error) {
+        console.error(`Error fetching Limitless history for ${id}:`, error.message);
+        return [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/fetchOrderBook.js
+var require_fetchOrderBook2 = __commonJS({
+  "dist/exchanges/limitless/fetchOrderBook.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.fetchOrderBook = fetchOrderBook;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function fetchOrderBook(id) {
+      try {
+        const url2 = `${utils_1.LIMITLESS_API_URL}/markets/${id}/orderbook`;
+        const response = await axios_1.default.get(url2);
+        const data = response.data;
+        const bids = (data.bids || []).map((level) => ({
+          price: parseFloat(level.price),
+          size: parseFloat(level.size)
+        })).sort((a, b) => b.price - a.price);
+        const asks = (data.asks || []).map((level) => ({
+          price: parseFloat(level.price),
+          size: parseFloat(level.size)
+        })).sort((a, b) => a.price - b.price);
+        return {
+          bids,
+          asks,
+          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.message);
+        return { bids: [], asks: [] };
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/fetchTrades.js
+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 [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/fetchPositions.js
+var require_fetchPositions2 = __commonJS({
+  "dist/exchanges/limitless/fetchPositions.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.fetchPositions = fetchPositions;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function fetchPositions(userAddress) {
+      try {
+        const url2 = `${utils_1.LIMITLESS_API_URL}/portfolio/${userAddress}/positions`;
+        const response = await axios_1.default.get(url2);
+        const data = response.data?.data || response.data || [];
+        return data.map((p) => ({
+          marketId: p.market?.slug || p.conditionId,
+          outcomeId: p.asset,
+          outcomeLabel: p.outcome || "Unknown",
+          size: parseFloat(p.size || "0"),
+          entryPrice: parseFloat(p.avgPrice || "0"),
+          currentPrice: parseFloat(p.curPrice || "0"),
+          unrealizedPnL: parseFloat(p.cashPnl || "0"),
+          realizedPnL: parseFloat(p.realizedPnl || "0")
+        }));
+      } catch (error) {
+        if (error.response?.status === 404) {
+          return [];
+        }
+        console.error(`Error fetching Limitless positions: ${error.message}`);
+        return [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/auth.js
+var require_auth2 = __commonJS({
+  "dist/exchanges/limitless/auth.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LimitlessAuth = void 0;
+    var clob_client_1 = (init_dist2(), __toCommonJS(dist_exports));
+    var ethers_1 = require_lib36();
+    var LIMITLESS_HOST = "https://api.limitless.exchange";
+    var BASE_CHAIN_ID = 8453;
+    var LimitlessAuth = class {
+      constructor(credentials) {
+        this.credentials = credentials;
+        if (!credentials.privateKey) {
+          throw new Error("Limitless requires a privateKey for authentication");
+        }
+        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.
+       */
+      async getApiCredentials() {
+        if (this.apiCreds) {
+          return this.apiCreds;
+        }
+        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;
+        }
+        const l1Client = new clob_client_1.ClobClient(LIMITLESS_HOST, BASE_CHAIN_ID, this.signer);
+        let creds;
+        try {
+          creds = await l1Client.deriveApiKey();
+        } catch (deriveError) {
+          try {
+            creds = await l1Client.createApiKey();
+          } catch (createError) {
+            console.error("Failed to both derive and create API key:", createError?.message || createError);
+            throw new Error("Authentication failed: Could not create or derive API key.");
+          }
+        }
+        if (!creds) {
+          throw new Error("Authentication failed: Credentials are empty.");
+        }
+        this.apiCreds = creds;
+        return creds;
+      }
+      /**
+       * Get an authenticated CLOB client for L2 operations (trading).
+       * This client can place orders, cancel orders, query positions, etc.
+       */
+      async getClobClient() {
+        if (this.clobClient) {
+          return this.clobClient;
+        }
+        const apiCreds = await this.getApiCredentials();
+        const signatureType = this.credentials.signatureType ?? 0;
+        const funderAddress = this.credentials.funderAddress ?? this.signer.address;
+        this.clobClient = new clob_client_1.ClobClient(LIMITLESS_HOST, BASE_CHAIN_ID, this.signer, apiCreds, signatureType, funderAddress);
+        return this.clobClient;
+      }
+      /**
+       * Get the signer's address.
+       */
+      getAddress() {
+        return this.signer.address;
+      }
+      /**
+       * Reset cached credentials and client (useful for testing or credential rotation).
+       */
+      reset() {
+        this.apiCreds = void 0;
+        this.clobClient = void 0;
+      }
+    };
+    exports2.LimitlessAuth = LimitlessAuth;
+  }
+});
+
+// dist/exchanges/limitless/websocket.js
+var require_websocket4 = __commonJS({
+  "dist/exchanges/limitless/websocket.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LimitlessWebSocket = void 0;
+    var LimitlessWebSocket = class {
+      constructor(_config = {}) {
+      }
+      async watchOrderBook(_id) {
+        throw new Error("Limitless WebSocket (watchOrderBook) is currently unavailable. The Limitless API v1 does not provide a public WebSocket endpoint for real-time updates. Please use fetchOrderBook() for polling instead.");
+      }
+      async watchTrades(_id) {
+        throw new Error("Limitless WebSocket (watchTrades) is currently unavailable. The Limitless API v1 does not provide a public WebSocket endpoint for real-time updates. Please use fetchOHLCV() or fetchOrderBook() for recent activity instead.");
+      }
+      async close() {
+      }
+    };
+    exports2.LimitlessWebSocket = LimitlessWebSocket;
+  }
+});
+
+// dist/exchanges/limitless/index.js
+var require_limitless = __commonJS({
+  "dist/exchanges/limitless/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LimitlessExchange = void 0;
+    var BaseExchange_1 = require_BaseExchange();
+    var fetchMarkets_1 = require_fetchMarkets2();
+    var searchMarkets_1 = require_searchMarkets2();
+    var searchEvents_1 = require_searchEvents2();
+    var getMarketsBySlug_1 = require_getMarketsBySlug2();
+    var fetchOHLCV_1 = require_fetchOHLCV2();
+    var fetchOrderBook_1 = require_fetchOrderBook2();
+    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 websocket_1 = require_websocket4();
+    var LimitlessExchange = class extends BaseExchange_1.PredictionMarketExchange {
+      constructor(options) {
+        let credentials;
+        let wsConfig;
+        if (options && "credentials" in options) {
+          credentials = options.credentials;
+          wsConfig = options.websocket;
+        } else if (options && "privateKey" in options) {
+          credentials = options;
+        } else {
+          credentials = options;
+        }
+        super(credentials);
+        this.wsConfig = wsConfig;
+        if (credentials?.privateKey) {
+          this.auth = new auth_1.LimitlessAuth(credentials);
+        }
+      }
+      get name() {
+        return "Limitless";
+      }
+      async fetchMarkets(params) {
+        return (0, fetchMarkets_1.fetchMarkets)(params);
+      }
+      async searchMarkets(query, params) {
+        return (0, searchMarkets_1.searchMarkets)(query, params);
+      }
+      async searchEvents(query, params) {
+        return (0, searchEvents_1.searchEvents)(query, params);
+      }
+      async getMarketsBySlug(slug) {
+        return (0, getMarketsBySlug_1.getMarketsBySlug)(slug);
+      }
+      async fetchOHLCV(id, params) {
+        return (0, fetchOHLCV_1.fetchOHLCV)(id, params);
+      }
+      async fetchOrderBook(id) {
+        return (0, fetchOrderBook_1.fetchOrderBook)(id);
+      }
+      async fetchTrades(id, params) {
+        return (0, fetchTrades_1.fetchTrades)(id, params);
+      }
+      // ----------------------------------------------------------------------------
+      // Trading Methods
+      // ----------------------------------------------------------------------------
+      /**
+       * Ensure authentication is initialized before trading operations.
+       */
+      ensureAuth() {
+        if (!this.auth) {
+          throw new Error('Trading operations require authentication. Initialize LimitlessExchange with credentials: new LimitlessExchange({ privateKey: "0x..." })');
+        }
+        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";
+          }
+        }
         try {
           const response = await client.createAndPostOrder({
             tokenID: params.outcomeId,
@@ -104847,7 +105639,7 @@ var require_polymarket = __commonJS({
             size: params.amount,
             feeRateBps: 0
           }, {
-            tickSize: "0.01"
+            tickSize
           });
           if (!response || !response.success) {
             throw new Error(response?.errorMsg || "Order placement failed");
@@ -104869,6 +105661,38 @@ var require_polymarket = __commonJS({
           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();
@@ -104934,7 +105758,7 @@ var require_polymarket = __commonJS({
             timestamp: o.created_at * 1e3
           }));
         } catch (error) {
-          console.error("Error fetching Polymarket open orders:", error);
+          console.error("Error fetching Limitless open orders:", error.message);
           return [];
         }
       }
@@ -104977,13 +105801,13 @@ var require_polymarket = __commonJS({
       }
       async watchOrderBook(id, limit) {
         if (!this.ws) {
-          this.ws = new websocket_1.PolymarketWebSocket(this.wsConfig);
+          this.ws = new websocket_1.LimitlessWebSocket(this.wsConfig);
         }
         return this.ws.watchOrderBook(id);
       }
       async watchTrades(id, since, limit) {
         if (!this.ws) {
-          this.ws = new websocket_1.PolymarketWebSocket(this.wsConfig);
+          this.ws = new websocket_1.LimitlessWebSocket(this.wsConfig);
         }
         return this.ws.watchTrades(id);
       }
@@ -104994,12 +105818,12 @@ var require_polymarket = __commonJS({
         }
       }
     };
-    exports2.PolymarketExchange = PolymarketExchange;
+    exports2.LimitlessExchange = LimitlessExchange;
   }
 });
 
 // dist/exchanges/kalshi/utils.js
-var require_utils10 = __commonJS({
+var require_utils11 = __commonJS({
   "dist/exchanges/kalshi/utils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -105089,7 +105913,7 @@ var require_utils10 = __commonJS({
 });
 
 // dist/exchanges/kalshi/fetchMarkets.js
-var require_fetchMarkets2 = __commonJS({
+var require_fetchMarkets3 = __commonJS({
   "dist/exchanges/kalshi/fetchMarkets.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105099,7 +105923,7 @@ var require_fetchMarkets2 = __commonJS({
     exports2.resetCache = resetCache;
     exports2.fetchMarkets = fetchMarkets;
     var axios_1 = __importDefault(require_axios());
-    var utils_1 = require_utils10();
+    var utils_1 = require_utils11();
     async function fetchActiveEvents(targetMarketCount) {
       let allEvents = [];
       let totalMarketCount = 0;
@@ -105219,12 +106043,12 @@ var require_fetchMarkets2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/searchMarkets.js
-var require_searchMarkets2 = __commonJS({
+var require_searchMarkets3 = __commonJS({
   "dist/exchanges/kalshi/searchMarkets.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.searchMarkets = searchMarkets;
-    var fetchMarkets_1 = require_fetchMarkets2();
+    var fetchMarkets_1 = require_fetchMarkets3();
     async function searchMarkets(query, params) {
       const fetchLimit = 1e5;
       try {
@@ -105251,7 +106075,7 @@ var require_searchMarkets2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/searchEvents.js
-var require_searchEvents2 = __commonJS({
+var require_searchEvents3 = __commonJS({
   "dist/exchanges/kalshi/searchEvents.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105260,7 +106084,7 @@ var require_searchEvents2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.searchEvents = searchEvents;
     var axios_1 = __importDefault(require_axios());
-    var utils_1 = require_utils10();
+    var utils_1 = require_utils11();
     async function searchEvents(query, params) {
       try {
         const queryParams = {
@@ -105313,7 +106137,7 @@ var require_searchEvents2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/getMarketsBySlug.js
-var require_getMarketsBySlug2 = __commonJS({
+var require_getMarketsBySlug3 = __commonJS({
   "dist/exchanges/kalshi/getMarketsBySlug.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105322,7 +106146,7 @@ var require_getMarketsBySlug2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getMarketsBySlug = getMarketsBySlug;
     var axios_1 = __importDefault(require_axios());
-    var utils_1 = require_utils10();
+    var utils_1 = require_utils11();
     async function getMarketsBySlug(eventTicker) {
       try {
         const normalizedTicker = eventTicker.toUpperCase();
@@ -105371,7 +106195,7 @@ var require_getMarketsBySlug2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/fetchOHLCV.js
-var require_fetchOHLCV2 = __commonJS({
+var require_fetchOHLCV3 = __commonJS({
   "dist/exchanges/kalshi/fetchOHLCV.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105380,7 +106204,7 @@ var require_fetchOHLCV2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.fetchOHLCV = fetchOHLCV;
     var axios_1 = __importDefault(require_axios());
-    var utils_1 = require_utils10();
+    var utils_1 = require_utils11();
     async function fetchOHLCV(id, params) {
       try {
         const cleanedId = id.replace(/-NO$/, "");
@@ -105458,7 +106282,7 @@ var require_fetchOHLCV2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/fetchOrderBook.js
-var require_fetchOrderBook2 = __commonJS({
+var require_fetchOrderBook3 = __commonJS({
   "dist/exchanges/kalshi/fetchOrderBook.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105509,7 +106333,7 @@ var require_fetchOrderBook2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/fetchTrades.js
-var require_fetchTrades2 = __commonJS({
+var require_fetchTrades3 = __commonJS({
   "dist/exchanges/kalshi/fetchTrades.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105545,7 +106369,7 @@ var require_fetchTrades2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/auth.js
-var require_auth2 = __commonJS({
+var require_auth3 = __commonJS({
   "dist/exchanges/kalshi/auth.js"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
@@ -105645,7 +106469,7 @@ var require_auth2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/websocket.js
-var require_websocket4 = __commonJS({
+var require_websocket5 = __commonJS({
   "dist/exchanges/kalshi/websocket.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105939,15 +106763,15 @@ var require_kalshi = __commonJS({
     exports2.KalshiExchange = void 0;
     var axios_1 = __importDefault(require_axios());
     var BaseExchange_1 = require_BaseExchange();
-    var fetchMarkets_1 = require_fetchMarkets2();
-    var searchMarkets_1 = require_searchMarkets2();
-    var searchEvents_1 = require_searchEvents2();
-    var getMarketsBySlug_1 = require_getMarketsBySlug2();
-    var fetchOHLCV_1 = require_fetchOHLCV2();
-    var fetchOrderBook_1 = require_fetchOrderBook2();
-    var fetchTrades_1 = require_fetchTrades2();
-    var auth_1 = require_auth2();
-    var websocket_1 = require_websocket4();
+    var fetchMarkets_1 = require_fetchMarkets3();
+    var searchMarkets_1 = require_searchMarkets3();
+    var searchEvents_1 = require_searchEvents3();
+    var getMarketsBySlug_1 = require_getMarketsBySlug3();
+    var fetchOHLCV_1 = require_fetchOHLCV3();
+    var fetchOrderBook_1 = require_fetchOrderBook3();
+    var fetchTrades_1 = require_fetchTrades3();
+    var auth_1 = require_auth3();
+    var websocket_1 = require_websocket5();
     var KalshiExchange = class extends BaseExchange_1.PredictionMarketExchange {
       constructor(options) {
         let credentials;
@@ -106233,9 +107057,11 @@ var require_app = __commonJS({
     var express_1 = __importDefault(require_express2());
     var cors_1 = __importDefault(require_lib3());
     var polymarket_1 = require_polymarket();
+    var limitless_1 = require_limitless();
     var kalshi_1 = require_kalshi();
     var defaultExchanges = {
       polymarket: null,
+      limitless: null,
       kalshi: null
     };
     async function startServer(port, accessToken) {
@@ -106299,6 +107125,13 @@ var require_app = __commonJS({
             apiSecret: credentials?.apiSecret || process.env.POLYMARKET_API_SECRET,
             passphrase: credentials?.passphrase || process.env.POLYMARKET_PASSPHRASE
           });
+        case "limitless":
+          return new limitless_1.LimitlessExchange({
+            privateKey: credentials?.privateKey || process.env.LIMITLESS_PK || process.env.LIMITLESS_PRIVATE_KEY,
+            apiKey: credentials?.apiKey || process.env.LIMITLESS_API_KEY,
+            apiSecret: credentials?.apiSecret || process.env.LIMITLESS_API_SECRET,
+            passphrase: credentials?.passphrase || process.env.LIMITLESS_PASSPHRASE
+          });
         case "kalshi":
           return new kalshi_1.KalshiExchange({
             apiKey: credentials?.apiKey || process.env.KALSHI_API_KEY,

pmxt/server_manager.py

@@ -209,15 +209,19 @@ class ServerManager:
         Start the server using the pmxt-ensure-server launcher.
         """
         # 1. Check for bundled server (PRODUCTION - installed via pip)
-        bundled_launcher = Path(__file__).parent / '_server' / 'bin' / 'pmxt-ensure-server'
-        
+        launcher_filename = 'pmxt-ensure-server'
+        if os.name == "nt": # Check if running Windows
+            launcher_filename += ".js"
+
+        bundled_launcher = Path(__file__).parent / '_server' / 'bin' / launcher_filename
+
         # 2. Check for monorepo structure (DEVELOPMENT)
         current_file = Path(__file__).resolve()
-        local_launcher = current_file.parent.parent.parent.parent / 'core' / 'bin' / 'pmxt-ensure-server'
-        
+        local_launcher = current_file.parent.parent.parent.parent / 'core' / 'bin' / launcher_filename
+
         # 3. Check PATH (GLOBAL INSTALL)
-        path_launcher = shutil.which('pmxt-ensure-server')
-        
+        path_launcher = shutil.which(launcher_filename)
+
         # Priority order: bundled > local dev > PATH
         if bundled_launcher.exists():
             launcher = str(bundled_launcher)
@@ -235,7 +239,7 @@ class ServerManager:
         
         # Call the launcher
         try:
-            # If it's a JS file and we are calling it directly, might need node
+            # If it's a JS file, and we are calling it directly, might need node
             cmd = [launcher]
             if launcher.endswith('.js') or not os.access(launcher, os.X_OK):
                 cmd = ['node', launcher]

{pmxt-1.4.0.dist-info → pmxt-1.5.0.dist-info}/METADATA

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

{pmxt-1.4.0.dist-info → pmxt-1.5.0.dist-info}/RECORD

@@ -1,14 +1,15 @@
-pmxt/__init__.py,sha256=MAOqnWgwuaG-IN2JEPoGdUrp2DHARbZAFjHd-SmyEvs,1150
+pmxt/__init__.py,sha256=ZPF_ko0cpffhd09VocB3qhkqlRaVOCmjuVkyZ6pkPU8,1150
 pmxt/client.py,sha256=1qa8ObZtf-tdzhDXQXvWWdeLvGbyxsiVHAgQvl8Z4Uk,32955
 pmxt/models.py,sha256=-jiQ9mmv_qnF6mzj3DrvNgEA77tE_Pl0RCblM1VbV7o,8581
-pmxt/server_manager.py,sha256=-G97dYEdKl7F3HK9bAOKYl-SGWP6HsvzZIx2QxiZm24,11494
+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/server/bundled.js,sha256=ETpsJ6ZmRtO1gQmBZYwwHWTHJIEI8ooeeMhOwoeDJ84,4198184
-pmxt_internal/__init__.py,sha256=Kbxeq4WFfhIjcDkz72ZeXhWFpecUcOXCwUgqUzs6qsw,7578
-pmxt_internal/api_client.py,sha256=2XZZdrKh90kAA4P3bJ54IdzRfAFMawSUqwnp2pRZNYA,27889
+pmxt/_server/bin/pmxt-ensure-server.js,sha256=kXIond0UbxS52FAVQD7kHmSBaL_s6cbIyapLRr4KZJw,4544
+pmxt/_server/server/bundled.js,sha256=vq8SwFCZcuApDMUupQGMDDOlSv7dy62LXNTODCRHiZc,4228689
+pmxt_internal/__init__.py,sha256=dyYj3OhFsjezgo0DTh1GPbUu9mIfKEHn-rHFI1awI4g,7578
+pmxt_internal/api_client.py,sha256=terc7r4idrh8DbO-6iQ5A54bb_eJL7H6GkBOjFwCUqA,27889
 pmxt_internal/api_response.py,sha256=eMxw1mpmJcoGZ3gs9z6jM4oYoZ10Gjk333s9sKxGv7s,652
-pmxt_internal/configuration.py,sha256=evyyjQzPpYofXsIUdNKTMlMbpmq38l2ISokDuXJ0qJ0,18320
+pmxt_internal/configuration.py,sha256=Qv9sYMIi_aut2V0cljQEWGDOrsjs5UcSZ_ipt3NAuSk,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
@@ -64,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.4.0.dist-info/METADATA,sha256=6fTb2tiWCkPoyKkYSs16e6yzhUdp-s-NaE7NPY6VFhc,6449
-pmxt-1.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pmxt-1.4.0.dist-info/top_level.txt,sha256=J_jrcouJ-x-5lpcXMxeW0GOSi1HsBVR5_PdSfvigVrw,19
-pmxt-1.4.0.dist-info/RECORD,,
+pmxt-1.5.0.dist-info/METADATA,sha256=Yj_I-KzPsqS3PERHSeeXCAbEwzYfLWW96ILbxUVa7dI,6449
+pmxt-1.5.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pmxt-1.5.0.dist-info/top_level.txt,sha256=J_jrcouJ-x-5lpcXMxeW0GOSi1HsBVR5_PdSfvigVrw,19
+pmxt-1.5.0.dist-info/RECORD,,

pmxt_internal/__init__.py

@@ -14,7 +14,7 @@
 """  # noqa: E501
 
 
-__version__ = "1.4.0"
+__version__ = "1.5.0"
 
 # 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.4.0/python'
+        self.user_agent = 'OpenAPI-Generator/1.5.0/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.4.0".\
+               "SDK Package Version: 1.5.0".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self) -> List[HostSetting]: