lighter-sdk-client 0.2.11

package/dist/api/info-private/withdraw-history.d.cts

@@ -0,0 +1,27 @@
+import { AxiosInstance } from 'axios';
+
+interface WithdrawHistoryRequest {
+    account_index: number;
+    l1_address: string;
+    cursor?: string;
+    filter?: string;
+}
+interface WithdrawHistoryItem {
+    id: string;
+    account_index: number;
+    l1_address: string;
+    l2_address: string;
+    amount: string;
+    l1_tx_hash: string;
+    status: string;
+    timestamp: number;
+    created_at: string;
+}
+interface WithdrawHistoryResponse {
+    code: number;
+    withdrawals: WithdrawHistoryItem[];
+    cursor?: string;
+}
+declare function getWithdrawHistory(client: AxiosInstance, params: WithdrawHistoryRequest, authorization?: string): Promise<WithdrawHistoryResponse>;
+
+export { type WithdrawHistoryItem, type WithdrawHistoryRequest, type WithdrawHistoryResponse, getWithdrawHistory };

package/dist/api/info-private/withdraw-history.d.ts

@@ -0,0 +1,27 @@
+import { AxiosInstance } from 'axios';
+
+interface WithdrawHistoryRequest {
+    account_index: number;
+    l1_address: string;
+    cursor?: string;
+    filter?: string;
+}
+interface WithdrawHistoryItem {
+    id: string;
+    account_index: number;
+    l1_address: string;
+    l2_address: string;
+    amount: string;
+    l1_tx_hash: string;
+    status: string;
+    timestamp: number;
+    created_at: string;
+}
+interface WithdrawHistoryResponse {
+    code: number;
+    withdrawals: WithdrawHistoryItem[];
+    cursor?: string;
+}
+declare function getWithdrawHistory(client: AxiosInstance, params: WithdrawHistoryRequest, authorization?: string): Promise<WithdrawHistoryResponse>;
+
+export { type WithdrawHistoryItem, type WithdrawHistoryRequest, type WithdrawHistoryResponse, getWithdrawHistory };

package/dist/api/info-private/withdraw-history.js

@@ -0,0 +1,6 @@
+import {
+  getWithdrawHistory
+} from "../../chunk-PEALQBVN.js";
+export {
+  getWithdrawHistory
+};

package/dist/chunk-2R5COGAH.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/api/info/account-by-l1-address.ts
+async function getAccountByL1Address(client, params) {
+  return client.get("/api/v1/accountsByL1Address", {
+    params
+  }).then((response) => response.data);
+}
+
+
+
+exports.getAccountByL1Address = getAccountByL1Address;

package/dist/chunk-3OSXAPI3.js

@@ -0,0 +1,8 @@
+// src/api/info/order-books.ts
+async function getOrderBooks(client) {
+  return client.get("/api/v1/orderBooks").then((response) => response.data);
+}
+
+export {
+  getOrderBooks
+};

package/dist/chunk-3R4OL3TU.cjs

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/api/exchange/notification-ack.ts
+async function acknowledgeNotification(client, params, authorization) {
+  const queryParams = {
+    notif_id: params.notif_id,
+    account_index: params.account_index.toString()
+  };
+  const headers = {};
+  if (authorization) {
+    headers["Authorization"] = authorization;
+    headers["auth"] = authorization;
+  }
+  return client.post("/api/v1/notification/ack", {}, { params: queryParams, headers }).then((response) => response.data);
+}
+
+
+
+exports.acknowledgeNotification = acknowledgeNotification;

package/dist/chunk-3Y76Q54G.js

@@ -0,0 +1,18 @@
+// src/api/info-private/transfer-history.ts
+async function getTransferHistory(client, params, authorization) {
+  const config = {
+    params: {
+      account_index: params.account_index,
+      ...params.cursor ? { cursor: params.cursor } : {},
+      ...params.auth ? { auth: params.auth } : {}
+    }
+  };
+  if (authorization) {
+    config.headers = { Authorization: authorization };
+  }
+  return client.get("/api/v1/transfer/history", config).then((response) => response.data);
+}
+
+export {
+  getTransferHistory
+};

package/dist/chunk-3ZIFHX7Q.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/chunk-467IJZRE.js

@@ -0,0 +1,14 @@
+// src/api/info-private/trades.ts
+async function getTrades(client, params, authorization) {
+  const config = {
+    params
+  };
+  if (authorization) {
+    config.headers = { Authorization: authorization };
+  }
+  return client.get("/api/v1/trades", config).then((response) => response.data);
+}
+
+export {
+  getTrades
+};

package/dist/chunk-472ULOSN.js

@@ -0,0 +1,10 @@
+// src/api/info/account.ts
+async function getAccountInfo(client, params) {
+  return client.get("/api/v1/account", {
+    params
+  }).then((response) => response.data);
+}
+
+export {
+  getAccountInfo
+};

package/dist/chunk-4LNJ2577.js

@@ -0,0 +1,17 @@
+// src/api/info-private/account-limits.ts
+async function getAccountLimits(client, params, authorization) {
+  const config = {
+    params: {
+      account_index: params.account_index,
+      ...params.auth ? { auth: params.auth } : {}
+    }
+  };
+  if (authorization) {
+    config.headers = { Authorization: authorization };
+  }
+  return client.get("/api/v1/accountLimits", config).then((response) => response.data);
+}
+
+export {
+  getAccountLimits
+};

package/dist/chunk-4MZ3XQUJ.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/api/info/next-nonce.ts
+async function getNextNonce(client, params) {
+  return client.get("/api/v1/nextNonce", {
+    params: {
+      account_index: params.account_index,
+      api_key_index: params.api_key_index
+    }
+  }).then((response) => response.data);
+}
+
+
+
+exports.getNextNonce = getNextNonce;

package/dist/chunk-4TIJW7PH.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/api/info-private/trades.ts
+async function getTrades(client, params, authorization) {
+  const config = {
+    params
+  };
+  if (authorization) {
+    config.headers = { Authorization: authorization };
+  }
+  return client.get("/api/v1/trades", config).then((response) => response.data);
+}
+
+
+
+exports.getTrades = getTrades;

package/dist/chunk-4VAZ7ZA2.js

@@ -0,0 +1,10 @@
+// src/api/info/account-by-l1-address.ts
+async function getAccountByL1Address(client, params) {
+  return client.get("/api/v1/accountsByL1Address", {
+    params
+  }).then((response) => response.data);
+}
+
+export {
+  getAccountByL1Address
+};

package/dist/chunk-5JDRAN7L.cjs

@@ -0,0 +1,22 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/api/exchange/fastwithdraw.ts
+async function fastWithdraw(client, params, authorization) {
+  const config = {
+    headers: {}
+  };
+  if (authorization) {
+    config.headers = { Authorization: authorization };
+  }
+  return client.post(
+    "/api/v1/fastwithdraw",
+    {
+      tx_info: params.tx_info,
+      to_address: params.to_address,
+      ...params.auth ? { auth: params.auth } : {}
+    },
+    config
+  ).then((response) => response.data);
+}
+
+
+
+exports.fastWithdraw = fastWithdraw;

package/dist/chunk-5P5CPB5A.js

@@ -0,0 +1,18 @@
+// src/api/info-private/account-metadata.ts
+async function getAccountMetadata(client, params, authorization) {
+  const config = {
+    params: {
+      by: params.by,
+      value: params.value,
+      ...params.auth ? { auth: params.auth } : {}
+    }
+  };
+  if (authorization) {
+    config.headers = { Authorization: authorization };
+  }
+  return client.get("/api/v1/accountMetadata", config).then((response) => response.data);
+}
+
+export {
+  getAccountMetadata
+};

package/dist/chunk-5U6X6DI7.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/api/info/asset-details.ts
+async function getAssetDetails(client, params) {
+  const config = {
+    params: {
+      ..._optionalChain([params, 'optionalAccess', _ => _.asset_index]) !== void 0 ? { asset_index: params.asset_index } : {}
+    }
+  };
+  return client.get("/api/v1/assetDetails", config).then((response) => response.data);
+}
+
+
+
+exports.getAssetDetails = getAssetDetails;

package/dist/chunk-5WEMEUUI.js

@@ -0,0 +1,22 @@
+// src/api/exchange/change-account-tier.ts
+async function changeAccountTier(client, params, authorization) {
+  const config = {
+    headers: {}
+  };
+  if (authorization) {
+    config.headers = { Authorization: authorization };
+  }
+  return client.post(
+    "/api/v1/changeAccountTier",
+    {
+      account_index: params.account_index,
+      new_tier: params.new_tier,
+      ...params.auth ? { auth: params.auth } : {}
+    },
+    config
+  ).then((response) => response.data);
+}
+
+export {
+  changeAccountTier
+};

package/dist/chunk-5YGIBBTZ.js

@@ -0,0 +1,357 @@
+// src/client/ws-client.ts
+var WsClient = class {
+  constructor(config) {
+    this.ws = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.isConnecting = false;
+    this.isConnected = false;
+    this.config = {
+      reconnectInterval: 5e3,
+      maxReconnectAttempts: 5,
+      ...config
+    };
+    this.url = this.config.url || "wss://mainnet.zklighter.elliot.ai/stream";
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      if (this.isConnecting || this.isConnected) {
+        resolve();
+        return;
+      }
+      this.isConnecting = true;
+      try {
+        this.ws = new WebSocket(this.url);
+        this.ws.onopen = () => {
+          this.isConnecting = false;
+          this.isConnected = true;
+          this.reconnectAttempts = 0;
+          this.config.onOpen?.();
+          this.resubscribeAll();
+          resolve();
+        };
+        this.ws.onmessage = (event) => {
+          try {
+            const message = JSON.parse(event.data);
+            this.config.onMessage?.(message);
+            this.handleSubscriptionMessage(message);
+          } catch (error) {
+          }
+        };
+        this.ws.onerror = (error) => {
+          this.isConnecting = false;
+          this.config.onError?.(new Error("WebSocket error"));
+          reject(new Error("WebSocket error"));
+        };
+        this.ws.onclose = () => {
+          this.isConnected = false;
+          this.config.onClose?.();
+          this.attemptReconnect();
+        };
+      } catch (error) {
+        console.error("WebSocket connection error:", error);
+        this.isConnecting = false;
+        reject(error);
+      }
+    });
+  }
+  disconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.isConnected = false;
+    this.isConnecting = false;
+  }
+  subscribe(subscription) {
+    if (!this.isConnected || !this.ws) {
+      throw new Error("WebSocket is not connected");
+    }
+    const message = {
+      type: "subscribe",
+      channel: subscription.channel
+    };
+    if (subscription.auth) {
+      message.auth = subscription.auth;
+    }
+    if (subscription.params) {
+      for (const [key, value] of Object.entries(subscription.params)) {
+        if (value !== void 0) {
+          message[key] = value;
+        }
+      }
+    }
+    const normalizedChannel = this.normalizeChannel(subscription.channel);
+    const storedSubscription = { ...subscription };
+    this.ws.send(JSON.stringify(message));
+    this.subscriptions.set(normalizedChannel, storedSubscription);
+  }
+  subscribeOrderBook(marketIndex, handler) {
+    this.subscribe({
+      channel: `order_book/${marketIndex}`,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeOrderBook(marketIndex) {
+    this.unsubscribe(`order_book/${marketIndex}`);
+  }
+  subscribeMarketStats(market, handler) {
+    const channel = `market_stats/${market}`;
+    this.subscribe({
+      channel,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeMarketStats(market) {
+    this.unsubscribe(`market_stats/${market}`);
+  }
+  subscribeSpotMarketStats(market, handler) {
+    const channel = `spot_market_stats/${market}`;
+    this.subscribe({
+      channel,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeSpotMarketStats(market) {
+    this.unsubscribe(`spot_market_stats/${market}`);
+  }
+  subscribeTrades(marketIndex, handler) {
+    this.subscribe({
+      channel: `trade/${marketIndex}`,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeTrades(marketIndex) {
+    this.unsubscribe(`trade/${marketIndex}`);
+  }
+  subscribeAccountAll(accountId, handler) {
+    this.subscribe({
+      channel: `account_all/${accountId}`,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountAll(accountId) {
+    this.unsubscribe(`account_all/${accountId}`);
+  }
+  subscribeAccountMarket(marketId, accountId, auth, handler) {
+    this.subscribe({
+      channel: `account_market/${marketId}/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountMarket(marketId, accountId) {
+    this.unsubscribe(`account_market/${marketId}/${accountId}`);
+  }
+  subscribeUserStats(accountId, handler) {
+    this.subscribe({
+      channel: `user_stats/${accountId}`,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeUserStats(accountId) {
+    this.unsubscribe(`user_stats/${accountId}`);
+  }
+  subscribeTransactions(handler) {
+    this.subscribe({
+      channel: "transaction",
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeTransactions() {
+    this.unsubscribe("transaction");
+  }
+  subscribeExecutedTransactions(handler) {
+    this.subscribe({
+      channel: "executed_transaction",
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeExecutedTransactions() {
+    this.unsubscribe("executed_transaction");
+  }
+  subscribeAccountTransactions(accountId, auth, handler) {
+    this.subscribe({
+      channel: `account_tx/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountTransactions(accountId) {
+    this.unsubscribe(`account_tx/${accountId}`);
+  }
+  subscribeAccountAllOrders(accountId, auth, handler) {
+    this.subscribe({
+      channel: `account_all_orders/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountAllOrders(accountId) {
+    this.unsubscribe(`account_all_orders/${accountId}`);
+  }
+  subscribeHeight(handler) {
+    this.subscribe({
+      channel: "height",
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeHeight() {
+    this.unsubscribe("height");
+  }
+  subscribePoolData(accountId, auth, handler) {
+    this.subscribe({
+      channel: `pool_data/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribePoolData(accountId) {
+    this.unsubscribe(`pool_data/${accountId}`);
+  }
+  subscribePoolInfo(accountId, auth, handler) {
+    this.subscribe({
+      channel: `pool_info/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribePoolInfo(accountId) {
+    this.unsubscribe(`pool_info/${accountId}`);
+  }
+  subscribeNotifications(accountId, auth, handler) {
+    this.subscribe({
+      channel: `notification/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeNotifications(accountId) {
+    this.unsubscribe(`notification/${accountId}`);
+  }
+  subscribeAccountOrders(marketIndex, accountId, auth, handler) {
+    this.subscribe({
+      channel: `account_orders/${marketIndex}/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountOrders(marketIndex, accountId) {
+    this.unsubscribe(`account_orders/${marketIndex}/${accountId}`);
+  }
+  subscribeAccountAllTrades(accountId, auth, handler) {
+    this.subscribe({
+      channel: `account_all_trades/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountAllTrades(accountId) {
+    this.unsubscribe(`account_all_trades/${accountId}`);
+  }
+  subscribeAccountAllPositions(accountId, auth, handler) {
+    this.subscribe({
+      channel: `account_all_positions/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountAllPositions(accountId) {
+    this.unsubscribe(`account_all_positions/${accountId}`);
+  }
+  unsubscribe(channel) {
+    if (!this.isConnected || !this.ws) {
+      throw new Error("WebSocket is not connected");
+    }
+    const message = {
+      type: "unsubscribe",
+      channel
+    };
+    this.ws.send(JSON.stringify(message));
+    this.subscriptions.delete(this.normalizeChannel(channel));
+  }
+  send(message) {
+    if (!this.isConnected || !this.ws) {
+      throw new Error("WebSocket is not connected");
+    }
+    this.ws.send(JSON.stringify(message));
+  }
+  normalizeChannel(channel) {
+    return channel.replace(/:/g, "/");
+  }
+  passthroughParser() {
+    return (payload) => payload;
+  }
+  handleSubscriptionMessage(rawMessage) {
+    if (!rawMessage || typeof rawMessage !== "object") {
+      return;
+    }
+    const channelName = typeof rawMessage.channel === "string" ? rawMessage.channel : void 0;
+    if (!channelName) {
+      return;
+    }
+    const normalizedChannel = this.normalizeChannel(channelName);
+    const subscription = this.subscriptions.get(normalizedChannel);
+    if (!subscription || typeof subscription.handler !== "function") {
+      return;
+    }
+    try {
+      const parser = typeof subscription.parser === "function" ? subscription.parser : (payload) => payload;
+      const parsed = parser(rawMessage);
+      subscription.handler(parsed);
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      this.config.onError?.(normalizedError);
+    }
+  }
+  attemptReconnect() {
+    if (this.reconnectAttempts >= (this.config.maxReconnectAttempts || 5)) {
+      return;
+    }
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this.connect().catch(() => {
+        this.attemptReconnect();
+      });
+    }, this.config.reconnectInterval || 5e3);
+  }
+  resubscribeAll() {
+    const subscriptions = Array.from(this.subscriptions.values());
+    for (const subscription of subscriptions) {
+      this.subscribe(subscription);
+    }
+  }
+  isConnectedToWebSocket() {
+    return this.isConnected;
+  }
+  getSubscriptions() {
+    return Array.from(this.subscriptions.values());
+  }
+};
+
+export {
+  WsClient
+};