@limitless-exchange/sdk 0.0.1 → 0.0.3

package/dist/index.mjs

@@ -46,16 +46,11 @@ var Side = /* @__PURE__ */ ((Side2) => {
   Side2[Side2["SELL"] = 1] = "SELL";
   return Side2;
 })(Side || {});
-var OrderType = /* @__PURE__ */ ((OrderType3) => {
-  OrderType3["FOK"] = "FOK";
-  OrderType3["GTC"] = "GTC";
-  return OrderType3;
+var OrderType = /* @__PURE__ */ ((OrderType2) => {
+  OrderType2["FOK"] = "FOK";
+  OrderType2["GTC"] = "GTC";
+  return OrderType2;
 })(OrderType || {});
-var MarketType = /* @__PURE__ */ ((MarketType3) => {
-  MarketType3["CLOB"] = "CLOB";
-  MarketType3["NEGRISK"] = "NEGRISK";
-  return MarketType3;
-})(MarketType || {});
 var SignatureType = /* @__PURE__ */ ((SignatureType2) => {
   SignatureType2[SignatureType2["EOA"] = 0] = "EOA";
   SignatureType2[SignatureType2["POLY_PROXY"] = 1] = "POLY_PROXY";
@@ -435,6 +430,8 @@ var AuthenticatedClient = class {
 
 // src/api/http.ts
 import axios from "axios";
+import http from "http";
+import https from "https";
 
 // src/utils/constants.ts
 var DEFAULT_API_URL = "https://api.limitless.exchange";
@@ -446,24 +443,31 @@ var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var CONTRACT_ADDRESSES = {
   // Base mainnet (chainId: 8453)
   8453: {
-    CLOB: "0xa4409D988CA2218d956BeEFD3874100F444f0DC3",
-    NEGRISK: "0x5a38afc17F7E97ad8d6C547ddb837E40B4aEDfC6"
+    USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    // Native USDC on Base
+    CTF: "0xC9c98965297Bc527861c898329Ee280632B76e18"
+    // Conditional Token Framework
   },
   // Base Sepolia testnet (chainId: 84532)
   84532: {
-    CLOB: "0x...",
-    // Add testnet addresses when available
-    NEGRISK: "0x..."
+    USDC: "0x...",
+    CTF: "0x..."
   }
 };
-function getContractAddress(marketType, chainId = DEFAULT_CHAIN_ID) {
+function getContractAddress(contractType, chainId = DEFAULT_CHAIN_ID) {
   const addresses = CONTRACT_ADDRESSES[chainId];
   if (!addresses) {
     throw new Error(
       `No contract addresses configured for chainId ${chainId}. Supported chains: ${Object.keys(CONTRACT_ADDRESSES).join(", ")}`
     );
   }
-  return addresses[marketType];
+  const address = addresses[contractType];
+  if (!address || address === "0x...") {
+    throw new Error(
+      `Contract address for ${contractType} not available on chainId ${chainId}. Please configure the address in constants.ts or use environment variables.`
+    );
+  }
+  return address;
 }
 
 // src/api/http.ts
@@ -476,14 +480,39 @@ var HttpClient = class {
   constructor(config = {}) {
     this.sessionCookie = config.sessionCookie;
     this.logger = config.logger || new NoOpLogger();
+    const keepAlive = config.keepAlive !== false;
+    const maxSockets = config.maxSockets || 50;
+    const maxFreeSockets = config.maxFreeSockets || 10;
+    const socketTimeout = config.socketTimeout || 6e4;
+    const httpAgent = new http.Agent({
+      keepAlive,
+      maxSockets,
+      maxFreeSockets,
+      timeout: socketTimeout
+    });
+    const httpsAgent = new https.Agent({
+      keepAlive,
+      maxSockets,
+      maxFreeSockets,
+      timeout: socketTimeout
+    });
     this.client = axios.create({
       baseURL: config.baseURL || DEFAULT_API_URL,
       timeout: config.timeout || 3e4,
+      httpAgent,
+      httpsAgent,
       headers: {
         "Content-Type": "application/json",
-        Accept: "application/json"
+        Accept: "application/json",
+        ...config.additionalHeaders
       }
     });
+    this.logger.debug("HTTP client initialized", {
+      baseURL: config.baseURL || DEFAULT_API_URL,
+      keepAlive,
+      maxSockets,
+      maxFreeSockets
+    });
     this.setupInterceptors();
   }
   /**
@@ -864,8 +893,7 @@ var OrderBuilder = class {
    * const fokOrder = builder.buildOrder({
    *   tokenId: '123456',
    *   makerAmount: 50,  // 50 USDC to spend
-   *   side: Side.BUY,
-   *   marketType: MarketType.CLOB
+   *   side: Side.BUY
    * });
    *
    * // GTC order (price + size)
@@ -873,8 +901,7 @@ var OrderBuilder = class {
    *   tokenId: '123456',
    *   price: 0.38,
    *   size: 22.123,  // Will be rounded to tick-aligned: 22.123 shares
-   *   side: Side.BUY,
-   *   marketType: MarketType.CLOB
+   *   side: Side.BUY
    * });
    * ```
    */
@@ -1149,8 +1176,7 @@ var OrderSigner = class {
    * ```typescript
    * const signature = await signer.signOrder(unsignedOrder, {
    *   chainId: 8453,
-   *   contractAddress: '0x...',
-   *   marketType: MarketType.CLOB
+   *   contractAddress: '0x...'
    * });
    * ```
    */
@@ -1158,7 +1184,7 @@ var OrderSigner = class {
     this.logger.debug("Signing order with EIP-712", {
       tokenId: order.tokenId,
       side: order.side,
-      marketType: config.marketType
+      verifyingContract: config.contractAddress
     });
     const walletAddress = await this.wallet.getAddress();
     if (walletAddress.toLowerCase() !== order.signer.toLowerCase()) {
@@ -1383,14 +1409,221 @@ function validateSignedOrder(order) {
   }
 }
 
+// src/markets/fetcher.ts
+var MarketFetcher = class {
+  /**
+   * Creates a new market fetcher instance.
+   *
+   * @param httpClient - HTTP client for API requests
+   * @param logger - Optional logger for debugging (default: no logging)
+   *
+   * @example
+   * ```typescript
+   * const fetcher = new MarketFetcher(httpClient);
+   * ```
+   */
+  constructor(httpClient, logger) {
+    this.httpClient = httpClient;
+    this.logger = logger || new NoOpLogger();
+    this.venueCache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Gets active markets with query parameters and pagination support.
+   *
+   * @param params - Query parameters for filtering and pagination
+   * @returns Promise resolving to active markets response
+   * @throws Error if API request fails
+   *
+   * @example
+   * ```typescript
+   * // Get 8 markets sorted by LP rewards
+   * const response = await fetcher.getActiveMarkets({
+   *   limit: 8,
+   *   sortBy: 'lp_rewards'
+   * });
+   * console.log(`Found ${response.data.length} of ${response.totalMarketsCount} markets`);
+   *
+   * // Get page 2
+   * const page2 = await fetcher.getActiveMarkets({
+   *   limit: 8,
+   *   page: 2,
+   *   sortBy: 'ending_soon'
+   * });
+   * ```
+   */
+  async getActiveMarkets(params) {
+    const queryParams = new URLSearchParams();
+    if (params?.limit !== void 0) {
+      queryParams.append("limit", params.limit.toString());
+    }
+    if (params?.page !== void 0) {
+      queryParams.append("page", params.page.toString());
+    }
+    if (params?.sortBy) {
+      queryParams.append("sortBy", params.sortBy);
+    }
+    const queryString = queryParams.toString();
+    const endpoint = `/markets/active${queryString ? `?${queryString}` : ""}`;
+    this.logger.debug("Fetching active markets", { params });
+    try {
+      const response = await this.httpClient.get(endpoint);
+      this.logger.info("Active markets fetched successfully", {
+        count: response.data.length,
+        total: response.totalMarketsCount,
+        sortBy: params?.sortBy,
+        page: params?.page
+      });
+      return response;
+    } catch (error) {
+      this.logger.error("Failed to fetch active markets", error, { params });
+      throw error;
+    }
+  }
+  /**
+   * Gets a single market by slug.
+   *
+   * @remarks
+   * Automatically caches venue information for efficient order signing.
+   * Always call this method before creating orders to ensure venue data
+   * is available and avoid additional API requests.
+   *
+   * @param slug - Market slug identifier
+   * @returns Promise resolving to market details
+   * @throws Error if API request fails or market not found
+   *
+   * @example
+   * ```typescript
+   * const market = await fetcher.getMarket('bitcoin-price-2024');
+   * console.log(`Market: ${market.title}`);
+   *
+   * // Venue is now cached for order signing
+   * await orderClient.createOrder({
+   *   marketSlug: 'bitcoin-price-2024',
+   *   ...
+   * });
+   * ```
+   */
+  async getMarket(slug) {
+    this.logger.debug("Fetching market", { slug });
+    try {
+      const market = await this.httpClient.get(`/markets/${slug}`);
+      if (market.venue) {
+        this.venueCache.set(slug, market.venue);
+        this.logger.debug("Venue cached for order signing", {
+          slug,
+          exchange: market.venue.exchange,
+          adapter: market.venue.adapter,
+          cacheSize: this.venueCache.size
+        });
+      } else {
+        this.logger.warn("Market has no venue data", { slug });
+      }
+      this.logger.info("Market fetched successfully", {
+        slug,
+        title: market.title
+      });
+      return market;
+    } catch (error) {
+      this.logger.error("Failed to fetch market", error, { slug });
+      throw error;
+    }
+  }
+  /**
+   * Gets cached venue information for a market.
+   *
+   * @remarks
+   * Returns venue data previously cached by getMarket() call.
+   * Used internally by OrderClient for efficient order signing.
+   *
+   * @param slug - Market slug identifier
+   * @returns Cached venue information, or undefined if not in cache
+   *
+   * @example
+   * ```typescript
+   * const venue = fetcher.getVenue('bitcoin-price-2024');
+   * if (venue) {
+   *   console.log(`Exchange: ${venue.exchange}`);
+   * }
+   * ```
+   */
+  getVenue(slug) {
+    const venue = this.venueCache.get(slug);
+    if (venue) {
+      this.logger.debug("Venue cache hit", {
+        slug,
+        exchange: venue.exchange
+      });
+    } else {
+      this.logger.debug("Venue cache miss", { slug });
+    }
+    return venue;
+  }
+  /**
+   * Gets the orderbook for a CLOB market.
+   *
+   * @param slug - Market slug identifier
+   * @returns Promise resolving to orderbook data
+   * @throws Error if API request fails
+   *
+   * @example
+   * ```typescript
+   * const orderbook = await fetcher.getOrderBook('bitcoin-price-2024');
+   * console.log(`Bids: ${orderbook.bids.length}, Asks: ${orderbook.asks.length}`);
+   * ```
+   */
+  async getOrderBook(slug) {
+    this.logger.debug("Fetching orderbook", { slug });
+    try {
+      const orderbook = await this.httpClient.get(
+        `/markets/${slug}/orderbook`
+      );
+      this.logger.info("Orderbook fetched successfully", {
+        slug,
+        bids: orderbook.bids.length,
+        asks: orderbook.asks.length,
+        tokenId: orderbook.tokenId
+      });
+      return orderbook;
+    } catch (error) {
+      this.logger.error("Failed to fetch orderbook", error, { slug });
+      throw error;
+    }
+  }
+  /**
+   * Gets the current price for a token.
+   *
+   * @param tokenId - Token ID
+   * @returns Promise resolving to price information
+   * @throws Error if API request fails
+   *
+   * @example
+   * ```typescript
+   * const price = await fetcher.getPrice('123456');
+   * console.log(`Current price: ${price.price}`);
+   * ```
+   */
+  async getPrice(tokenId) {
+    this.logger.debug("Fetching price", { tokenId });
+    try {
+      const price = await this.httpClient.get(`/prices/${tokenId}`);
+      this.logger.info("Price fetched successfully", {
+        tokenId,
+        price: price.price
+      });
+      return price;
+    } catch (error) {
+      this.logger.error("Failed to fetch price", error, { tokenId });
+      throw error;
+    }
+  }
+};
+
 // src/orders/client.ts
 var OrderClient = class {
   /**
    * Creates a new order client instance.
    *
    * @param config - Order client configuration
-   *
-   * @throws Error if neither marketType nor signingConfig is provided
    */
   constructor(config) {
     this.httpClient = config.httpClient;
@@ -1399,32 +1632,18 @@ var OrderClient = class {
     const feeRateBps = config.userData.feeRateBps;
     this.orderBuilder = new OrderBuilder(config.wallet.address, feeRateBps, 1e-3);
     this.orderSigner = new OrderSigner(config.wallet, this.logger);
+    this.marketFetcher = config.marketFetcher || new MarketFetcher(config.httpClient, this.logger);
     if (config.signingConfig) {
       this.signingConfig = config.signingConfig;
-    } else if (config.marketType) {
-      const chainId = parseInt(process.env.CHAIN_ID || "8453");
-      const contractAddress = config.marketType === "NEGRISK" /* NEGRISK */ ? process.env.NEGRISK_CONTRACT_ADDRESS || getContractAddress("NEGRISK", chainId) : process.env.CLOB_CONTRACT_ADDRESS || getContractAddress("CLOB", chainId);
-      this.signingConfig = {
-        chainId,
-        contractAddress,
-        marketType: config.marketType
-      };
-      this.logger.info("Auto-configured signing", {
-        chainId,
-        contractAddress,
-        marketType: config.marketType
-      });
     } else {
       const chainId = parseInt(process.env.CHAIN_ID || "8453");
-      const contractAddress = process.env.CLOB_CONTRACT_ADDRESS || getContractAddress("CLOB", chainId);
+      const contractAddress = ZERO_ADDRESS;
       this.signingConfig = {
-        chainId,
-        contractAddress,
-        marketType: "CLOB" /* CLOB */
-      };
-      this.logger.debug("Using default CLOB configuration", {
         chainId,
         contractAddress
+      };
+      this.logger.info("Auto-configured signing (contract address from venue)", {
+        chainId
       });
     }
   }
@@ -1433,24 +1652,31 @@ var OrderClient = class {
    *
    * @remarks
    * This method handles the complete order creation flow:
-   * 1. Build unsigned order
-   * 2. Sign with EIP-712
-   * 3. Submit to API
+   * 1. Resolve venue address (from cache or API)
+   * 2. Build unsigned order
+   * 3. Sign with EIP-712 using venue.exchange as verifyingContract
+   * 4. Submit to API
+   *
+   * Performance best practice: Always call marketFetcher.getMarket(marketSlug)
+   * before createOrder() to cache venue data and avoid additional API requests.
    *
    * @param params - Order parameters
    * @returns Promise resolving to order response
    *
-   * @throws Error if order creation fails
+   * @throws Error if order creation fails or venue not found
    *
    * @example
    * ```typescript
+   * // Best practice: fetch market first to cache venue
+   * const market = await marketFetcher.getMarket('bitcoin-2024');
+   *
    * const order = await orderClient.createOrder({
-   *   tokenId: '123456',
+   *   tokenId: market.tokens.yes,
    *   price: 0.65,
    *   size: 100,
    *   side: Side.BUY,
    *   orderType: OrderType.GTC,
-   *   marketSlug: 'market-slug'
+   *   marketSlug: 'bitcoin-2024'
    * });
    *
    * console.log(`Order created: ${order.order.id}`);
@@ -1462,6 +1688,29 @@ var OrderClient = class {
       orderType: params.orderType,
       marketSlug: params.marketSlug
     });
+    let venue = this.marketFetcher.getVenue(params.marketSlug);
+    if (!venue) {
+      this.logger.warn(
+        "Venue not cached, fetching market details. For better performance, call marketFetcher.getMarket() before createOrder().",
+        { marketSlug: params.marketSlug }
+      );
+      const market = await this.marketFetcher.getMarket(params.marketSlug);
+      if (!market.venue) {
+        throw new Error(
+          `Market ${params.marketSlug} does not have venue information. Venue data is required for order signing.`
+        );
+      }
+      venue = market.venue;
+    }
+    const dynamicSigningConfig = {
+      ...this.signingConfig,
+      contractAddress: venue.exchange
+    };
+    this.logger.debug("Using venue for order signing", {
+      marketSlug: params.marketSlug,
+      exchange: venue.exchange,
+      adapter: venue.adapter
+    });
     const unsignedOrder = this.orderBuilder.buildOrder(params);
     this.logger.debug("Built unsigned order", {
       salt: unsignedOrder.salt,
@@ -1470,7 +1719,7 @@ var OrderClient = class {
     });
     const signature = await this.orderSigner.signOrder(
       unsignedOrder,
-      this.signingConfig
+      dynamicSigningConfig
     );
     const payload = {
       order: {
@@ -1653,162 +1902,6 @@ var OrderClient = class {
   }
 };
 
-// src/markets/fetcher.ts
-var MarketFetcher = class {
-  /**
-   * Creates a new market fetcher instance.
-   *
-   * @param httpClient - HTTP client for API requests
-   * @param logger - Optional logger for debugging (default: no logging)
-   *
-   * @example
-   * ```typescript
-   * const fetcher = new MarketFetcher(httpClient);
-   * ```
-   */
-  constructor(httpClient, logger) {
-    this.httpClient = httpClient;
-    this.logger = logger || new NoOpLogger();
-  }
-  /**
-   * Gets active markets with query parameters and pagination support.
-   *
-   * @param params - Query parameters for filtering and pagination
-   * @returns Promise resolving to active markets response
-   * @throws Error if API request fails
-   *
-   * @example
-   * ```typescript
-   * // Get 8 markets sorted by LP rewards
-   * const response = await fetcher.getActiveMarkets({
-   *   limit: 8,
-   *   sortBy: 'lp_rewards'
-   * });
-   * console.log(`Found ${response.data.length} of ${response.totalMarketsCount} markets`);
-   *
-   * // Get page 2
-   * const page2 = await fetcher.getActiveMarkets({
-   *   limit: 8,
-   *   page: 2,
-   *   sortBy: 'ending_soon'
-   * });
-   * ```
-   */
-  async getActiveMarkets(params) {
-    const queryParams = new URLSearchParams();
-    if (params?.limit !== void 0) {
-      queryParams.append("limit", params.limit.toString());
-    }
-    if (params?.page !== void 0) {
-      queryParams.append("page", params.page.toString());
-    }
-    if (params?.sortBy) {
-      queryParams.append("sortBy", params.sortBy);
-    }
-    const queryString = queryParams.toString();
-    const endpoint = `/markets/active${queryString ? `?${queryString}` : ""}`;
-    this.logger.debug("Fetching active markets", { params });
-    try {
-      const response = await this.httpClient.get(endpoint);
-      this.logger.info("Active markets fetched successfully", {
-        count: response.data.length,
-        total: response.totalMarketsCount,
-        sortBy: params?.sortBy,
-        page: params?.page
-      });
-      return response;
-    } catch (error) {
-      this.logger.error("Failed to fetch active markets", error, { params });
-      throw error;
-    }
-  }
-  /**
-   * Gets a single market by slug.
-   *
-   * @param slug - Market slug identifier
-   * @returns Promise resolving to market details
-   * @throws Error if API request fails or market not found
-   *
-   * @example
-   * ```typescript
-   * const market = await fetcher.getMarket('bitcoin-price-2024');
-   * console.log(`Market: ${market.title}`);
-   * ```
-   */
-  async getMarket(slug) {
-    this.logger.debug("Fetching market", { slug });
-    try {
-      const market = await this.httpClient.get(`/markets/${slug}`);
-      this.logger.info("Market fetched successfully", {
-        slug,
-        title: market.title
-      });
-      return market;
-    } catch (error) {
-      this.logger.error("Failed to fetch market", error, { slug });
-      throw error;
-    }
-  }
-  /**
-   * Gets the orderbook for a CLOB market.
-   *
-   * @param slug - Market slug identifier
-   * @returns Promise resolving to orderbook data
-   * @throws Error if API request fails
-   *
-   * @example
-   * ```typescript
-   * const orderbook = await fetcher.getOrderBook('bitcoin-price-2024');
-   * console.log(`Bids: ${orderbook.bids.length}, Asks: ${orderbook.asks.length}`);
-   * ```
-   */
-  async getOrderBook(slug) {
-    this.logger.debug("Fetching orderbook", { slug });
-    try {
-      const orderbook = await this.httpClient.get(
-        `/markets/${slug}/orderbook`
-      );
-      this.logger.info("Orderbook fetched successfully", {
-        slug,
-        bids: orderbook.bids.length,
-        asks: orderbook.asks.length,
-        tokenId: orderbook.tokenId
-      });
-      return orderbook;
-    } catch (error) {
-      this.logger.error("Failed to fetch orderbook", error, { slug });
-      throw error;
-    }
-  }
-  /**
-   * Gets the current price for a token.
-   *
-   * @param tokenId - Token ID
-   * @returns Promise resolving to price information
-   * @throws Error if API request fails
-   *
-   * @example
-   * ```typescript
-   * const price = await fetcher.getPrice('123456');
-   * console.log(`Current price: ${price.price}`);
-   * ```
-   */
-  async getPrice(tokenId) {
-    this.logger.debug("Fetching price", { tokenId });
-    try {
-      const price = await this.httpClient.get(`/prices/${tokenId}`);
-      this.logger.info("Price fetched successfully", {
-        tokenId,
-        price: price.price
-      });
-      return price;
-    } catch (error) {
-      this.logger.error("Failed to fetch price", error, { tokenId });
-      throw error;
-    }
-  }
-};
-
 // src/portfolio/fetcher.ts
 var PortfolioFetcher = class {
   /**
@@ -2458,7 +2551,6 @@ export {
   DEFAULT_WS_URL,
   HttpClient,
   MarketFetcher,
-  MarketType,
   MessageSigner,
   NoOpLogger,
   OrderBuilder,