@limitless-exchange/sdk 0.0.2 → 1.0.1

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";
@@ -73,250 +68,92 @@ var WebSocketState = /* @__PURE__ */ ((WebSocketState2) => {
   return WebSocketState2;
 })(WebSocketState || {});
 
-// src/auth/signer.ts
-import { ethers } from "ethers";
-var MessageSigner = class {
-  /**
-   * Creates a new message signer instance.
-   *
-   * @param wallet - Ethers wallet instance for signing
-   */
-  constructor(wallet) {
-    this.wallet = wallet;
-  }
-  /**
-   * Creates authentication headers for API requests.
-   *
-   * @param signingMessage - Message to sign from the API
-   * @returns Promise resolving to signature headers
-   *
-   * @example
-   * ```typescript
-   * const signer = new MessageSigner(wallet);
-   * const headers = await signer.createAuthHeaders(message);
-   * ```
-   */
-  async createAuthHeaders(signingMessage) {
-    const hexMessage = this.stringToHex(signingMessage);
-    const signature = await this.wallet.signMessage(signingMessage);
-    const address = this.wallet.address;
-    const recoveredAddress = ethers.verifyMessage(signingMessage, signature);
-    if (address.toLowerCase() !== recoveredAddress.toLowerCase()) {
-      throw new Error("Signature verification failed: address mismatch");
-    }
-    return {
-      "x-account": address,
-      "x-signing-message": hexMessage,
-      "x-signature": signature
-    };
-  }
-  /**
-   * Signs EIP-712 typed data.
-   *
-   * @param domain - EIP-712 domain
-   * @param types - EIP-712 types
-   * @param value - Value to sign
-   * @returns Promise resolving to signature string
-   *
-   * @example
-   * ```typescript
-   * const signature = await signer.signTypedData(domain, types, order);
-   * ```
-   */
-  async signTypedData(domain, types, value) {
-    return await this.wallet.signTypedData(domain, types, value);
-  }
-  /**
-   * Gets the wallet address.
-   *
-   * @returns Ethereum address
-   */
-  getAddress() {
-    return this.wallet.address;
-  }
-  /**
-   * Converts a string to hex format.
-   *
-   * @param text - String to convert
-   * @returns Hex string with 0x prefix
-   * @internal
-   */
-  stringToHex(text) {
-    return ethers.hexlify(ethers.toUtf8Bytes(text));
-  }
-};
-
-// src/auth/authenticator.ts
-var Authenticator = class {
+// src/types/market-class.ts
+var Market = class _Market {
   /**
-   * Creates a new authenticator instance.
-   *
-   * @param httpClient - HTTP client for API requests
-   * @param signer - Message signer for wallet operations
-   * @param logger - Optional logger for debugging and monitoring (default: no logging)
+   * Creates a Market instance.
    *
-   * @example
-   * ```typescript
-   * // Without logging (default)
-   * const authenticator = new Authenticator(httpClient, signer);
-   *
-   * // With logging
-   * import { ConsoleLogger } from '@limitless-exchange/sdk';
-   * const logger = new ConsoleLogger('debug');
-   * const authenticator = new Authenticator(httpClient, signer, logger);
-   * ```
+   * @param data - Market data from API
+   * @param httpClient - HTTP client for making requests
    */
-  constructor(httpClient, signer, logger) {
+  constructor(data, httpClient) {
+    Object.assign(this, data);
     this.httpClient = httpClient;
-    this.signer = signer;
-    this.logger = logger || new NoOpLogger();
+    if (data.markets && Array.isArray(data.markets)) {
+      this.markets = data.markets.map((m) => new _Market(m, httpClient));
+    }
   }
   /**
-   * Gets a signing message from the API.
-   *
-   * @returns Promise resolving to signing message string
-   * @throws Error if API request fails
+   * Get user's orders for this market.
    *
-   * @example
-   * ```typescript
-   * const message = await authenticator.getSigningMessage();
-   * console.log(message);
-   * ```
-   */
-  async getSigningMessage() {
-    this.logger.debug("Requesting signing message from API");
-    const message = await this.httpClient.get("/auth/signing-message");
-    this.logger.debug("Received signing message", { length: message.length });
-    return message;
-  }
-  /**
-   * Authenticates with the API and obtains session cookie.
+   * @remarks
+   * Fetches all orders placed by the authenticated user for this specific market.
+   * Uses the http_client from the MarketFetcher that created this Market instance.
    *
-   * @param options - Login options including client type and smart wallet
-   * @returns Promise resolving to authentication result
-   * @throws Error if authentication fails or smart wallet is required but not provided
+   * @returns Promise resolving to array of user orders
+   * @throws Error if market wasn't fetched via MarketFetcher
    *
    * @example
    * ```typescript
-   * // EOA authentication
-   * const result = await authenticator.authenticate({ client: 'eoa' });
-   *
-   * // ETHERSPOT with smart wallet
-   * const result = await authenticator.authenticate({
-   *   client: 'etherspot',
-   *   smartWallet: '0x...'
-   * });
+   * // Clean fluent API
+   * const market = await marketFetcher.getMarket("bitcoin-2024");
+   * const orders = await market.getUserOrders();
+   * console.log(`You have ${orders.length} orders in ${market.title}`);
    * ```
    */
-  async authenticate(options = {}) {
-    const client = options.client || "eoa";
-    this.logger.info("Starting authentication", {
-      client,
-      hasSmartWallet: !!options.smartWallet
-    });
-    if (client === "etherspot" && !options.smartWallet) {
-      this.logger.error("Smart wallet address required for ETHERSPOT client");
-      throw new Error("Smart wallet address is required for ETHERSPOT client");
-    }
-    try {
-      const signingMessage = await this.getSigningMessage();
-      this.logger.debug("Creating signature headers");
-      const headers = await this.signer.createAuthHeaders(signingMessage);
-      this.logger.debug("Sending authentication request", { client });
-      const response = await this.httpClient.postWithResponse(
-        "/auth/login",
-        { client, smartWallet: options.smartWallet },
-        {
-          headers,
-          validateStatus: (status) => status < 500
-        }
+  async getUserOrders() {
+    if (!this.httpClient) {
+      throw new Error(
+        "This Market instance has no httpClient attached. Make sure to fetch the market via MarketFetcher.getMarket() to use this method."
       );
-      this.logger.debug("Extracting session cookie from response");
-      const cookies = this.httpClient.extractCookies(response);
-      const sessionCookie = cookies["limitless_session"];
-      if (!sessionCookie) {
-        this.logger.error("Session cookie not found in response headers");
-        throw new Error("Failed to obtain session cookie from response");
-      }
-      this.httpClient.setSessionCookie(sessionCookie);
-      this.logger.info("Authentication successful", {
-        account: response.data.account,
-        client: response.data.client
-      });
-      return {
-        sessionCookie,
-        profile: response.data
-      };
-    } catch (error) {
-      this.logger.error("Authentication failed", error, {
-        client
-      });
-      throw error;
-    }
-  }
-  /**
-   * Verifies the current authentication status.
-   *
-   * @param sessionCookie - Session cookie to verify
-   * @returns Promise resolving to user's Ethereum address
-   * @throws Error if session is invalid
-   *
-   * @example
-   * ```typescript
-   * const address = await authenticator.verifyAuth(sessionCookie);
-   * console.log(`Authenticated as: ${address}`);
-   * ```
-   */
-  async verifyAuth(sessionCookie) {
-    this.logger.debug("Verifying authentication session");
-    const originalCookie = this.httpClient["sessionCookie"];
-    this.httpClient.setSessionCookie(sessionCookie);
-    try {
-      const address = await this.httpClient.get("/auth/verify-auth");
-      this.logger.info("Session verified", { address });
-      return address;
-    } catch (error) {
-      this.logger.error("Session verification failed", error);
-      throw error;
-    } finally {
-      if (originalCookie) {
-        this.httpClient.setSessionCookie(originalCookie);
-      } else {
-        this.httpClient.clearSessionCookie();
-      }
     }
+    const response = await this.httpClient.get(`/markets/${this.slug}/user-orders`);
+    const orders = Array.isArray(response) ? response : response.orders || [];
+    return orders;
   }
-  /**
-   * Logs out and clears the session.
-   *
-   * @param sessionCookie - Session cookie to invalidate
-   * @throws Error if logout request fails
-   *
-   * @example
-   * ```typescript
-   * await authenticator.logout(sessionCookie);
-   * console.log('Logged out successfully');
-   * ```
-   */
-  async logout(sessionCookie) {
-    this.logger.debug("Logging out session");
-    const originalCookie = this.httpClient["sessionCookie"];
-    this.httpClient.setSessionCookie(sessionCookie);
-    try {
-      await this.httpClient.post("/auth/logout", {});
-      this.logger.info("Logout successful");
-    } catch (error) {
-      this.logger.error("Logout failed", error);
-      throw error;
-    } finally {
-      if (originalCookie) {
-        this.httpClient.setSessionCookie(originalCookie);
-      } else {
-        this.httpClient.clearSessionCookie();
-      }
-    }
+};
+
+// 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";
+var DEFAULT_WS_URL = "wss://ws.limitless.exchange";
+var DEFAULT_CHAIN_ID = 8453;
+var BASE_SEPOLIA_CHAIN_ID = 84532;
+var SIGNING_MESSAGE_TEMPLATE = "Welcome to Limitless.exchange! Please sign this message to verify your identity.\n\nNonce: {NONCE}";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var CONTRACT_ADDRESSES = {
+  // Base mainnet (chainId: 8453)
+  8453: {
+    USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    // Native USDC on Base
+    CTF: "0xC9c98965297Bc527861c898329Ee280632B76e18"
+    // Conditional Token Framework
+  },
+  // Base Sepolia testnet (chainId: 84532)
+  84532: {
+    USDC: "0x...",
+    CTF: "0x..."
   }
 };
+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(", ")}`
+    );
+  }
+  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/errors.ts
 var APIError = class _APIError extends Error {
@@ -362,111 +199,33 @@ var APIError = class _APIError extends Error {
     return this.status === 401 || this.status === 403;
   }
 };
-
-// src/auth/authenticated-client.ts
-var AuthenticatedClient = class {
-  /**
-   * Creates a new authenticated client with auto-retry capability.
-   *
-   * @param config - Configuration for authenticated client
-   */
-  constructor(config) {
-    this.httpClient = config.httpClient;
-    this.authenticator = config.authenticator;
-    this.client = config.client;
-    this.smartWallet = config.smartWallet;
-    this.logger = config.logger || new NoOpLogger();
-    this.maxRetries = config.maxRetries ?? 1;
-  }
-  /**
-   * Executes a function with automatic retry on authentication errors.
-   *
-   * @param fn - Function to execute with auth retry
-   * @returns Promise resolving to the function result
-   * @throws Error if max retries exceeded or non-auth error occurs
-   *
-   * @example
-   * ```typescript
-   * // Automatic retry on 401/403
-   * const positions = await authClient.withRetry(() =>
-   *   portfolioFetcher.getPositions()
-   * );
-   *
-   * // Works with any async operation
-   * const order = await authClient.withRetry(() =>
-   *   orderClient.createOrder({ ... })
-   * );
-   * ```
-   */
-  async withRetry(fn) {
-    let attempts = 0;
-    while (attempts <= this.maxRetries) {
-      try {
-        return await fn();
-      } catch (error) {
-        if (error instanceof APIError && error.isAuthError() && attempts < this.maxRetries) {
-          this.logger.info("Authentication expired, re-authenticating...", {
-            attempt: attempts + 1,
-            maxRetries: this.maxRetries
-          });
-          await this.reauthenticate();
-          attempts++;
-          continue;
-        }
-        throw error;
-      }
+var RateLimitError = class _RateLimitError extends APIError {
+  constructor(message = "Rate limit exceeded", status = 429, data = null, url, method) {
+    super(message, status, data, url, method);
+    this.name = "RateLimitError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _RateLimitError);
     }
-    throw new Error("Unexpected error: exceeded max retries");
-  }
-  /**
-   * Re-authenticates with the API.
-   *
-   * @internal
-   */
-  async reauthenticate() {
-    this.logger.debug("Re-authenticating with API");
-    await this.authenticator.authenticate({
-      client: this.client,
-      smartWallet: this.smartWallet
-    });
-    this.logger.info("Re-authentication successful");
   }
 };
-
-// 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";
-var DEFAULT_WS_URL = "wss://ws.limitless.exchange";
-var DEFAULT_CHAIN_ID = 8453;
-var BASE_SEPOLIA_CHAIN_ID = 84532;
-var SIGNING_MESSAGE_TEMPLATE = "Welcome to Limitless.exchange! Please sign this message to verify your identity.\n\nNonce: {NONCE}";
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-var CONTRACT_ADDRESSES = {
-  // Base mainnet (chainId: 8453)
-  8453: {
-    CLOB: "0xa4409D988CA2218d956BeEFD3874100F444f0DC3",
-    NEGRISK: "0x5a38afc17F7E97ad8d6C547ddb837E40B4aEDfC6"
-  },
-  // Base Sepolia testnet (chainId: 84532)
-  84532: {
-    CLOB: "0x...",
-    // Add testnet addresses when available
-    NEGRISK: "0x..."
+var AuthenticationError = class _AuthenticationError extends APIError {
+  constructor(message = "Authentication failed", status = 401, data = null, url, method) {
+    super(message, status, data, url, method);
+    this.name = "AuthenticationError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _AuthenticationError);
+    }
   }
 };
-function getContractAddress(marketType, 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(", ")}`
-    );
+var ValidationError = class _ValidationError extends APIError {
+  constructor(message, status = 400, data = null, url, method) {
+    super(message, status, data, url, method);
+    this.name = "ValidationError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ValidationError);
+    }
   }
-  return addresses[marketType];
-}
+};
 
 // src/api/http.ts
 var HttpClient = class {
@@ -476,8 +235,13 @@ var HttpClient = class {
    * @param config - Configuration options for the HTTP client
    */
   constructor(config = {}) {
-    this.sessionCookie = config.sessionCookie;
+    this.apiKey = config.apiKey || process.env.LIMITLESS_API_KEY;
     this.logger = config.logger || new NoOpLogger();
+    if (!this.apiKey) {
+      this.logger.warn(
+        "API key not set. Authenticated endpoints will fail. Set LIMITLESS_API_KEY environment variable or pass apiKey parameter."
+      );
+    }
     const keepAlive = config.keepAlive !== false;
     const maxSockets = config.maxSockets || 50;
     const maxFreeSockets = config.maxFreeSockets || 10;
@@ -520,13 +284,17 @@ var HttpClient = class {
   setupInterceptors() {
     this.client.interceptors.request.use(
       (config) => {
-        if (this.sessionCookie) {
-          config.headers["Cookie"] = `limitless_session=${this.sessionCookie}`;
+        if (this.apiKey) {
+          config.headers["X-API-Key"] = this.apiKey;
         }
         const fullUrl = `${config.baseURL || ""}${config.url || ""}`;
         const method = config.method?.toUpperCase() || "GET";
+        const logHeaders = { ...config.headers };
+        if (logHeaders["X-API-Key"]) {
+          logHeaders["X-API-Key"] = "***";
+        }
         this.logger.debug(`\u2192 ${method} ${fullUrl}`, {
-          headers: config.headers,
+          headers: logHeaders,
           body: config.data
         });
         return config;
@@ -567,7 +335,15 @@ var HttpClient = class {
               message = String(data);
             }
           }
-          throw new APIError(message, status, data, url, method);
+          if (status === 429) {
+            throw new RateLimitError(message, status, data, url, method);
+          } else if (status === 401 || status === 403) {
+            throw new AuthenticationError(message, status, data, url, method);
+          } else if (status === 400) {
+            throw new ValidationError(message, status, data, url, method);
+          } else {
+            throw new APIError(message, status, data, url, method);
+          }
         } else if (error.request) {
           throw new Error("No response received from API");
         } else {
@@ -577,18 +353,18 @@ var HttpClient = class {
     );
   }
   /**
-   * Sets the session cookie for authenticated requests.
+   * Sets the API key for authenticated requests.
    *
-   * @param cookie - Session cookie value
+   * @param apiKey - API key value
    */
-  setSessionCookie(cookie) {
-    this.sessionCookie = cookie;
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
   }
   /**
-   * Clears the session cookie.
+   * Clears the API key.
    */
-  clearSessionCookie() {
-    this.sessionCookie = void 0;
+  clearApiKey() {
+    this.apiKey = void 0;
   }
   /**
    * Performs a GET request.
@@ -613,19 +389,6 @@ var HttpClient = class {
     const response = await this.client.post(url, data, config);
     return response.data;
   }
-  /**
-   * Performs a POST request and returns the full response object.
-   * Useful when you need access to response headers (e.g., for cookie extraction).
-   *
-   * @param url - Request URL
-   * @param data - Request body data
-   * @param config - Additional request configuration
-   * @returns Promise resolving to the full AxiosResponse object
-   * @internal
-   */
-  async postWithResponse(url, data, config) {
-    return await this.client.post(url, data, config);
-  }
   /**
    * Performs a DELETE request.
    *
@@ -648,26 +411,6 @@ var HttpClient = class {
     const response = await this.client.delete(url, deleteConfig);
     return response.data;
   }
-  /**
-   * Extracts cookies from response headers.
-   *
-   * @param response - Axios response object
-   * @returns Object containing parsed cookies
-   * @internal
-   */
-  extractCookies(response) {
-    const setCookie = response.headers["set-cookie"];
-    if (!setCookie) return {};
-    const cookies = {};
-    const cookieStrings = Array.isArray(setCookie) ? setCookie : [setCookie];
-    for (const cookieString of cookieStrings) {
-      const parts = cookieString.split(";")[0].split("=");
-      if (parts.length === 2) {
-        cookies[parts[0].trim()] = parts[1].trim();
-      }
-    }
-    return cookies;
-  }
 };
 
 // src/api/retry.ts
@@ -852,7 +595,7 @@ var RetryableClient = class {
 };
 
 // src/orders/builder.ts
-import { ethers as ethers2 } from "ethers";
+import { ethers } from "ethers";
 var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
 var DEFAULT_PRICE_TICK = 1e-3;
 var OrderBuilder = class {
@@ -891,8 +634,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)
@@ -900,8 +642,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
    * });
    * ```
    */
@@ -936,7 +677,7 @@ var OrderBuilder = class {
    * @internal
    */
   isFOKOrder(args) {
-    return "amount" in args;
+    return "makerAmount" in args;
   }
   /**
    * Generates a unique salt using timestamp + nano-offset pattern.
@@ -1090,7 +831,7 @@ var OrderBuilder = class {
       }
     }
     const amountFormatted = makerAmount.toFixed(DECIMALS);
-    const amountScaled = ethers2.parseUnits(amountFormatted, DECIMALS);
+    const amountScaled = ethers.parseUnits(amountFormatted, DECIMALS);
     const collateralAmount = Number(amountScaled);
     return {
       makerAmount: collateralAmount,
@@ -1110,7 +851,7 @@ var OrderBuilder = class {
     if (!args.tokenId || args.tokenId === "0") {
       throw new Error("Invalid tokenId: tokenId is required.");
     }
-    if (args.taker && !ethers2.isAddress(args.taker)) {
+    if (args.taker && !ethers.isAddress(args.taker)) {
       throw new Error(`Invalid taker address: ${args.taker}`);
     }
     if (this.isFOKOrder(args)) {
@@ -1121,7 +862,7 @@ var OrderBuilder = class {
         throw new Error(`Invalid makerAmount: ${args.makerAmount}. Maker amount must be positive.`);
       }
     } else {
-      if (args.price < 0 || args.price > 1) {
+      if (args.price == null || args.price < 0 || args.price > 1) {
         throw new Error(`Invalid price: ${args.price}. Price must be between 0 and 1.`);
       }
       if (args.size <= 0) {
@@ -1176,8 +917,7 @@ var OrderSigner = class {
    * ```typescript
    * const signature = await signer.signOrder(unsignedOrder, {
    *   chainId: 8453,
-   *   contractAddress: '0x...',
-   *   marketType: MarketType.CLOB
+   *   contractAddress: '0x...'
    * });
    * ```
    */
@@ -1185,7 +925,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()) {
@@ -1211,11 +951,11 @@ var OrderSigner = class {
       signatureType: order.signatureType
     };
     this.logger.debug("EIP-712 Order Value", orderValue);
-    console.log("[OrderSigner] Full signing payload:", JSON.stringify({
+    this.logger.debug("Full signing payload", {
       domain,
       types: this.getTypes(),
       value: orderValue
-    }, null, 2));
+    });
     try {
       const signature = await this.wallet.signTypedData(domain, types, orderValue);
       this.logger.info("Successfully generated EIP-712 signature", {
@@ -1275,11 +1015,11 @@ var OrderSigner = class {
 };
 
 // src/orders/validator.ts
-import { ethers as ethers3 } from "ethers";
-var ValidationError = class extends Error {
+import { ethers as ethers2 } from "ethers";
+var OrderValidationError = class extends Error {
   constructor(message) {
     super(message);
-    this.name = "ValidationError";
+    this.name = "OrderValidationError";
   }
 };
 function isFOKOrder(args) {
@@ -1287,418 +1027,149 @@ function isFOKOrder(args) {
 }
 function validateOrderArgs(args) {
   if (!args.tokenId) {
-    throw new ValidationError("TokenId is required");
+    throw new OrderValidationError("TokenId is required");
   }
   if (args.tokenId === "0") {
-    throw new ValidationError("TokenId cannot be zero");
+    throw new OrderValidationError("TokenId cannot be zero");
   }
   if (!/^\d+$/.test(args.tokenId)) {
-    throw new ValidationError(`Invalid tokenId format: ${args.tokenId}`);
+    throw new OrderValidationError(`Invalid tokenId format: ${args.tokenId}`);
   }
-  if (args.taker && !ethers3.isAddress(args.taker)) {
-    throw new ValidationError(`Invalid taker address: ${args.taker}`);
+  if (args.taker && !ethers2.isAddress(args.taker)) {
+    throw new OrderValidationError(`Invalid taker address: ${args.taker}`);
   }
   if (args.expiration !== void 0) {
     if (!/^\d+$/.test(args.expiration)) {
-      throw new ValidationError(`Invalid expiration format: ${args.expiration}`);
+      throw new OrderValidationError(`Invalid expiration format: ${args.expiration}`);
     }
   }
   if (args.nonce !== void 0) {
     if (!Number.isInteger(args.nonce) || args.nonce < 0) {
-      throw new ValidationError(`Invalid nonce: ${args.nonce}`);
+      throw new OrderValidationError(`Invalid nonce: ${args.nonce}`);
     }
   }
   if (isFOKOrder(args)) {
     if (typeof args.makerAmount !== "number" || isNaN(args.makerAmount)) {
-      throw new ValidationError("Amount must be a valid number");
+      throw new OrderValidationError("Amount must be a valid number");
     }
     if (args.makerAmount <= 0) {
-      throw new ValidationError(`Amount must be positive, got: ${args.makerAmount}`);
+      throw new OrderValidationError(`Amount must be positive, got: ${args.makerAmount}`);
     }
     const amountStr = args.makerAmount.toString();
     const decimalIndex = amountStr.indexOf(".");
     if (decimalIndex !== -1) {
       const decimalPlaces = amountStr.length - decimalIndex - 1;
       if (decimalPlaces > 2) {
-        throw new ValidationError(
+        throw new OrderValidationError(
           `Amount must have max 2 decimal places, got: ${args.makerAmount} (${decimalPlaces} decimals)`
         );
       }
     }
   } else {
     if (typeof args.price !== "number" || isNaN(args.price)) {
-      throw new ValidationError("Price must be a valid number");
+      throw new OrderValidationError("Price must be a valid number");
     }
     if (args.price < 0 || args.price > 1) {
-      throw new ValidationError(`Price must be between 0 and 1, got: ${args.price}`);
+      throw new OrderValidationError(`Price must be between 0 and 1, got: ${args.price}`);
     }
     if (typeof args.size !== "number" || isNaN(args.size)) {
-      throw new ValidationError("Size must be a valid number");
+      throw new OrderValidationError("Size must be a valid number");
     }
     if (args.size <= 0) {
-      throw new ValidationError(`Size must be positive, got: ${args.size}`);
+      throw new OrderValidationError(`Size must be positive, got: ${args.size}`);
     }
   }
 }
 function validateUnsignedOrder(order) {
-  if (!ethers3.isAddress(order.maker)) {
-    throw new ValidationError(`Invalid maker address: ${order.maker}`);
+  if (!ethers2.isAddress(order.maker)) {
+    throw new OrderValidationError(`Invalid maker address: ${order.maker}`);
   }
-  if (!ethers3.isAddress(order.signer)) {
-    throw new ValidationError(`Invalid signer address: ${order.signer}`);
+  if (!ethers2.isAddress(order.signer)) {
+    throw new OrderValidationError(`Invalid signer address: ${order.signer}`);
   }
-  if (!ethers3.isAddress(order.taker)) {
-    throw new ValidationError(`Invalid taker address: ${order.taker}`);
+  if (!ethers2.isAddress(order.taker)) {
+    throw new OrderValidationError(`Invalid taker address: ${order.taker}`);
   }
   if (!order.makerAmount || order.makerAmount === 0) {
-    throw new ValidationError("MakerAmount must be greater than zero");
+    throw new OrderValidationError("MakerAmount must be greater than zero");
   }
   if (!order.takerAmount || order.takerAmount === 0) {
-    throw new ValidationError("TakerAmount must be greater than zero");
+    throw new OrderValidationError("TakerAmount must be greater than zero");
   }
   if (typeof order.makerAmount !== "number" || order.makerAmount <= 0) {
-    throw new ValidationError(`Invalid makerAmount: ${order.makerAmount}`);
+    throw new OrderValidationError(`Invalid makerAmount: ${order.makerAmount}`);
   }
   if (typeof order.takerAmount !== "number" || order.takerAmount <= 0) {
-    throw new ValidationError(`Invalid takerAmount: ${order.takerAmount}`);
+    throw new OrderValidationError(`Invalid takerAmount: ${order.takerAmount}`);
   }
   if (!/^\d+$/.test(order.tokenId)) {
-    throw new ValidationError(`Invalid tokenId format: ${order.tokenId}`);
+    throw new OrderValidationError(`Invalid tokenId format: ${order.tokenId}`);
   }
   if (!/^\d+$/.test(order.expiration)) {
-    throw new ValidationError(`Invalid expiration format: ${order.expiration}`);
+    throw new OrderValidationError(`Invalid expiration format: ${order.expiration}`);
   }
   if (!Number.isInteger(order.salt) || order.salt <= 0) {
-    throw new ValidationError(`Invalid salt: ${order.salt}`);
+    throw new OrderValidationError(`Invalid salt: ${order.salt}`);
   }
   if (!Number.isInteger(order.nonce) || order.nonce < 0) {
-    throw new ValidationError(`Invalid nonce: ${order.nonce}`);
+    throw new OrderValidationError(`Invalid nonce: ${order.nonce}`);
   }
   if (!Number.isInteger(order.feeRateBps) || order.feeRateBps < 0) {
-    throw new ValidationError(`Invalid feeRateBps: ${order.feeRateBps}`);
+    throw new OrderValidationError(`Invalid feeRateBps: ${order.feeRateBps}`);
   }
   if (order.side !== 0 && order.side !== 1) {
-    throw new ValidationError(`Invalid side: ${order.side}. Must be 0 (BUY) or 1 (SELL)`);
+    throw new OrderValidationError(`Invalid side: ${order.side}. Must be 0 (BUY) or 1 (SELL)`);
   }
   if (!Number.isInteger(order.signatureType) || order.signatureType < 0) {
-    throw new ValidationError(`Invalid signatureType: ${order.signatureType}`);
+    throw new OrderValidationError(`Invalid signatureType: ${order.signatureType}`);
   }
   if (order.price !== void 0) {
     if (typeof order.price !== "number" || isNaN(order.price)) {
-      throw new ValidationError("Price must be a valid number");
+      throw new OrderValidationError("Price must be a valid number");
     }
     if (order.price < 0 || order.price > 1) {
-      throw new ValidationError(`Price must be between 0 and 1, got: ${order.price}`);
+      throw new OrderValidationError(`Price must be between 0 and 1, got: ${order.price}`);
     }
   }
 }
 function validateSignedOrder(order) {
   validateUnsignedOrder(order);
   if (!order.signature) {
-    throw new ValidationError("Signature is required");
+    throw new OrderValidationError("Signature is required");
   }
   if (!order.signature.startsWith("0x")) {
-    throw new ValidationError("Signature must start with 0x");
+    throw new OrderValidationError("Signature must start with 0x");
   }
   if (order.signature.length !== 132) {
-    throw new ValidationError(
+    throw new OrderValidationError(
       `Invalid signature length: ${order.signature.length}. Expected 132 characters.`
     );
   }
   if (!/^0x[0-9a-fA-F]{130}$/.test(order.signature)) {
-    throw new ValidationError("Signature must be valid hex string");
+    throw new OrderValidationError("Signature must be valid hex string");
   }
 }
 
-// src/orders/client.ts
-var OrderClient = class {
+// src/markets/fetcher.ts
+var MarketFetcher = class {
   /**
-   * Creates a new order client instance.
+   * Creates a new market fetcher instance.
    *
-   * @param config - Order client configuration
+   * @param httpClient - HTTP client for API requests
+   * @param logger - Optional logger for debugging (default: no logging)
    *
-   * @throws Error if neither marketType nor signingConfig is provided
+   * @example
+   * ```typescript
+   * const fetcher = new MarketFetcher(httpClient);
+   * ```
    */
-  constructor(config) {
-    this.httpClient = config.httpClient;
-    this.logger = config.logger || new NoOpLogger();
-    this.ownerId = config.userData.userId;
-    const feeRateBps = config.userData.feeRateBps;
-    this.orderBuilder = new OrderBuilder(config.wallet.address, feeRateBps, 1e-3);
-    this.orderSigner = new OrderSigner(config.wallet, 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);
-      this.signingConfig = {
-        chainId,
-        contractAddress,
-        marketType: "CLOB" /* CLOB */
-      };
-      this.logger.debug("Using default CLOB configuration", {
-        chainId,
-        contractAddress
-      });
-    }
+  constructor(httpClient, logger) {
+    this.httpClient = httpClient;
+    this.logger = logger || new NoOpLogger();
+    this.venueCache = /* @__PURE__ */ new Map();
   }
   /**
-   * Creates and submits a new order.
-   *
-   * @remarks
-   * This method handles the complete order creation flow:
-   * 1. Build unsigned order
-   * 2. Sign with EIP-712
-   * 3. Submit to API
-   *
-   * @param params - Order parameters
-   * @returns Promise resolving to order response
-   *
-   * @throws Error if order creation fails
-   *
-   * @example
-   * ```typescript
-   * const order = await orderClient.createOrder({
-   *   tokenId: '123456',
-   *   price: 0.65,
-   *   size: 100,
-   *   side: Side.BUY,
-   *   orderType: OrderType.GTC,
-   *   marketSlug: 'market-slug'
-   * });
-   *
-   * console.log(`Order created: ${order.order.id}`);
-   * ```
-   */
-  async createOrder(params) {
-    this.logger.info("Creating order", {
-      side: params.side,
-      orderType: params.orderType,
-      marketSlug: params.marketSlug
-    });
-    const unsignedOrder = this.orderBuilder.buildOrder(params);
-    this.logger.debug("Built unsigned order", {
-      salt: unsignedOrder.salt,
-      makerAmount: unsignedOrder.makerAmount,
-      takerAmount: unsignedOrder.takerAmount
-    });
-    const signature = await this.orderSigner.signOrder(
-      unsignedOrder,
-      this.signingConfig
-    );
-    const payload = {
-      order: {
-        ...unsignedOrder,
-        signature
-      },
-      orderType: params.orderType,
-      marketSlug: params.marketSlug,
-      ownerId: this.ownerId
-    };
-    this.logger.debug("Submitting order to API");
-    console.log("[OrderClient] Full API request payload:", JSON.stringify(payload, null, 2));
-    const apiResponse = await this.httpClient.post(
-      "/orders",
-      payload
-    );
-    this.logger.info("Order created successfully", {
-      orderId: apiResponse.order.id
-    });
-    return this.transformOrderResponse(apiResponse);
-  }
-  /**
-   * Transforms raw API response to clean OrderResponse DTO.
-   *
-   * @param apiResponse - Raw API response with nested objects
-   * @returns Clean OrderResponse with only essential fields
-   *
-   * @internal
-   */
-  transformOrderResponse(apiResponse) {
-    const cleanOrder = {
-      order: {
-        id: apiResponse.order.id,
-        createdAt: apiResponse.order.createdAt,
-        makerAmount: apiResponse.order.makerAmount,
-        takerAmount: apiResponse.order.takerAmount,
-        expiration: apiResponse.order.expiration,
-        signatureType: apiResponse.order.signatureType,
-        salt: apiResponse.order.salt,
-        maker: apiResponse.order.maker,
-        signer: apiResponse.order.signer,
-        taker: apiResponse.order.taker,
-        tokenId: apiResponse.order.tokenId,
-        side: apiResponse.order.side,
-        feeRateBps: apiResponse.order.feeRateBps,
-        nonce: apiResponse.order.nonce,
-        signature: apiResponse.order.signature,
-        orderType: apiResponse.order.orderType,
-        price: apiResponse.order.price,
-        marketId: apiResponse.order.marketId
-      }
-    };
-    if (apiResponse.makerMatches && apiResponse.makerMatches.length > 0) {
-      cleanOrder.makerMatches = apiResponse.makerMatches.map((match) => ({
-        id: match.id,
-        createdAt: match.createdAt,
-        matchedSize: match.matchedSize,
-        orderId: match.orderId
-      }));
-    }
-    return cleanOrder;
-  }
-  /**
-   * Cancels an existing order by ID.
-   *
-   * @param orderId - Order ID to cancel
-   * @returns Promise resolving to cancellation message
-   *
-   * @throws Error if cancellation fails
-   *
-   * @example
-   * ```typescript
-   * const result = await orderClient.cancel('order-id-123');
-   * console.log(result.message); // "Order canceled successfully"
-   * ```
-   */
-  async cancel(orderId) {
-    this.logger.info("Cancelling order", { orderId });
-    const response = await this.httpClient.delete(
-      `/orders/${orderId}`
-    );
-    this.logger.info("Order cancellation response", {
-      orderId,
-      message: response.message
-    });
-    return response;
-  }
-  /**
-   * Cancels all orders for a specific market.
-   *
-   * @param marketSlug - Market slug to cancel all orders for
-   * @returns Promise resolving to cancellation message
-   *
-   * @throws Error if cancellation fails
-   *
-   * @example
-   * ```typescript
-   * const result = await orderClient.cancelAll('market-slug-123');
-   * console.log(result.message); // "Orders canceled successfully"
-   * ```
-   */
-  async cancelAll(marketSlug) {
-    this.logger.info("Cancelling all orders for market", { marketSlug });
-    const response = await this.httpClient.delete(
-      `/orders/all/${marketSlug}`
-    );
-    this.logger.info("All orders cancellation response", {
-      marketSlug,
-      message: response.message
-    });
-    return response;
-  }
-  /**
-   * @deprecated Use `cancel()` instead
-   */
-  async cancelOrder(orderId) {
-    await this.cancel(orderId);
-  }
-  /**
-   * Gets an order by ID.
-   *
-   * @param orderId - Order ID to fetch
-   * @returns Promise resolving to order details
-   *
-   * @throws Error if order not found
-   *
-   * @example
-   * ```typescript
-   * const order = await orderClient.getOrder('order-id-123');
-   * console.log(order.order.side);
-   * ```
-   */
-  async getOrder(orderId) {
-    this.logger.debug("Fetching order", { orderId });
-    const response = await this.httpClient.get(
-      `/orders/${orderId}`
-    );
-    return response;
-  }
-  /**
-   * Builds an unsigned order without submitting.
-   *
-   * @remarks
-   * Useful for advanced use cases where you need the unsigned order
-   * before signing and submission.
-   *
-   * @param params - Order parameters
-   * @returns Unsigned order
-   *
-   * @example
-   * ```typescript
-   * const unsignedOrder = orderClient.buildUnsignedOrder({
-   *   tokenId: '123456',
-   *   price: 0.65,
-   *   size: 100,
-   *   side: Side.BUY
-   * });
-   * ```
-   */
-  buildUnsignedOrder(params) {
-    return this.orderBuilder.buildOrder(params);
-  }
-  /**
-   * Signs an unsigned order without submitting.
-   *
-   * @remarks
-   * Useful for advanced use cases where you need to inspect
-   * the signature before submission.
-   *
-   * @param order - Unsigned order to sign
-   * @returns Promise resolving to signature
-   *
-   * @example
-   * ```typescript
-   * const signature = await orderClient.signOrder(unsignedOrder);
-   * ```
-   */
-  async signOrder(order) {
-    return await this.orderSigner.signOrder(order, this.signingConfig);
-  }
-};
-
-// 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.
+   * Gets active markets with query parameters and pagination support.
    *
    * @param params - Query parameters for filtering and pagination
    * @returns Promise resolving to active markets response
@@ -1737,13 +1208,18 @@ var MarketFetcher = class {
     this.logger.debug("Fetching active markets", { params });
     try {
       const response = await this.httpClient.get(endpoint);
+      const markets = response.data.map((marketData) => new Market(marketData, this.httpClient));
+      const result = {
+        data: markets,
+        totalMarketsCount: response.totalMarketsCount
+      };
       this.logger.info("Active markets fetched successfully", {
-        count: response.data.length,
+        count: markets.length,
         total: response.totalMarketsCount,
         sortBy: params?.sortBy,
         page: params?.page
       });
-      return response;
+      return result;
     } catch (error) {
       this.logger.error("Failed to fetch active markets", error, { params });
       throw error;
@@ -1752,20 +1228,48 @@ var MarketFetcher = class {
   /**
    * 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
+   * // Get market
    * const market = await fetcher.getMarket('bitcoin-price-2024');
    * console.log(`Market: ${market.title}`);
+   *
+   * // Fluent API - get user orders for this market (clean!)
+   * const orders = await market.getUserOrders();
+   * console.log(`You have ${orders.length} orders`);
+   *
+   * // 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}`);
+      const response = await this.httpClient.get(`/markets/${slug}`);
+      const market = new Market(response, this.httpClient);
+      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
@@ -1776,6 +1280,36 @@ var MarketFetcher = class {
       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.
    *
@@ -1807,335 +1341,473 @@ var MarketFetcher = class {
       throw error;
     }
   }
+};
+
+// src/portfolio/fetcher.ts
+var PortfolioFetcher = class {
+  /**
+   * Creates a new portfolio fetcher instance.
+   *
+   * @param httpClient - Authenticated HTTP client for API requests
+   * @param logger - Optional logger for debugging (default: no logging)
+   *
+   * @example
+   * ```typescript
+   * // Create authenticated client
+   * const httpClient = new HttpClient({ baseURL: API_URL });
+   * await authenticator.authenticate({ client: 'eoa' });
+   *
+   * // Create portfolio fetcher
+   * const portfolioFetcher = new PortfolioFetcher(httpClient);
+   * ```
+   */
+  constructor(httpClient, logger) {
+    this.httpClient = httpClient;
+    this.logger = logger || new NoOpLogger();
+  }
+  /**
+   * Gets user profile for a specific wallet address.
+   *
+   * @remarks
+   * Returns user profile data including user ID and fee rate.
+   * Used internally by OrderClient to fetch user data.
+   *
+   * @param address - Wallet address to fetch profile for
+   * @returns Promise resolving to user profile data
+   * @throws Error if API request fails or user is not authenticated
+   *
+   * @example
+   * ```typescript
+   * const profile = await portfolioFetcher.getProfile('0x1234...');
+   * console.log(`User ID: ${profile.id}`);
+   * console.log(`Account: ${profile.account}`);
+   * console.log(`Fee Rate: ${profile.rank?.feeRateBps}`);
+   * ```
+   */
+  async getProfile(address) {
+    this.logger.debug("Fetching user profile", { address });
+    try {
+      const response = await this.httpClient.get(`/profiles/${address}`);
+      this.logger.info("User profile fetched successfully", { address });
+      return response;
+    } catch (error) {
+      this.logger.error("Failed to fetch user profile", error, { address });
+      throw error;
+    }
+  }
+  /**
+   * Gets raw portfolio positions response from API.
+   *
+   * @returns Promise resolving to portfolio positions response with CLOB and AMM positions
+   * @throws Error if API request fails or user is not authenticated
+   *
+   * @example
+   * ```typescript
+   * const response = await portfolioFetcher.getPositions();
+   * console.log(`CLOB positions: ${response.clob.length}`);
+   * console.log(`AMM positions: ${response.amm.length}`);
+   * console.log(`Total points: ${response.accumulativePoints}`);
+   * ```
+   */
+  async getPositions() {
+    this.logger.debug("Fetching user positions");
+    try {
+      const response = await this.httpClient.get("/portfolio/positions");
+      this.logger.info("Positions fetched successfully", {
+        clobCount: response.clob?.length || 0,
+        ammCount: response.amm?.length || 0
+      });
+      return response;
+    } catch (error) {
+      this.logger.error("Failed to fetch positions", error);
+      throw error;
+    }
+  }
+  /**
+   * Gets CLOB positions only.
+   *
+   * @returns Promise resolving to array of CLOB positions
+   * @throws Error if API request fails
+   *
+   * @example
+   * ```typescript
+   * const clobPositions = await portfolioFetcher.getCLOBPositions();
+   * clobPositions.forEach(pos => {
+   *   console.log(`${pos.market.title}: YES ${pos.positions.yes.unrealizedPnl} P&L`);
+   * });
+   * ```
+   */
+  async getCLOBPositions() {
+    const response = await this.getPositions();
+    return response.clob || [];
+  }
+  /**
+   * Gets AMM positions only.
+   *
+   * @returns Promise resolving to array of AMM positions
+   * @throws Error if API request fails
+   *
+   * @example
+   * ```typescript
+   * const ammPositions = await portfolioFetcher.getAMMPositions();
+   * ammPositions.forEach(pos => {
+   *   console.log(`${pos.market.title}: ${pos.unrealizedPnl} P&L`);
+   * });
+   * ```
+   */
+  async getAMMPositions() {
+    const response = await this.getPositions();
+    return response.amm || [];
+  }
+  /**
+   * Gets paginated history of user actions.
+   *
+   *  Includes AMM trades, CLOB trades, Negrisk trades & conversions.
+   *
+   * @param page - Page number (starts at 1)
+   * @param limit - Number of items per page
+   * @returns Promise resolving to paginated history response
+   * @throws Error if API request fails or user is not authenticated
+   *
+   * @example
+   * ```typescript
+   * // Get first page
+   * const response = await portfolioFetcher.getUserHistory(1, 20);
+   * console.log(`Found ${response.data.length} of ${response.totalCount} entries`);
+   *
+   * // Process history entries
+   * for (const entry of response.data) {
+   *   console.log(`Type: ${entry.type}`);
+   *   console.log(`Market: ${entry.marketSlug}`);
+   * }
+   *
+   * // Get next page
+   * const page2 = await portfolioFetcher.getUserHistory(2, 20);
+   * ```
+   */
+  async getUserHistory(page = 1, limit = 10) {
+    this.logger.debug("Fetching user history", { page, limit });
+    try {
+      const params = new URLSearchParams({
+        page: page.toString(),
+        limit: limit.toString()
+      });
+      const response = await this.httpClient.get(
+        `/portfolio/history?${params.toString()}`
+      );
+      this.logger.info("User history fetched successfully");
+      return response;
+    } catch (error) {
+      this.logger.error("Failed to fetch user history", error, { page, limit });
+      throw error;
+    }
+  }
+};
+
+// src/orders/client.ts
+var OrderClient = class {
   /**
-   * Gets the current price for a token.
+   * Creates a new order client instance.
+   *
+   * @param config - Order client configuration
+   */
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.wallet = config.wallet;
+    this.logger = config.logger || new NoOpLogger();
+    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 {
+      const chainId = parseInt(process.env.CHAIN_ID || "8453");
+      const contractAddress = ZERO_ADDRESS;
+      this.signingConfig = {
+        chainId,
+        contractAddress
+      };
+      this.logger.info("Auto-configured signing (contract address from venue)", {
+        chainId
+      });
+    }
+  }
+  /**
+   * Ensures user data is loaded and cached.
+   * Fetches from profile API on first call, then caches for subsequent calls.
+   *
+   * @returns Promise resolving to cached user data
+   * @internal
+   */
+  async ensureUserData() {
+    if (!this.cachedUserData) {
+      this.logger.info("Fetching user profile for order client initialization...", {
+        walletAddress: this.wallet.address
+      });
+      const portfolioFetcher = new PortfolioFetcher(this.httpClient);
+      const profile = await portfolioFetcher.getProfile(this.wallet.address);
+      this.cachedUserData = {
+        userId: profile.id,
+        feeRateBps: profile.rank?.feeRateBps || 300
+      };
+      this.orderBuilder = new OrderBuilder(
+        this.wallet.address,
+        this.cachedUserData.feeRateBps,
+        1e-3
+      );
+      this.logger.info("Order Client initialized", {
+        walletAddress: profile.account,
+        userId: this.cachedUserData.userId,
+        feeRate: `${this.cachedUserData.feeRateBps / 100}%`
+      });
+    }
+    return this.cachedUserData;
+  }
+  /**
+   * Creates and submits a new order.
+   *
+   * @remarks
+   * This method handles the complete order creation flow:
+   * 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
    *
-   * @param tokenId - Token ID
-   * @returns Promise resolving to price information
-   * @throws Error if API request fails
+   * 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 or venue not found
    *
    * @example
    * ```typescript
-   * const price = await fetcher.getPrice('123456');
-   * console.log(`Current price: ${price.price}`);
+   * // Best practice: fetch market first to cache venue
+   * const market = await marketFetcher.getMarket('bitcoin-2024');
+   *
+   * const order = await orderClient.createOrder({
+   *   tokenId: market.tokens.yes,
+   *   price: 0.65,
+   *   size: 100,
+   *   side: Side.BUY,
+   *   orderType: OrderType.GTC,
+   *   marketSlug: 'bitcoin-2024'
+   * });
+   *
+   * console.log(`Order created: ${order.order.id}`);
    * ```
    */
-  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;
+  async createOrder(params) {
+    const userData = await this.ensureUserData();
+    this.logger.info("Creating order", {
+      side: params.side,
+      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,
+      makerAmount: unsignedOrder.makerAmount,
+      takerAmount: unsignedOrder.takerAmount
+    });
+    const signature = await this.orderSigner.signOrder(unsignedOrder, dynamicSigningConfig);
+    const payload = {
+      order: {
+        ...unsignedOrder,
+        signature
+      },
+      orderType: params.orderType,
+      marketSlug: params.marketSlug,
+      ownerId: userData.userId
+    };
+    this.logger.debug("Submitting order to API", payload);
+    const apiResponse = await this.httpClient.post("/orders", payload);
+    this.logger.info("Order created successfully", {
+      orderId: apiResponse.order.id
+    });
+    return this.transformOrderResponse(apiResponse);
   }
-};
-
-// src/portfolio/fetcher.ts
-var PortfolioFetcher = class {
   /**
-   * Creates a new portfolio fetcher instance.
-   *
-   * @param httpClient - Authenticated HTTP client for API requests
-   * @param logger - Optional logger for debugging (default: no logging)
+   * Transforms raw API response to clean OrderResponse DTO.
    *
-   * @example
-   * ```typescript
-   * // Create authenticated client
-   * const httpClient = new HttpClient({ baseURL: API_URL });
-   * await authenticator.authenticate({ client: 'eoa' });
+   * @param apiResponse - Raw API response with nested objects
+   * @returns Clean OrderResponse with only essential fields
    *
-   * // Create portfolio fetcher
-   * const portfolioFetcher = new PortfolioFetcher(httpClient);
-   * ```
+   * @internal
    */
-  constructor(httpClient, logger) {
-    this.httpClient = httpClient;
-    this.logger = logger || new NoOpLogger();
+  transformOrderResponse(apiResponse) {
+    const cleanOrder = {
+      order: {
+        id: apiResponse.order.id,
+        createdAt: apiResponse.order.createdAt,
+        makerAmount: apiResponse.order.makerAmount,
+        takerAmount: apiResponse.order.takerAmount,
+        expiration: apiResponse.order.expiration,
+        signatureType: apiResponse.order.signatureType,
+        salt: apiResponse.order.salt,
+        maker: apiResponse.order.maker,
+        signer: apiResponse.order.signer,
+        taker: apiResponse.order.taker,
+        tokenId: apiResponse.order.tokenId,
+        side: apiResponse.order.side,
+        feeRateBps: apiResponse.order.feeRateBps,
+        nonce: apiResponse.order.nonce,
+        signature: apiResponse.order.signature,
+        orderType: apiResponse.order.orderType,
+        price: apiResponse.order.price,
+        marketId: apiResponse.order.marketId
+      }
+    };
+    if (apiResponse.makerMatches && apiResponse.makerMatches.length > 0) {
+      cleanOrder.makerMatches = apiResponse.makerMatches.map((match) => ({
+        id: match.id,
+        createdAt: match.createdAt,
+        matchedSize: match.matchedSize,
+        orderId: match.orderId
+      }));
+    }
+    return cleanOrder;
   }
   /**
-   * Gets raw portfolio positions response from API.
+   * Cancels an existing order by ID.
    *
-   * @returns Promise resolving to portfolio positions response with CLOB and AMM positions
-   * @throws Error if API request fails or user is not authenticated
+   * @param orderId - Order ID to cancel
+   * @returns Promise resolving to cancellation message
+   *
+   * @throws Error if cancellation fails
    *
    * @example
    * ```typescript
-   * const response = await portfolioFetcher.getPositions();
-   * console.log(`CLOB positions: ${response.clob.length}`);
-   * console.log(`AMM positions: ${response.amm.length}`);
-   * console.log(`Total points: ${response.accumulativePoints}`);
+   * const result = await orderClient.cancel('order-id-123');
+   * console.log(result.message); // "Order canceled successfully"
    * ```
    */
-  async getPositions() {
-    this.logger.debug("Fetching user positions");
-    try {
-      const response = await this.httpClient.get(
-        "/portfolio/positions"
-      );
-      this.logger.info("Positions fetched successfully", {
-        clobCount: response.clob?.length || 0,
-        ammCount: response.amm?.length || 0
-      });
-      return response;
-    } catch (error) {
-      this.logger.error("Failed to fetch positions", error);
-      throw error;
-    }
+  async cancel(orderId) {
+    this.logger.info("Cancelling order", { orderId });
+    const response = await this.httpClient.delete(`/orders/${orderId}`);
+    this.logger.info("Order cancellation response", {
+      orderId,
+      message: response.message
+    });
+    return response;
   }
   /**
-   * Gets CLOB positions only.
+   * Cancels all orders for a specific market.
    *
-   * @returns Promise resolving to array of CLOB positions
-   * @throws Error if API request fails
+   * @param marketSlug - Market slug to cancel all orders for
+   * @returns Promise resolving to cancellation message
+   *
+   * @throws Error if cancellation fails
    *
    * @example
    * ```typescript
-   * const clobPositions = await portfolioFetcher.getCLOBPositions();
-   * clobPositions.forEach(pos => {
-   *   console.log(`${pos.market.title}: YES ${pos.positions.yes.unrealizedPnl} P&L`);
-   * });
+   * const result = await orderClient.cancelAll('market-slug-123');
+   * console.log(result.message); // "Orders canceled successfully"
    * ```
    */
-  async getCLOBPositions() {
-    const response = await this.getPositions();
-    return response.clob || [];
+  async cancelAll(marketSlug) {
+    this.logger.info("Cancelling all orders for market", { marketSlug });
+    const response = await this.httpClient.delete(`/orders/all/${marketSlug}`);
+    this.logger.info("All orders cancellation response", {
+      marketSlug,
+      message: response.message
+    });
+    return response;
   }
   /**
-   * Gets AMM positions only.
+   * Builds an unsigned order without submitting.
    *
-   * @returns Promise resolving to array of AMM positions
-   * @throws Error if API request fails
+   * @remarks
+   * Useful for advanced use cases where you need the unsigned order
+   * before signing and submission.
+   *
+   * @param params - Order parameters
+   * @returns Promise resolving to unsigned order
    *
    * @example
    * ```typescript
-   * const ammPositions = await portfolioFetcher.getAMMPositions();
-   * ammPositions.forEach(pos => {
-   *   console.log(`${pos.market.title}: ${pos.unrealizedPnl} P&L`);
+   * const unsignedOrder = await orderClient.buildUnsignedOrder({
+   *   tokenId: '123456',
+   *   price: 0.65,
+   *   size: 100,
+   *   side: Side.BUY
    * });
    * ```
    */
-  async getAMMPositions() {
-    const response = await this.getPositions();
-    return response.amm || [];
+  async buildUnsignedOrder(params) {
+    await this.ensureUserData();
+    return this.orderBuilder.buildOrder(params);
   }
   /**
-   * Flattens positions into a unified format for easier consumption.
+   * Signs an unsigned order without submitting.
    *
    * @remarks
-   * Converts CLOB positions (which have YES/NO sides) and AMM positions
-   * into a unified Position array. Only includes positions with non-zero values.
+   * Useful for advanced use cases where you need to inspect
+   * the signature before submission.
    *
-   * @returns Promise resolving to array of flattened positions
-   * @throws Error if API request fails
+   * @param order - Unsigned order to sign
+   * @returns Promise resolving to signature
    *
    * @example
    * ```typescript
-   * const positions = await portfolioFetcher.getFlattenedPositions();
-   * positions.forEach(pos => {
-   *   const pnlPercent = (pos.unrealizedPnl / pos.costBasis) * 100;
-   *   console.log(`${pos.market.title} (${pos.side}): ${pnlPercent.toFixed(2)}% P&L`);
-   * });
+   * const signature = await orderClient.signOrder(unsignedOrder);
    * ```
    */
-  async getFlattenedPositions() {
-    const response = await this.getPositions();
-    const positions = [];
-    for (const clobPos of response.clob || []) {
-      const yesCost = parseFloat(clobPos.positions.yes.cost);
-      const yesValue = parseFloat(clobPos.positions.yes.marketValue);
-      if (yesCost > 0 || yesValue > 0) {
-        positions.push({
-          type: "CLOB",
-          market: clobPos.market,
-          side: "YES",
-          costBasis: yesCost,
-          marketValue: yesValue,
-          unrealizedPnl: parseFloat(clobPos.positions.yes.unrealizedPnl),
-          realizedPnl: parseFloat(clobPos.positions.yes.realisedPnl),
-          currentPrice: clobPos.latestTrade?.latestYesPrice ?? 0,
-          avgPrice: yesCost > 0 ? parseFloat(clobPos.positions.yes.fillPrice) / 1e6 : 0,
-          tokenBalance: parseFloat(clobPos.tokensBalance.yes)
-        });
-      }
-      const noCost = parseFloat(clobPos.positions.no.cost);
-      const noValue = parseFloat(clobPos.positions.no.marketValue);
-      if (noCost > 0 || noValue > 0) {
-        positions.push({
-          type: "CLOB",
-          market: clobPos.market,
-          side: "NO",
-          costBasis: noCost,
-          marketValue: noValue,
-          unrealizedPnl: parseFloat(clobPos.positions.no.unrealizedPnl),
-          realizedPnl: parseFloat(clobPos.positions.no.realisedPnl),
-          currentPrice: clobPos.latestTrade?.latestNoPrice ?? 0,
-          avgPrice: noCost > 0 ? parseFloat(clobPos.positions.no.fillPrice) / 1e6 : 0,
-          tokenBalance: parseFloat(clobPos.tokensBalance.no)
-        });
-      }
-    }
-    for (const ammPos of response.amm || []) {
-      const cost = parseFloat(ammPos.totalBuysCost);
-      const value = parseFloat(ammPos.collateralAmount);
-      if (cost > 0 || value > 0) {
-        positions.push({
-          type: "AMM",
-          market: ammPos.market,
-          side: ammPos.outcomeIndex === 0 ? "YES" : "NO",
-          costBasis: cost,
-          marketValue: value,
-          unrealizedPnl: parseFloat(ammPos.unrealizedPnl),
-          realizedPnl: parseFloat(ammPos.realizedPnl),
-          currentPrice: ammPos.latestTrade ? parseFloat(ammPos.latestTrade.outcomeTokenPrice) : 0,
-          avgPrice: parseFloat(ammPos.averageFillPrice),
-          tokenBalance: parseFloat(ammPos.outcomeTokenAmount)
-        });
-      }
-    }
-    this.logger.debug("Flattened positions", { count: positions.length });
-    return positions;
+  async signOrder(order) {
+    return await this.orderSigner.signOrder(order, this.signingConfig);
   }
   /**
-   * Calculates portfolio summary statistics from raw API response.
+   * Gets the wallet address.
    *
-   * @param response - Portfolio positions response from API
-   * @returns Portfolio summary with totals and statistics
+   * @returns Ethereum address of the wallet
    *
    * @example
    * ```typescript
-   * const response = await portfolioFetcher.getPositions();
-   * const summary = portfolioFetcher.calculateSummary(response);
-   *
-   * console.log(`Total Portfolio Value: $${(summary.totalValue / 1e6).toFixed(2)}`);
-   * console.log(`Total P&L: ${summary.totalUnrealizedPnlPercent.toFixed(2)}%`);
-   * console.log(`CLOB Positions: ${summary.breakdown.clob.positions}`);
-   * console.log(`AMM Positions: ${summary.breakdown.amm.positions}`);
+   * const address = orderClient.walletAddress;
+   * console.log(`Wallet: ${address}`);
    * ```
    */
-  calculateSummary(response) {
-    this.logger.debug("Calculating portfolio summary", {
-      clobCount: response.clob?.length || 0,
-      ammCount: response.amm?.length || 0
-    });
-    let totalValue = 0;
-    let totalCostBasis = 0;
-    let totalUnrealizedPnl = 0;
-    let totalRealizedPnl = 0;
-    let clobPositions = 0;
-    let clobValue = 0;
-    let clobPnl = 0;
-    let ammPositions = 0;
-    let ammValue = 0;
-    let ammPnl = 0;
-    for (const clobPos of response.clob || []) {
-      const yesCost = parseFloat(clobPos.positions.yes.cost);
-      const yesValue = parseFloat(clobPos.positions.yes.marketValue);
-      const yesUnrealizedPnl = parseFloat(clobPos.positions.yes.unrealizedPnl);
-      const yesRealizedPnl = parseFloat(clobPos.positions.yes.realisedPnl);
-      if (yesCost > 0 || yesValue > 0) {
-        clobPositions++;
-        totalCostBasis += yesCost;
-        totalValue += yesValue;
-        totalUnrealizedPnl += yesUnrealizedPnl;
-        totalRealizedPnl += yesRealizedPnl;
-        clobValue += yesValue;
-        clobPnl += yesUnrealizedPnl;
-      }
-      const noCost = parseFloat(clobPos.positions.no.cost);
-      const noValue = parseFloat(clobPos.positions.no.marketValue);
-      const noUnrealizedPnl = parseFloat(clobPos.positions.no.unrealizedPnl);
-      const noRealizedPnl = parseFloat(clobPos.positions.no.realisedPnl);
-      if (noCost > 0 || noValue > 0) {
-        clobPositions++;
-        totalCostBasis += noCost;
-        totalValue += noValue;
-        totalUnrealizedPnl += noUnrealizedPnl;
-        totalRealizedPnl += noRealizedPnl;
-        clobValue += noValue;
-        clobPnl += noUnrealizedPnl;
-      }
-    }
-    for (const ammPos of response.amm || []) {
-      const cost = parseFloat(ammPos.totalBuysCost);
-      const value = parseFloat(ammPos.collateralAmount);
-      const unrealizedPnl = parseFloat(ammPos.unrealizedPnl);
-      const realizedPnl = parseFloat(ammPos.realizedPnl);
-      if (cost > 0 || value > 0) {
-        ammPositions++;
-        totalCostBasis += cost;
-        totalValue += value;
-        totalUnrealizedPnl += unrealizedPnl;
-        totalRealizedPnl += realizedPnl;
-        ammValue += value;
-        ammPnl += unrealizedPnl;
-      }
-    }
-    const totalUnrealizedPnlPercent = totalCostBasis > 0 ? totalUnrealizedPnl / totalCostBasis * 100 : 0;
-    const uniqueMarkets = /* @__PURE__ */ new Set();
-    for (const pos of response.clob || []) {
-      uniqueMarkets.add(pos.market.id);
-    }
-    for (const pos of response.amm || []) {
-      uniqueMarkets.add(pos.market.id);
-    }
-    const summary = {
-      totalValue,
-      totalCostBasis,
-      totalUnrealizedPnl,
-      totalRealizedPnl,
-      totalUnrealizedPnlPercent,
-      positionCount: clobPositions + ammPositions,
-      marketCount: uniqueMarkets.size,
-      breakdown: {
-        clob: {
-          positions: clobPositions,
-          value: clobValue,
-          pnl: clobPnl
-        },
-        amm: {
-          positions: ammPositions,
-          value: ammValue,
-          pnl: ammPnl
-        }
-      }
-    };
-    this.logger.debug("Portfolio summary calculated", summary);
-    return summary;
+  get walletAddress() {
+    return this.wallet.address;
   }
   /**
-   * Gets positions and calculates summary in a single call.
+   * Gets the owner ID (user ID from profile).
    *
-   * @returns Promise resolving to response and summary
-   * @throws Error if API request fails or user is not authenticated
+   * @returns Owner ID from user profile, or undefined if not yet loaded
    *
    * @example
    * ```typescript
-   * const { response, summary } = await portfolioFetcher.getPortfolio();
-   *
-   * console.log('Portfolio Summary:');
-   * console.log(`  Total Value: $${(summary.totalValue / 1e6).toFixed(2)}`);
-   * console.log(`  Total P&L: $${(summary.totalUnrealizedPnl / 1e6).toFixed(2)}`);
-   * console.log(`  P&L %: ${summary.totalUnrealizedPnlPercent.toFixed(2)}%`);
-   * console.log(`\nCLOB Positions: ${response.clob.length}`);
-   * console.log(`AMM Positions: ${response.amm.length}`);
+   * const ownerId = orderClient.ownerId;
+   * if (ownerId) {
+   *   console.log(`Owner ID: ${ownerId}`);
+   * }
    * ```
    */
-  async getPortfolio() {
-    this.logger.debug("Fetching portfolio with summary");
-    const response = await this.getPositions();
-    const summary = this.calculateSummary(response);
-    this.logger.info("Portfolio fetched with summary", {
-      positionCount: summary.positionCount,
-      totalValueUSDC: summary.totalValue / 1e6,
-      pnlPercent: summary.totalUnrealizedPnlPercent
-    });
-    return { response, summary };
+  get ownerId() {
+    return this.cachedUserData?.userId;
   }
 };
 
@@ -2156,7 +1828,7 @@ var WebSocketClient = class {
     this.pendingListeners = [];
     this.config = {
       url: config.url || DEFAULT_WS_URL,
-      sessionCookie: config.sessionCookie || "",
+      apiKey: config.apiKey || process.env.LIMITLESS_API_KEY || "",
       autoReconnect: config.autoReconnect ?? true,
       reconnectDelay: config.reconnectDelay || 1e3,
       maxReconnectAttempts: config.maxReconnectAttempts || Infinity,
@@ -2181,18 +1853,29 @@ var WebSocketClient = class {
     return this.state === "connected" /* CONNECTED */ && this.socket?.connected === true;
   }
   /**
-   * Sets the session cookie for authentication.
+   * Sets the API key for authentication.
    *
-   * @param sessionCookie - Session cookie value
+   * @param apiKey - API key value
+   *
+   * @remarks
+   * API key is required for authenticated subscriptions (positions, transactions).
+   * If already connected, this will trigger a reconnection with the new API key.
    */
-  setSessionCookie(sessionCookie) {
-    this.config.sessionCookie = sessionCookie;
+  setApiKey(apiKey) {
+    this.config.apiKey = apiKey;
     if (this.socket?.connected) {
-      this.logger.info("Session cookie updated, reconnecting...");
-      this.disconnect();
-      this.connect();
+      this.logger.info("API key updated, reconnecting...");
+      this.reconnectWithNewAuth();
     }
   }
+  /**
+   * Reconnects with new authentication credentials.
+   * @internal
+   */
+  async reconnectWithNewAuth() {
+    await this.disconnect();
+    await this.connect();
+  }
   /**
    * Connects to the WebSocket server.
    *
@@ -2206,8 +1889,8 @@ var WebSocketClient = class {
    * ```
    */
   async connect() {
-    if (this.socket?.connected) {
-      this.logger.info("Already connected");
+    if (this.socket?.connected || this.state === "connecting" /* CONNECTING */) {
+      this.logger.info("Already connected or connecting");
       return;
     }
     this.logger.info("Connecting to WebSocket", { url: this.config.url });
@@ -2216,18 +1899,26 @@ var WebSocketClient = class {
       const timeout = setTimeout(() => {
         reject(new Error(`Connection timeout after ${this.config.timeout}ms`));
       }, this.config.timeout);
-      const wsUrl = this.config.url.endsWith("/markets") ? this.config.url : `${this.config.url}/markets`;
-      this.socket = io(wsUrl, {
+      const wsUrl = this.config.url;
+      const socketOptions = {
         transports: ["websocket"],
         // Use WebSocket transport only
-        extraHeaders: {
-          cookie: `limitless_session=${this.config.sessionCookie}`
-        },
         reconnection: this.config.autoReconnect,
         reconnectionDelay: this.config.reconnectDelay,
-        reconnectionAttempts: this.config.maxReconnectAttempts,
+        reconnectionDelayMax: Math.min(this.config.reconnectDelay * 32, 6e4),
+        // Max 60s
+        reconnectionAttempts: this.config.maxReconnectAttempts === Infinity ? 0 : this.config.maxReconnectAttempts,
+        // 0 = infinite
+        randomizationFactor: 0.2,
+        // Add jitter to prevent thundering herd
         timeout: this.config.timeout
-      });
+      };
+      if (this.config.apiKey) {
+        socketOptions.extraHeaders = {
+          "X-API-Key": this.config.apiKey
+        };
+      }
+      this.socket = io(wsUrl + "/markets", socketOptions);
       this.attachPendingListeners();
       this.setupEventHandlers();
       this.socket.once("connect", () => {
@@ -2249,12 +1940,14 @@ var WebSocketClient = class {
   /**
    * Disconnects from the WebSocket server.
    *
+   * @returns Promise that resolves when disconnected
+   *
    * @example
    * ```typescript
-   * wsClient.disconnect();
+   * await wsClient.disconnect();
    * ```
    */
-  disconnect() {
+  async disconnect() {
     if (!this.socket) {
       return;
     }
@@ -2269,13 +1962,13 @@ var WebSocketClient = class {
    *
    * @param channel - Channel to subscribe to
    * @param options - Subscription options
-   * @returns Promise that resolves when subscribed
+   * @returns Promise that resolves immediately (kept async for API compatibility)
    * @throws Error if not connected
    *
    * @example
    * ```typescript
    * // Subscribe to orderbook for a specific market
-   * await wsClient.subscribe('orderbook', { marketSlug: 'market-123' });
+   * await wsClient.subscribe('orderbook', { marketSlugs: ['market-123'] });
    *
    * // Subscribe to all trades
    * await wsClient.subscribe('trades');
@@ -2288,21 +1981,20 @@ var WebSocketClient = class {
     if (!this.isConnected()) {
       throw new Error("WebSocket not connected. Call connect() first.");
     }
+    const authenticatedChannels = [
+      "subscribe_positions",
+      "subscribe_transactions"
+    ];
+    if (authenticatedChannels.includes(channel) && !this.config.apiKey) {
+      throw new Error(
+        `API key is required for '${channel}' subscription. Please provide an API key in the constructor or set LIMITLESS_API_KEY environment variable. You can generate an API key at https://limitless.exchange`
+      );
+    }
     const subscriptionKey = this.getSubscriptionKey(channel, options);
     this.subscriptions.set(subscriptionKey, options);
     this.logger.info("Subscribing to channel", { channel, options });
-    return new Promise((resolve, reject) => {
-      this.socket.emit(channel, options, (response) => {
-        if (response?.error) {
-          this.logger.error("Subscription failed", response.error);
-          this.subscriptions.delete(subscriptionKey);
-          reject(new Error(response.error));
-        } else {
-          this.logger.info("Subscribed successfully", { channel, options });
-          resolve();
-        }
-      });
-    });
+    this.socket.emit(channel, options);
+    this.logger.info("Subscription request sent", { channel, options });
   }
   /**
    * Unsubscribes from a channel.
@@ -2310,10 +2002,11 @@ var WebSocketClient = class {
    * @param channel - Channel to unsubscribe from
    * @param options - Subscription options (must match subscribe call)
    * @returns Promise that resolves when unsubscribed
+   * @throws Error if not connected or unsubscribe fails
    *
    * @example
    * ```typescript
-   * await wsClient.unsubscribe('orderbook', { marketSlug: 'market-123' });
+   * await wsClient.unsubscribe('orderbook', { marketSlugs: ['market-123'] });
    * ```
    */
   async unsubscribe(channel, options = {}) {
@@ -2323,17 +2016,19 @@ var WebSocketClient = class {
     const subscriptionKey = this.getSubscriptionKey(channel, options);
     this.subscriptions.delete(subscriptionKey);
     this.logger.info("Unsubscribing from channel", { channel, options });
-    return new Promise((resolve, reject) => {
-      this.socket.emit("unsubscribe", { channel, ...options }, (response) => {
-        if (response?.error) {
-          this.logger.error("Unsubscribe failed", response.error);
-          reject(new Error(response.error));
-        } else {
-          this.logger.info("Unsubscribed successfully", { channel, options });
-          resolve();
-        }
-      });
-    });
+    try {
+      const unsubscribeData = { channel, ...options };
+      const response = await this.socket.timeout(5e3).emitWithAck("unsubscribe", unsubscribeData);
+      if (response && typeof response === "object" && "error" in response) {
+        const errorMsg = response.error;
+        this.logger.error("Unsubscribe failed", new Error(errorMsg), { error: errorMsg });
+        throw new Error(`Unsubscribe failed: ${errorMsg}`);
+      }
+      this.logger.info("Unsubscribed successfully", { channel, options });
+    } catch (error) {
+      this.logger.error("Unsubscribe error", error, { channel });
+      throw error;
+    }
   }
   /**
    * Registers an event listener.
@@ -2376,14 +2071,27 @@ var WebSocketClient = class {
    * Removes an event listener.
    *
    * @param event - Event name
-   * @param handler - Event handler to remove
+   * @param handler - Event handler to remove (if undefined, removes all handlers for event)
    * @returns This client for chaining
+   *
+   * @example
+   * ```typescript
+   * // Remove specific handler
+   * wsClient.off('orderbookUpdate', myHandler);
+   *
+   * // Remove all handlers for event
+   * wsClient.off('orderbookUpdate');
+   * ```
    */
   off(event, handler) {
     if (!this.socket) {
       return this;
     }
-    this.socket.off(event, handler);
+    if (handler === void 0) {
+      this.socket.removeAllListeners(event);
+    } else {
+      this.socket.off(event, handler);
+    }
     return this;
   }
   /**
@@ -2475,8 +2183,7 @@ var WebSocketClient = class {
 };
 export {
   APIError,
-  AuthenticatedClient,
-  Authenticator,
+  AuthenticationError,
   BASE_SEPOLIA_CHAIN_ID,
   CONTRACT_ADDRESSES,
   ConsoleLogger,
@@ -2484,15 +2191,16 @@ export {
   DEFAULT_CHAIN_ID,
   DEFAULT_WS_URL,
   HttpClient,
+  Market,
   MarketFetcher,
-  MarketType,
-  MessageSigner,
   NoOpLogger,
   OrderBuilder,
   OrderClient,
   OrderSigner,
   OrderType,
+  OrderValidationError,
   PortfolioFetcher,
+  RateLimitError,
   RetryConfig,
   RetryableClient,
   SIGNING_MESSAGE_TEMPLATE,