@limitless-exchange/sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,2555 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APIError: () => APIError,
+  AuthenticatedClient: () => AuthenticatedClient,
+  Authenticator: () => Authenticator,
+  BASE_SEPOLIA_CHAIN_ID: () => BASE_SEPOLIA_CHAIN_ID,
+  CONTRACT_ADDRESSES: () => CONTRACT_ADDRESSES,
+  ConsoleLogger: () => ConsoleLogger,
+  DEFAULT_API_URL: () => DEFAULT_API_URL,
+  DEFAULT_CHAIN_ID: () => DEFAULT_CHAIN_ID,
+  DEFAULT_WS_URL: () => DEFAULT_WS_URL,
+  HttpClient: () => HttpClient,
+  MarketFetcher: () => MarketFetcher,
+  MarketType: () => MarketType,
+  MessageSigner: () => MessageSigner,
+  NoOpLogger: () => NoOpLogger,
+  OrderBuilder: () => OrderBuilder,
+  OrderClient: () => OrderClient,
+  OrderSigner: () => OrderSigner,
+  OrderType: () => OrderType,
+  PortfolioFetcher: () => PortfolioFetcher,
+  RetryConfig: () => RetryConfig,
+  RetryableClient: () => RetryableClient,
+  SIGNING_MESSAGE_TEMPLATE: () => SIGNING_MESSAGE_TEMPLATE,
+  Side: () => Side,
+  SignatureType: () => SignatureType,
+  ValidationError: () => ValidationError,
+  WebSocketClient: () => WebSocketClient,
+  WebSocketState: () => WebSocketState,
+  ZERO_ADDRESS: () => ZERO_ADDRESS,
+  getContractAddress: () => getContractAddress,
+  retryOnErrors: () => retryOnErrors,
+  validateOrderArgs: () => validateOrderArgs,
+  validateSignedOrder: () => validateSignedOrder,
+  validateUnsignedOrder: () => validateUnsignedOrder,
+  withRetry: () => withRetry
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/logger.ts
+var NoOpLogger = class {
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+};
+var ConsoleLogger = class {
+  constructor(level = "info") {
+    this.level = level;
+  }
+  shouldLog(messageLevel) {
+    const levels = ["debug", "info", "warn", "error"];
+    return levels.indexOf(messageLevel) >= levels.indexOf(this.level);
+  }
+  debug(message, meta) {
+    if (this.shouldLog("debug")) {
+      console.debug("[Limitless SDK]", message, meta || "");
+    }
+  }
+  info(message, meta) {
+    if (this.shouldLog("info")) {
+      console.info("[Limitless SDK]", message, meta || "");
+    }
+  }
+  warn(message, meta) {
+    if (this.shouldLog("warn")) {
+      console.warn("[Limitless SDK]", message, meta || "");
+    }
+  }
+  error(message, error, meta) {
+    if (this.shouldLog("error")) {
+      const errorMsg = error ? error.message : "";
+      console.error("[Limitless SDK]", message, errorMsg ? `- ${errorMsg}` : "", meta || "");
+    }
+  }
+};
+
+// src/types/orders.ts
+var Side = /* @__PURE__ */ ((Side2) => {
+  Side2[Side2["BUY"] = 0] = "BUY";
+  Side2[Side2["SELL"] = 1] = "SELL";
+  return Side2;
+})(Side || {});
+var OrderType = /* @__PURE__ */ ((OrderType3) => {
+  OrderType3["FOK"] = "FOK";
+  OrderType3["GTC"] = "GTC";
+  return OrderType3;
+})(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";
+  SignatureType2[SignatureType2["POLY_GNOSIS_SAFE"] = 2] = "POLY_GNOSIS_SAFE";
+  return SignatureType2;
+})(SignatureType || {});
+
+// src/types/websocket.ts
+var WebSocketState = /* @__PURE__ */ ((WebSocketState2) => {
+  WebSocketState2["DISCONNECTED"] = "disconnected";
+  WebSocketState2["CONNECTING"] = "connecting";
+  WebSocketState2["CONNECTED"] = "connected";
+  WebSocketState2["RECONNECTING"] = "reconnecting";
+  WebSocketState2["ERROR"] = "error";
+  return WebSocketState2;
+})(WebSocketState || {});
+
+// src/auth/signer.ts
+var import_ethers = require("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 = import_ethers.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 import_ethers.ethers.hexlify(import_ethers.ethers.toUtf8Bytes(text));
+  }
+};
+
+// src/auth/authenticator.ts
+var Authenticator = class {
+  /**
+   * 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)
+   *
+   * @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);
+   * ```
+   */
+  constructor(httpClient, signer, logger) {
+    this.httpClient = httpClient;
+    this.signer = signer;
+    this.logger = logger || new NoOpLogger();
+  }
+  /**
+   * Gets a signing message from the API.
+   *
+   * @returns Promise resolving to signing message string
+   * @throws Error if API request fails
+   *
+   * @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.
+   *
+   * @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
+   *
+   * @example
+   * ```typescript
+   * // EOA authentication
+   * const result = await authenticator.authenticate({ client: 'eoa' });
+   *
+   * // ETHERSPOT with smart wallet
+   * const result = await authenticator.authenticate({
+   *   client: 'etherspot',
+   *   smartWallet: '0x...'
+   * });
+   * ```
+   */
+  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
+        }
+      );
+      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();
+      }
+    }
+  }
+  /**
+   * 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/errors.ts
+var APIError = class _APIError extends Error {
+  /**
+   * Creates a new API error.
+   *
+   * @param message - Human-readable error message
+   * @param status - HTTP status code
+   * @param data - Raw API response data
+   * @param url - Request URL
+   * @param method - Request method
+   */
+  constructor(message, status, data, url, method) {
+    super(message);
+    this.name = "APIError";
+    this.status = status;
+    this.data = data;
+    this.url = url;
+    this.method = method;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _APIError);
+    }
+  }
+  /**
+   * Checks if this error is an authentication/authorization error.
+   *
+   * @returns True if the error is due to expired or invalid authentication
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await portfolioFetcher.getPositions();
+   * } catch (error) {
+   *   if (error instanceof APIError && error.isAuthError()) {
+   *     // Re-authenticate and retry
+   *     await authenticator.authenticate({ client: 'eoa' });
+   *     await portfolioFetcher.getPositions();
+   *   }
+   * }
+   * ```
+   */
+  isAuthError() {
+    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;
+      }
+    }
+    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
+var import_axios = __toESM(require("axios"));
+
+// 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..."
+  }
+};
+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(", ")}`
+    );
+  }
+  return addresses[marketType];
+}
+
+// src/api/http.ts
+var HttpClient = class {
+  /**
+   * Creates a new HTTP client instance.
+   *
+   * @param config - Configuration options for the HTTP client
+   */
+  constructor(config = {}) {
+    this.sessionCookie = config.sessionCookie;
+    this.logger = config.logger || new NoOpLogger();
+    this.client = import_axios.default.create({
+      baseURL: config.baseURL || DEFAULT_API_URL,
+      timeout: config.timeout || 3e4,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      }
+    });
+    this.setupInterceptors();
+  }
+  /**
+   * Sets up request and response interceptors.
+   * @internal
+   */
+  setupInterceptors() {
+    this.client.interceptors.request.use(
+      (config) => {
+        if (this.sessionCookie) {
+          config.headers["Cookie"] = `limitless_session=${this.sessionCookie}`;
+        }
+        const fullUrl = `${config.baseURL || ""}${config.url || ""}`;
+        const method = config.method?.toUpperCase() || "GET";
+        this.logger.debug(`\u2192 ${method} ${fullUrl}`, {
+          headers: config.headers,
+          body: config.data
+        });
+        return config;
+      },
+      (error) => Promise.reject(error)
+    );
+    this.client.interceptors.response.use(
+      (response) => {
+        const method = response.config.method?.toUpperCase() || "GET";
+        const url = response.config.url || "";
+        this.logger.debug(`\u2713 ${response.status} ${method} ${url}`, {
+          data: response.data
+        });
+        return response;
+      },
+      (error) => {
+        if (error.response) {
+          const status = error.response.status;
+          const data = error.response.data;
+          const url = error.config?.url;
+          const method = error.config?.method?.toUpperCase();
+          let message = error.message;
+          if (data) {
+            this.logger.debug(`\u2717 ${status} ${method} ${url}`, {
+              error: data
+            });
+            if (typeof data === "object") {
+              if (Array.isArray(data.message)) {
+                const messages = data.message.map((err) => {
+                  const details = Object.entries(err).filter(([_key, val]) => val !== "" && val !== null && val !== void 0).map(([key, val]) => `${key}: ${val}`).join(", ");
+                  return details || JSON.stringify(err);
+                }).filter((msg) => msg.trim() !== "").join(" | ");
+                message = messages || data.error || JSON.stringify(data);
+              } else {
+                message = data.message || data.error || data.msg || data.errors && JSON.stringify(data.errors) || JSON.stringify(data);
+              }
+            } else {
+              message = String(data);
+            }
+          }
+          throw new APIError(message, status, data, url, method);
+        } else if (error.request) {
+          throw new Error("No response received from API");
+        } else {
+          throw new Error(`Request failed: ${error.message}`);
+        }
+      }
+    );
+  }
+  /**
+   * Sets the session cookie for authenticated requests.
+   *
+   * @param cookie - Session cookie value
+   */
+  setSessionCookie(cookie) {
+    this.sessionCookie = cookie;
+  }
+  /**
+   * Clears the session cookie.
+   */
+  clearSessionCookie() {
+    this.sessionCookie = void 0;
+  }
+  /**
+   * Performs a GET request.
+   *
+   * @param url - Request URL
+   * @param config - Additional request configuration
+   * @returns Promise resolving to the response data
+   */
+  async get(url, config) {
+    const response = await this.client.get(url, config);
+    return response.data;
+  }
+  /**
+   * Performs a POST request.
+   *
+   * @param url - Request URL
+   * @param data - Request body data
+   * @param config - Additional request configuration
+   * @returns Promise resolving to the response data
+   */
+  async post(url, data, config) {
+    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.
+   *
+   * @remarks
+   * DELETE requests typically don't have a body, so we remove the Content-Type header
+   * to avoid "Body cannot be empty" errors from the API.
+   *
+   * @param url - Request URL
+   * @param config - Additional request configuration
+   * @returns Promise resolving to the response data
+   */
+  async delete(url, config) {
+    const deleteConfig = {
+      ...config,
+      headers: {
+        ...config?.headers,
+        "Content-Type": void 0
+      }
+    };
+    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
+var RetryConfig = class {
+  /**
+   * Creates a new retry configuration.
+   *
+   * @param options - Configuration options
+   */
+  constructor(options = {}) {
+    this.statusCodes = new Set(options.statusCodes || [429, 500, 502, 503, 504]);
+    this.maxRetries = options.maxRetries ?? 3;
+    this.delays = options.delays;
+    this.exponentialBase = options.exponentialBase ?? 2;
+    this.maxDelay = options.maxDelay ?? 60;
+    this.onRetry = options.onRetry;
+  }
+  /**
+   * Calculates delay for a given retry attempt.
+   *
+   * @param attempt - Retry attempt number (0-based)
+   * @returns Delay in seconds
+   */
+  getDelay(attempt) {
+    if (this.delays) {
+      return this.delays[Math.min(attempt, this.delays.length - 1)];
+    } else {
+      return Math.min(Math.pow(this.exponentialBase, attempt), this.maxDelay);
+    }
+  }
+};
+function sleep(seconds) {
+  return new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+}
+function retryOnErrors(options = {}) {
+  const config = new RetryConfig(options);
+  return function(_target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      let lastError;
+      try {
+        return await originalMethod.apply(this, args);
+      } catch (error) {
+        if (error instanceof APIError && config.statusCodes.has(error.status)) {
+          lastError = error;
+        } else {
+          throw error;
+        }
+      }
+      for (let attempt = 0; attempt < config.maxRetries; attempt++) {
+        try {
+          const delay = config.getDelay(attempt);
+          if (config.onRetry && lastError) {
+            config.onRetry(attempt, lastError, delay);
+          }
+          await sleep(delay);
+          return await originalMethod.apply(this, args);
+        } catch (error) {
+          if (error instanceof APIError && config.statusCodes.has(error.status)) {
+            lastError = error;
+          } else {
+            throw error;
+          }
+        }
+      }
+      throw lastError;
+    };
+    return descriptor;
+  };
+}
+async function withRetry(fn, options = {}, logger = new NoOpLogger()) {
+  const config = new RetryConfig(options);
+  let lastError;
+  try {
+    return await fn();
+  } catch (error) {
+    if (error instanceof APIError && config.statusCodes.has(error.status)) {
+      lastError = error;
+      logger.warn("API error, starting retries", { status: error.status });
+    } else {
+      throw error;
+    }
+  }
+  for (let attempt = 0; attempt < config.maxRetries; attempt++) {
+    try {
+      const delay = config.getDelay(attempt);
+      if (config.onRetry && lastError) {
+        config.onRetry(attempt, lastError, delay);
+      }
+      logger.info("Retrying operation", { attempt: attempt + 1, delay });
+      await sleep(delay);
+      return await fn();
+    } catch (error) {
+      if (error instanceof APIError && config.statusCodes.has(error.status)) {
+        lastError = error;
+        logger.warn("Retry failed", { attempt: attempt + 1, status: error.status });
+      } else {
+        throw error;
+      }
+    }
+  }
+  logger.error("All retries exhausted");
+  throw lastError;
+}
+var RetryableClient = class {
+  /**
+   * Creates a new retryable client wrapper.
+   *
+   * @param httpClient - HTTP client to wrap
+   * @param retryConfig - Retry configuration
+   * @param logger - Optional logger
+   */
+  constructor(httpClient, retryConfig = new RetryConfig(), logger = new NoOpLogger()) {
+    this.httpClient = httpClient;
+    this.retryConfig = retryConfig;
+    this.logger = logger;
+  }
+  /**
+   * Performs a GET request with retry logic.
+   *
+   * @param url - Request URL
+   * @param config - Additional request configuration
+   * @returns Promise resolving to the response data
+   */
+  async get(url, config) {
+    return withRetry(
+      async () => this.httpClient.get(url, config),
+      {
+        statusCodes: Array.from(this.retryConfig.statusCodes),
+        maxRetries: this.retryConfig.maxRetries,
+        delays: this.retryConfig.delays,
+        exponentialBase: this.retryConfig.exponentialBase,
+        maxDelay: this.retryConfig.maxDelay,
+        onRetry: this.retryConfig.onRetry
+      },
+      this.logger
+    );
+  }
+  /**
+   * Performs a POST request with retry logic.
+   *
+   * @param url - Request URL
+   * @param data - Request body data
+   * @param config - Additional request configuration
+   * @returns Promise resolving to the response data
+   */
+  async post(url, data, config) {
+    return withRetry(
+      async () => this.httpClient.post(url, data, config),
+      {
+        statusCodes: Array.from(this.retryConfig.statusCodes),
+        maxRetries: this.retryConfig.maxRetries,
+        delays: this.retryConfig.delays,
+        exponentialBase: this.retryConfig.exponentialBase,
+        maxDelay: this.retryConfig.maxDelay,
+        onRetry: this.retryConfig.onRetry
+      },
+      this.logger
+    );
+  }
+  /**
+   * Performs a DELETE request with retry logic.
+   *
+   * @param url - Request URL
+   * @param config - Additional request configuration
+   * @returns Promise resolving to the response data
+   */
+  async delete(url, config) {
+    return withRetry(
+      async () => this.httpClient.delete(url, config),
+      {
+        statusCodes: Array.from(this.retryConfig.statusCodes),
+        maxRetries: this.retryConfig.maxRetries,
+        delays: this.retryConfig.delays,
+        exponentialBase: this.retryConfig.exponentialBase,
+        maxDelay: this.retryConfig.maxDelay,
+        onRetry: this.retryConfig.onRetry
+      },
+      this.logger
+    );
+  }
+};
+
+// src/orders/builder.ts
+var import_ethers2 = require("ethers");
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+var DEFAULT_PRICE_TICK = 1e-3;
+var OrderBuilder = class {
+  /**
+   * Creates a new order builder instance.
+   *
+   * @param makerAddress - Ethereum address of the order maker
+   * @param feeRateBps - Fee rate in basis points (e.g., 100 = 1%)
+   * @param priceTick - Price tick size (default: 0.001 for 3 decimals)
+   *
+   * @example
+   * ```typescript
+   * const builder = new OrderBuilder(
+   *   '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+   *   300, // 3% fee
+   *   0.001 // 3 decimal price precision
+   * );
+   * ```
+   */
+  constructor(makerAddress, feeRateBps, priceTick = DEFAULT_PRICE_TICK) {
+    this.makerAddress = makerAddress;
+    this.feeRateBps = feeRateBps;
+    this.priceTick = priceTick;
+  }
+  /**
+   * Builds an unsigned order payload.
+   *
+   * @param args - Order arguments (FOK or GTC)
+   * @returns Unsigned order ready for signing
+   *
+   * @throws Error if validation fails or tick alignment fails
+   *
+   * @example
+   * ```typescript
+   * // FOK order (market order)
+   * const fokOrder = builder.buildOrder({
+   *   tokenId: '123456',
+   *   makerAmount: 50,  // 50 USDC to spend
+   *   side: Side.BUY,
+   *   marketType: MarketType.CLOB
+   * });
+   *
+   * // GTC order (price + size)
+   * const gtcOrder = builder.buildOrder({
+   *   tokenId: '123456',
+   *   price: 0.38,
+   *   size: 22.123,  // Will be rounded to tick-aligned: 22.123 shares
+   *   side: Side.BUY,
+   *   marketType: MarketType.CLOB
+   * });
+   * ```
+   */
+  buildOrder(args) {
+    this.validateOrderArgs(args);
+    const { makerAmount, takerAmount, price } = this.isFOKOrder(args) ? this.calculateFOKAmounts(args.makerAmount) : this.calculateGTCAmountsTickAligned(args.price, args.size, args.side);
+    const order = {
+      salt: this.generateSalt(),
+      maker: this.makerAddress,
+      signer: this.makerAddress,
+      taker: args.taker || ZERO_ADDRESS2,
+      tokenId: args.tokenId,
+      makerAmount,
+      takerAmount,
+      expiration: args.expiration || "0",
+      nonce: args.nonce || 0,
+      feeRateBps: this.feeRateBps,
+      side: args.side,
+      signatureType: 0 /* EOA */
+    };
+    if (price !== void 0) {
+      order.price = price;
+    }
+    return order;
+  }
+  /**
+   * Type guard to check if order arguments are for FOK order.
+   *
+   * @param args - Order arguments
+   * @returns True if FOK order arguments
+   *
+   * @internal
+   */
+  isFOKOrder(args) {
+    return "amount" in args;
+  }
+  /**
+   * Generates a unique salt using timestamp + nano-offset pattern.
+   *
+   * @remarks
+   * This follows the reference implementation pattern:
+   * salt = timestamp * 1000 + nanoOffset + 24h
+   *
+   * This ensures uniqueness even when creating orders rapidly.
+   *
+   * @returns Unique salt value
+   *
+   * @internal
+   */
+  generateSalt() {
+    const timestamp = Date.now();
+    const nanoOffset = Math.floor(performance.now() * 1e3) % 1e6;
+    const oneDayMs = 1e3 * 60 * 60 * 24;
+    return timestamp * 1e3 + nanoOffset + oneDayMs;
+  }
+  /**
+   * Parses decimal string to scaled BigInt.
+   *
+   * @param value - Decimal string (e.g., "0.38")
+   * @param scale - Scale factor (e.g., 1_000_000n for 6 decimals)
+   * @returns Scaled BigInt value
+   *
+   * @internal
+   */
+  parseDecToInt(value, scale) {
+    const s = value.trim();
+    const [intPart, fracPart = ""] = s.split(".");
+    const decimals = scale.toString().length - 1;
+    const frac = (fracPart + "0".repeat(decimals)).slice(0, decimals);
+    const sign = intPart.startsWith("-") ? -1n : 1n;
+    const intPartAbs = intPart.replace("-", "");
+    return sign * (BigInt(intPartAbs || "0") * scale + BigInt(frac || "0"));
+  }
+  /**
+   * Ceiling division for BigInt.
+   *
+   * @param numerator - Numerator
+   * @param denominator - Denominator
+   * @returns Ceiling of numerator / denominator
+   *
+   * @internal
+   */
+  divCeil(numerator, denominator) {
+    if (denominator === 0n) {
+      throw new Error("Division by zero");
+    }
+    return (numerator + denominator - 1n) / denominator;
+  }
+  /**
+   * Calculates maker and taker amounts for GTC orders with tick alignment validation.
+   *
+   * @remarks
+   * Validates and calculates amounts to ensure:
+   * 1. Price aligns to tick size (e.g., 0.001 for 3 decimals)
+   * 2. Size produces takerAmount divisible by sharesStep
+   * 3. No auto-rounding - fails fast if values are invalid
+   * 4. Transparent error messages guide users to valid values
+   *
+   * **Algorithm**:
+   * - sharesStep = priceScale / tickInt (e.g., 1000 for 0.001 tick)
+   * - Validates shares are divisible by sharesStep
+   * - Calculates collateral from shares × price (ceil for BUY, floor for SELL)
+   * - Assigns maker/taker based on side:
+   *   - BUY: maker = collateral, taker = shares
+   *   - SELL: maker = shares, taker = collateral
+   * - Throws clear error if size is not tick-aligned
+   *
+   * @param price - Price per share (0.0 to 1.0, max 3 decimals)
+   * @param size - Number of shares (must be tick-aligned)
+   * @param side - Order side (BUY or SELL)
+   * @returns Object with validated makerAmount, takerAmount, and price
+   *
+   * @throws Error if price or size not tick-aligned
+   *
+   * @internal
+   */
+  calculateGTCAmountsTickAligned(price, size, side) {
+    const sharesScale = 1000000n;
+    const collateralScale = 1000000n;
+    const priceScale = 1000000n;
+    const shares = this.parseDecToInt(size.toString(), sharesScale);
+    const priceInt = this.parseDecToInt(price.toString(), priceScale);
+    const tickInt = this.parseDecToInt(this.priceTick.toString(), priceScale);
+    if (tickInt <= 0n) {
+      throw new Error(`Invalid priceTick: ${this.priceTick}`);
+    }
+    if (priceInt <= 0n) {
+      throw new Error(`Invalid price: ${price}`);
+    }
+    if (priceInt % tickInt !== 0n) {
+      throw new Error(
+        `Price ${price} is not tick-aligned. Must be multiple of ${this.priceTick} (e.g., 0.380, 0.381, etc.)`
+      );
+    }
+    const sharesStep = priceScale / tickInt;
+    if (shares % sharesStep !== 0n) {
+      const validSizeDown = Number(shares / sharesStep * sharesStep) / 1e6;
+      const validSizeUp = Number(this.divCeil(shares, sharesStep) * sharesStep) / 1e6;
+      throw new Error(
+        `Invalid size: ${size}. Size must produce contracts divisible by ${sharesStep} (sharesStep). Try ${validSizeDown} (rounded down) or ${validSizeUp} (rounded up) instead.`
+      );
+    }
+    const numerator = shares * priceInt * collateralScale;
+    const denominator = sharesScale * priceScale;
+    const collateral = side === 0 /* BUY */ ? this.divCeil(numerator, denominator) : numerator / denominator;
+    let makerAmount;
+    let takerAmount;
+    if (side === 0 /* BUY */) {
+      makerAmount = collateral;
+      takerAmount = shares;
+    } else {
+      makerAmount = shares;
+      takerAmount = collateral;
+    }
+    return {
+      makerAmount: Number(makerAmount),
+      takerAmount: Number(takerAmount),
+      price
+    };
+  }
+  /**
+   * Calculates maker and taker amounts for FOK (market) orders.
+   *
+   * @remarks
+   * FOK orders use makerAmount for both BUY and SELL:
+   * - BUY: makerAmount = USDC amount to spend (e.g., 50 = $50 USDC)
+   * - SELL: makerAmount = number of shares to sell (e.g., 18.64 shares)
+   *
+   * takerAmount is always 1 (constant for FOK orders)
+   *
+   * @param makerAmount - Amount in human-readable format (max 6 decimals)
+   * @returns Object with makerAmount (scaled), takerAmount (always 1), and undefined price
+   *
+   * @internal
+   */
+  calculateFOKAmounts(makerAmount) {
+    const DECIMALS = 6;
+    const amountStr = makerAmount.toString();
+    const decimalIndex = amountStr.indexOf(".");
+    if (decimalIndex !== -1) {
+      const decimalPlaces = amountStr.length - decimalIndex - 1;
+      if (decimalPlaces > DECIMALS) {
+        throw new Error(
+          `Invalid makerAmount: ${makerAmount}. Can have max ${DECIMALS} decimal places. Try ${makerAmount.toFixed(DECIMALS)} instead.`
+        );
+      }
+    }
+    const amountFormatted = makerAmount.toFixed(DECIMALS);
+    const amountScaled = import_ethers2.ethers.parseUnits(amountFormatted, DECIMALS);
+    const collateralAmount = Number(amountScaled);
+    return {
+      makerAmount: collateralAmount,
+      takerAmount: 1,
+      price: void 0
+    };
+  }
+  /**
+   * Validates order arguments.
+   *
+   * @param args - Order arguments to validate
+   * @throws Error if validation fails
+   *
+   * @internal
+   */
+  validateOrderArgs(args) {
+    if (!args.tokenId || args.tokenId === "0") {
+      throw new Error("Invalid tokenId: tokenId is required.");
+    }
+    if (args.taker && !import_ethers2.ethers.isAddress(args.taker)) {
+      throw new Error(`Invalid taker address: ${args.taker}`);
+    }
+    if (this.isFOKOrder(args)) {
+      if (!args.makerAmount) {
+        throw new Error("FOK orders require makerAmount");
+      }
+      if (args.makerAmount <= 0) {
+        throw new Error(`Invalid makerAmount: ${args.makerAmount}. Maker amount must be positive.`);
+      }
+    } else {
+      if (args.price < 0 || args.price > 1) {
+        throw new Error(`Invalid price: ${args.price}. Price must be between 0 and 1.`);
+      }
+      if (args.size <= 0) {
+        throw new Error(`Invalid size: ${args.size}. Size must be positive.`);
+      }
+      const priceStr = args.price.toString();
+      const decimalIndex = priceStr.indexOf(".");
+      if (decimalIndex !== -1) {
+        const decimalPlaces = priceStr.length - decimalIndex - 1;
+        if (decimalPlaces > 3) {
+          throw new Error(
+            `Invalid price: ${args.price}. Price must have max 3 decimal places (e.g., 0.380, 0.001).`
+          );
+        }
+      }
+    }
+  }
+};
+
+// src/orders/signer.ts
+var OrderSigner = class {
+  /**
+   * Creates a new order signer instance.
+   *
+   * @param wallet - Ethers wallet for signing
+   * @param logger - Optional logger for debugging (default: no logging)
+   *
+   * @example
+   * ```typescript
+   * import { ethers } from 'ethers';
+   * import { OrderSigner } from '@limitless-exchange/sdk';
+   *
+   * const wallet = new ethers.Wallet(privateKey);
+   * const signer = new OrderSigner(wallet);
+   * ```
+   */
+  constructor(wallet, logger) {
+    this.wallet = wallet;
+    this.logger = logger || new NoOpLogger();
+  }
+  /**
+   * Signs an order with EIP-712.
+   *
+   * @param order - Unsigned order to sign
+   * @param config - Signing configuration (chainId, contract address, market type)
+   * @returns Promise resolving to EIP-712 signature
+   *
+   * @throws Error if wallet address doesn't match order signer
+   * @throws Error if signing fails
+   *
+   * @example
+   * ```typescript
+   * const signature = await signer.signOrder(unsignedOrder, {
+   *   chainId: 8453,
+   *   contractAddress: '0x...',
+   *   marketType: MarketType.CLOB
+   * });
+   * ```
+   */
+  async signOrder(order, config) {
+    this.logger.debug("Signing order with EIP-712", {
+      tokenId: order.tokenId,
+      side: order.side,
+      marketType: config.marketType
+    });
+    const walletAddress = await this.wallet.getAddress();
+    if (walletAddress.toLowerCase() !== order.signer.toLowerCase()) {
+      const error = `Wallet address mismatch! Signing with: ${walletAddress}, but order signer is: ${order.signer}`;
+      this.logger.error(error);
+      throw new Error(error);
+    }
+    const domain = this.getDomain(config);
+    this.logger.debug("EIP-712 Domain", domain);
+    const types = this.getTypes();
+    const orderValue = {
+      salt: order.salt,
+      maker: order.maker,
+      signer: order.signer,
+      taker: order.taker,
+      tokenId: order.tokenId,
+      makerAmount: order.makerAmount,
+      takerAmount: order.takerAmount,
+      expiration: order.expiration,
+      nonce: order.nonce,
+      feeRateBps: order.feeRateBps,
+      side: order.side,
+      signatureType: order.signatureType
+    };
+    this.logger.debug("EIP-712 Order Value", orderValue);
+    console.log("[OrderSigner] Full signing payload:", JSON.stringify({
+      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", {
+        signature: signature.slice(0, 10) + "..."
+      });
+      return signature;
+    } catch (error) {
+      this.logger.error("Failed to sign order", error);
+      throw error;
+    }
+  }
+  /**
+   * Gets the EIP-712 domain for signing.
+   *
+   * @param config - Signing configuration
+   * @returns EIP-712 domain object
+   *
+   * @internal
+   */
+  getDomain(config) {
+    return {
+      name: "Limitless CTF Exchange",
+      version: "1",
+      chainId: config.chainId,
+      verifyingContract: config.contractAddress
+    };
+  }
+  /**
+   * Gets the EIP-712 type definitions.
+   *
+   * @remarks
+   * This matches the order structure expected by the Limitless Exchange
+   * smart contracts.
+   *
+   * @returns EIP-712 types definition
+   *
+   * @internal
+   */
+  getTypes() {
+    return {
+      Order: [
+        { name: "salt", type: "uint256" },
+        { name: "maker", type: "address" },
+        { name: "signer", type: "address" },
+        { name: "taker", type: "address" },
+        { name: "tokenId", type: "uint256" },
+        { name: "makerAmount", type: "uint256" },
+        { name: "takerAmount", type: "uint256" },
+        { name: "expiration", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "feeRateBps", type: "uint256" },
+        { name: "side", type: "uint8" },
+        { name: "signatureType", type: "uint8" }
+      ]
+    };
+  }
+};
+
+// src/orders/validator.ts
+var import_ethers3 = require("ethers");
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+function isFOKOrder(args) {
+  return "amount" in args;
+}
+function validateOrderArgs(args) {
+  if (!args.tokenId) {
+    throw new ValidationError("TokenId is required");
+  }
+  if (args.tokenId === "0") {
+    throw new ValidationError("TokenId cannot be zero");
+  }
+  if (!/^\d+$/.test(args.tokenId)) {
+    throw new ValidationError(`Invalid tokenId format: ${args.tokenId}`);
+  }
+  if (args.taker && !import_ethers3.ethers.isAddress(args.taker)) {
+    throw new ValidationError(`Invalid taker address: ${args.taker}`);
+  }
+  if (args.expiration !== void 0) {
+    if (!/^\d+$/.test(args.expiration)) {
+      throw new ValidationError(`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}`);
+    }
+  }
+  if (isFOKOrder(args)) {
+    if (typeof args.makerAmount !== "number" || isNaN(args.makerAmount)) {
+      throw new ValidationError("Amount must be a valid number");
+    }
+    if (args.makerAmount <= 0) {
+      throw new ValidationError(`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(
+          `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");
+    }
+    if (args.price < 0 || args.price > 1) {
+      throw new ValidationError(`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");
+    }
+    if (args.size <= 0) {
+      throw new ValidationError(`Size must be positive, got: ${args.size}`);
+    }
+  }
+}
+function validateUnsignedOrder(order) {
+  if (!import_ethers3.ethers.isAddress(order.maker)) {
+    throw new ValidationError(`Invalid maker address: ${order.maker}`);
+  }
+  if (!import_ethers3.ethers.isAddress(order.signer)) {
+    throw new ValidationError(`Invalid signer address: ${order.signer}`);
+  }
+  if (!import_ethers3.ethers.isAddress(order.taker)) {
+    throw new ValidationError(`Invalid taker address: ${order.taker}`);
+  }
+  if (!order.makerAmount || order.makerAmount === 0) {
+    throw new ValidationError("MakerAmount must be greater than zero");
+  }
+  if (!order.takerAmount || order.takerAmount === 0) {
+    throw new ValidationError("TakerAmount must be greater than zero");
+  }
+  if (typeof order.makerAmount !== "number" || order.makerAmount <= 0) {
+    throw new ValidationError(`Invalid makerAmount: ${order.makerAmount}`);
+  }
+  if (typeof order.takerAmount !== "number" || order.takerAmount <= 0) {
+    throw new ValidationError(`Invalid takerAmount: ${order.takerAmount}`);
+  }
+  if (!/^\d+$/.test(order.tokenId)) {
+    throw new ValidationError(`Invalid tokenId format: ${order.tokenId}`);
+  }
+  if (!/^\d+$/.test(order.expiration)) {
+    throw new ValidationError(`Invalid expiration format: ${order.expiration}`);
+  }
+  if (!Number.isInteger(order.salt) || order.salt <= 0) {
+    throw new ValidationError(`Invalid salt: ${order.salt}`);
+  }
+  if (!Number.isInteger(order.nonce) || order.nonce < 0) {
+    throw new ValidationError(`Invalid nonce: ${order.nonce}`);
+  }
+  if (!Number.isInteger(order.feeRateBps) || order.feeRateBps < 0) {
+    throw new ValidationError(`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)`);
+  }
+  if (!Number.isInteger(order.signatureType) || order.signatureType < 0) {
+    throw new ValidationError(`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");
+    }
+    if (order.price < 0 || order.price > 1) {
+      throw new ValidationError(`Price must be between 0 and 1, got: ${order.price}`);
+    }
+  }
+}
+function validateSignedOrder(order) {
+  validateUnsignedOrder(order);
+  if (!order.signature) {
+    throw new ValidationError("Signature is required");
+  }
+  if (!order.signature.startsWith("0x")) {
+    throw new ValidationError("Signature must start with 0x");
+  }
+  if (order.signature.length !== 132) {
+    throw new ValidationError(
+      `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");
+  }
+}
+
+// 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;
+    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
+      });
+    }
+  }
+  /**
+   * 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.
+   *
+   * @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 {
+  /**
+   * 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 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 || [];
+  }
+  /**
+   * Flattens positions into a unified format for easier consumption.
+   *
+   * @remarks
+   * Converts CLOB positions (which have YES/NO sides) and AMM positions
+   * into a unified Position array. Only includes positions with non-zero values.
+   *
+   * @returns Promise resolving to array of flattened positions
+   * @throws Error if API request fails
+   *
+   * @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`);
+   * });
+   * ```
+   */
+  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;
+  }
+  /**
+   * Calculates portfolio summary statistics from raw API response.
+   *
+   * @param response - Portfolio positions response from API
+   * @returns Portfolio summary with totals and statistics
+   *
+   * @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}`);
+   * ```
+   */
+  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;
+  }
+  /**
+   * Gets positions and calculates summary in a single call.
+   *
+   * @returns Promise resolving to response and summary
+   * @throws Error if API request fails or user is not authenticated
+   *
+   * @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}`);
+   * ```
+   */
+  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 };
+  }
+};
+
+// src/websocket/client.ts
+var import_socket = require("socket.io-client");
+var WebSocketClient = class {
+  /**
+   * Creates a new WebSocket client.
+   *
+   * @param config - WebSocket configuration
+   * @param logger - Optional logger for debugging
+   */
+  constructor(config = {}, logger) {
+    this.socket = null;
+    this.state = "disconnected" /* DISCONNECTED */;
+    this.reconnectAttempts = 0;
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.pendingListeners = [];
+    this.config = {
+      url: config.url || DEFAULT_WS_URL,
+      sessionCookie: config.sessionCookie || "",
+      autoReconnect: config.autoReconnect ?? true,
+      reconnectDelay: config.reconnectDelay || 1e3,
+      maxReconnectAttempts: config.maxReconnectAttempts || Infinity,
+      timeout: config.timeout || 1e4
+    };
+    this.logger = logger || new NoOpLogger();
+  }
+  /**
+   * Gets current connection state.
+   *
+   * @returns Current WebSocket state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Checks if client is connected.
+   *
+   * @returns True if connected
+   */
+  isConnected() {
+    return this.state === "connected" /* CONNECTED */ && this.socket?.connected === true;
+  }
+  /**
+   * Sets the session cookie for authentication.
+   *
+   * @param sessionCookie - Session cookie value
+   */
+  setSessionCookie(sessionCookie) {
+    this.config.sessionCookie = sessionCookie;
+    if (this.socket?.connected) {
+      this.logger.info("Session cookie updated, reconnecting...");
+      this.disconnect();
+      this.connect();
+    }
+  }
+  /**
+   * Connects to the WebSocket server.
+   *
+   * @returns Promise that resolves when connected
+   * @throws Error if connection fails
+   *
+   * @example
+   * ```typescript
+   * await wsClient.connect();
+   * console.log('Connected!');
+   * ```
+   */
+  async connect() {
+    if (this.socket?.connected) {
+      this.logger.info("Already connected");
+      return;
+    }
+    this.logger.info("Connecting to WebSocket", { url: this.config.url });
+    this.state = "connecting" /* CONNECTING */;
+    return new Promise((resolve, reject) => {
+      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 = (0, import_socket.io)(wsUrl, {
+        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,
+        timeout: this.config.timeout
+      });
+      this.attachPendingListeners();
+      this.setupEventHandlers();
+      this.socket.once("connect", () => {
+        clearTimeout(timeout);
+        this.state = "connected" /* CONNECTED */;
+        this.reconnectAttempts = 0;
+        this.logger.info("WebSocket connected");
+        this.resubscribeAll();
+        resolve();
+      });
+      this.socket.once("connect_error", (error) => {
+        clearTimeout(timeout);
+        this.state = "error" /* ERROR */;
+        this.logger.error("WebSocket connection error", error);
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Disconnects from the WebSocket server.
+   *
+   * @example
+   * ```typescript
+   * wsClient.disconnect();
+   * ```
+   */
+  disconnect() {
+    if (!this.socket) {
+      return;
+    }
+    this.logger.info("Disconnecting from WebSocket");
+    this.socket.disconnect();
+    this.socket = null;
+    this.state = "disconnected" /* DISCONNECTED */;
+    this.subscriptions.clear();
+  }
+  /**
+   * Subscribes to a channel.
+   *
+   * @param channel - Channel to subscribe to
+   * @param options - Subscription options
+   * @returns Promise that resolves when subscribed
+   * @throws Error if not connected
+   *
+   * @example
+   * ```typescript
+   * // Subscribe to orderbook for a specific market
+   * await wsClient.subscribe('orderbook', { marketSlug: 'market-123' });
+   *
+   * // Subscribe to all trades
+   * await wsClient.subscribe('trades');
+   *
+   * // Subscribe to your orders
+   * await wsClient.subscribe('orders');
+   * ```
+   */
+  async subscribe(channel, options = {}) {
+    if (!this.isConnected()) {
+      throw new Error("WebSocket not connected. Call connect() first.");
+    }
+    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();
+        }
+      });
+    });
+  }
+  /**
+   * Unsubscribes from a channel.
+   *
+   * @param channel - Channel to unsubscribe from
+   * @param options - Subscription options (must match subscribe call)
+   * @returns Promise that resolves when unsubscribed
+   *
+   * @example
+   * ```typescript
+   * await wsClient.unsubscribe('orderbook', { marketSlug: 'market-123' });
+   * ```
+   */
+  async unsubscribe(channel, options = {}) {
+    if (!this.isConnected()) {
+      throw new Error("WebSocket not connected");
+    }
+    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();
+        }
+      });
+    });
+  }
+  /**
+   * Registers an event listener.
+   *
+   * @param event - Event name
+   * @param handler - Event handler
+   * @returns This client for chaining
+   *
+   * @example
+   * ```typescript
+   * wsClient
+   *   .on('orderbook', (data) => console.log('Orderbook:', data))
+   *   .on('trade', (data) => console.log('Trade:', data))
+   *   .on('error', (error) => console.error('Error:', error));
+   * ```
+   */
+  on(event, handler) {
+    if (!this.socket) {
+      this.pendingListeners.push({ event, handler });
+      return this;
+    }
+    this.socket.on(event, handler);
+    return this;
+  }
+  /**
+   * Registers a one-time event listener.
+   *
+   * @param event - Event name
+   * @param handler - Event handler
+   * @returns This client for chaining
+   */
+  once(event, handler) {
+    if (!this.socket) {
+      throw new Error("WebSocket not initialized. Call connect() first.");
+    }
+    this.socket.once(event, handler);
+    return this;
+  }
+  /**
+   * Removes an event listener.
+   *
+   * @param event - Event name
+   * @param handler - Event handler to remove
+   * @returns This client for chaining
+   */
+  off(event, handler) {
+    if (!this.socket) {
+      return this;
+    }
+    this.socket.off(event, handler);
+    return this;
+  }
+  /**
+   * Attach any pending event listeners that were added before connect().
+   * @internal
+   */
+  attachPendingListeners() {
+    if (!this.socket || this.pendingListeners.length === 0) {
+      return;
+    }
+    for (const { event, handler } of this.pendingListeners) {
+      this.socket.on(event, handler);
+    }
+    this.pendingListeners = [];
+  }
+  /**
+   * Setup internal event handlers for connection management.
+   * @internal
+   */
+  setupEventHandlers() {
+    if (!this.socket) {
+      return;
+    }
+    this.socket.on("connect", () => {
+      this.state = "connected" /* CONNECTED */;
+      this.reconnectAttempts = 0;
+      this.logger.info("WebSocket connected");
+    });
+    this.socket.on("disconnect", (reason) => {
+      this.state = "disconnected" /* DISCONNECTED */;
+      this.logger.info("WebSocket disconnected", { reason });
+    });
+    this.socket.on("error", (error) => {
+      this.state = "error" /* ERROR */;
+      this.logger.error("WebSocket error", error);
+    });
+    this.socket.io.on("reconnect_attempt", (attempt) => {
+      this.state = "reconnecting" /* RECONNECTING */;
+      this.reconnectAttempts = attempt;
+      this.logger.info("Reconnecting...", { attempt });
+    });
+    this.socket.io.on("reconnect", (attempt) => {
+      this.state = "connected" /* CONNECTED */;
+      this.logger.info("Reconnected", { attempts: attempt });
+      this.resubscribeAll();
+    });
+    this.socket.io.on("reconnect_error", (error) => {
+      this.logger.error("Reconnection error", error);
+    });
+    this.socket.io.on("reconnect_failed", () => {
+      this.state = "error" /* ERROR */;
+      this.logger.error("Reconnection failed");
+    });
+  }
+  /**
+   * Re-subscribes to all previous subscriptions after reconnection.
+   * @internal
+   */
+  async resubscribeAll() {
+    if (this.subscriptions.size === 0) {
+      return;
+    }
+    this.logger.info("Re-subscribing to channels", {
+      count: this.subscriptions.size
+    });
+    for (const [key, options] of this.subscriptions.entries()) {
+      const channel = this.getChannelFromKey(key);
+      try {
+        await this.subscribe(channel, options);
+      } catch (error) {
+        this.logger.error("Failed to re-subscribe", error, { channel, options });
+      }
+    }
+  }
+  /**
+   * Creates a unique subscription key.
+   * @internal
+   */
+  getSubscriptionKey(channel, options) {
+    return `${channel}:${options.marketSlug || "global"}`;
+  }
+  /**
+   * Extracts channel from subscription key.
+   * @internal
+   */
+  getChannelFromKey(key) {
+    return key.split(":")[0];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIError,
+  AuthenticatedClient,
+  Authenticator,
+  BASE_SEPOLIA_CHAIN_ID,
+  CONTRACT_ADDRESSES,
+  ConsoleLogger,
+  DEFAULT_API_URL,
+  DEFAULT_CHAIN_ID,
+  DEFAULT_WS_URL,
+  HttpClient,
+  MarketFetcher,
+  MarketType,
+  MessageSigner,
+  NoOpLogger,
+  OrderBuilder,
+  OrderClient,
+  OrderSigner,
+  OrderType,
+  PortfolioFetcher,
+  RetryConfig,
+  RetryableClient,
+  SIGNING_MESSAGE_TEMPLATE,
+  Side,
+  SignatureType,
+  ValidationError,
+  WebSocketClient,
+  WebSocketState,
+  ZERO_ADDRESS,
+  getContractAddress,
+  retryOnErrors,
+  validateOrderArgs,
+  validateSignedOrder,
+  validateUnsignedOrder,
+  withRetry
+});
+//# sourceMappingURL=index.js.map