lighter-sdk-client 0.2.11

package/dist/chunk-L5SDFTHR.cjs

@@ -0,0 +1,242 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/client/l1-bridge-client.ts
+var _viem = require('viem');
+var _accounts = require('viem/accounts');
+var USDC_ABI = [
+  {
+    name: "transfer",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "decimals",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint8" }]
+  },
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ type: "uint256" }]
+  }
+];
+var BRIDGE_ABI = [
+  {
+    name: "deposit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "l2AccountIndex", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "depositTo",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "l2AccountIndex", type: "uint256" },
+      { name: "to", type: "address" }
+    ],
+    outputs: []
+  }
+];
+var L1BridgeClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Deposit USDC from L1 to L2
+   * @param params - Deposit parameters
+   * @returns Promise<L1DepositResult>
+   */
+  async depositToL2(params) {
+    const account = _accounts.privateKeyToAccount.call(void 0, params.ethPrivateKey);
+    const publicClient = _viem.createPublicClient.call(void 0, {
+      chain: { id: this.config.chainId },
+      transport: _viem.http.call(void 0, this.config.rpcUrl)
+    });
+    const walletClient = _viem.createWalletClient.call(void 0, {
+      account,
+      chain: { id: this.config.chainId },
+      transport: _viem.http.call(void 0, this.config.rpcUrl)
+    });
+    const usdcContract = _viem.getContract.call(void 0, {
+      address: this.config.usdcContract,
+      abi: USDC_ABI,
+      client: { public: publicClient, wallet: walletClient }
+    });
+    const bridgeContract = _viem.getContract.call(void 0, {
+      address: this.config.l1BridgeContract,
+      abi: BRIDGE_ABI,
+      client: { public: publicClient, wallet: walletClient }
+    });
+    const decimals = await usdcContract.read.decimals();
+    const amountInUnits = _viem.parseUnits.call(void 0, params.usdcAmount.toString(), decimals);
+    const balance = await usdcContract.read.balanceOf([account.address]);
+    if (balance < amountInUnits) {
+      throw new Error(`Insufficient USDC balance. Required: ${_viem.formatUnits.call(void 0, amountInUnits, decimals)}, Available: ${_viem.formatUnits.call(void 0, balance, decimals)}`);
+    }
+    const allowance = await usdcContract.read.allowance([account.address, this.config.l1BridgeContract]);
+    if (allowance < amountInUnits) {
+      const approveHash = await usdcContract.write.approve([this.config.l1BridgeContract, amountInUnits], {
+        gasPrice: params.gasPrice ? _viem.parseUnits.call(void 0, params.gasPrice, 9) : void 0,
+        gas: params.gasLimit ? BigInt(params.gasLimit) : void 0
+      });
+      await publicClient.waitForTransactionReceipt({ hash: approveHash });
+    }
+    const depositHash = await bridgeContract.write.deposit([amountInUnits, BigInt(params.l2AccountIndex)], {
+      gasPrice: params.gasPrice ? _viem.parseUnits.call(void 0, params.gasPrice, 9) : void 0,
+      gas: params.gasLimit ? BigInt(params.gasLimit) : void 0
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({ hash: depositHash });
+    if (!receipt) {
+      throw new Error("Transaction receipt not found");
+    }
+    return {
+      l1TxHash: depositHash,
+      l2AccountIndex: params.l2AccountIndex,
+      amount: _viem.formatUnits.call(void 0, amountInUnits, decimals),
+      status: receipt.status === "success" ? "completed" : "failed",
+      blockNumber: Number(receipt.blockNumber),
+      gasUsed: receipt.gasUsed.toString()
+    };
+  }
+  /**
+   * Check USDC balance for an address
+   * @param address - Ethereum address
+   * @returns Promise<string> - Balance in USDC units
+   */
+  async getUSDCBalance(address) {
+    const publicClient = _viem.createPublicClient.call(void 0, {
+      chain: { id: this.config.chainId },
+      transport: _viem.http.call(void 0, this.config.rpcUrl)
+    });
+    const usdcContract = _viem.getContract.call(void 0, {
+      address: this.config.usdcContract,
+      abi: USDC_ABI,
+      client: publicClient
+    });
+    const balance = await usdcContract.read.balanceOf([address]);
+    const decimals = await usdcContract.read.decimals();
+    return _viem.formatUnits.call(void 0, balance, decimals);
+  }
+  /**
+   * Check USDC allowance for bridge contract
+   * @param address - Ethereum address
+   * @returns Promise<string> - Allowance in USDC units
+   */
+  async getUSDCAllowance(address) {
+    const publicClient = _viem.createPublicClient.call(void 0, {
+      chain: { id: this.config.chainId },
+      transport: _viem.http.call(void 0, this.config.rpcUrl)
+    });
+    const usdcContract = _viem.getContract.call(void 0, {
+      address: this.config.usdcContract,
+      abi: USDC_ABI,
+      client: publicClient
+    });
+    const allowance = await usdcContract.read.allowance([address, this.config.l1BridgeContract]);
+    const decimals = await usdcContract.read.decimals();
+    return _viem.formatUnits.call(void 0, allowance, decimals);
+  }
+  /**
+   * Get transaction status
+   * @param txHash - Transaction hash
+   * @returns Promise<L1DepositResult>
+   */
+  async getTransactionStatus(txHash) {
+    const publicClient = _viem.createPublicClient.call(void 0, {
+      chain: { id: this.config.chainId },
+      transport: _viem.http.call(void 0, this.config.rpcUrl)
+    });
+    const tx = await publicClient.getTransaction({ hash: txHash });
+    const receipt = await publicClient.getTransactionReceipt({ hash: txHash }).catch(() => null);
+    if (!tx) {
+      throw new Error("Transaction not found");
+    }
+    if (!receipt) {
+      return {
+        l1TxHash: txHash,
+        l2AccountIndex: 0,
+        // Will be updated when transaction is parsed
+        amount: "0",
+        status: "pending"
+      };
+    }
+    const amount = "0";
+    const l2AccountIndex = 0;
+    return {
+      l1TxHash: txHash,
+      l2AccountIndex,
+      amount,
+      status: receipt.status === "success" ? "completed" : "failed",
+      blockNumber: Number(receipt.blockNumber),
+      gasUsed: receipt.gasUsed.toString()
+    };
+  }
+  /**
+   * Get default bridge configuration for mainnet
+   * @returns L1BridgeConfig
+   */
+  static getMainnetConfig() {
+    return {
+      l1BridgeContract: "0x0000000000000000000000000000000000000000",
+      // Replace with actual bridge contract
+      usdcContract: "0xA0b86a33E6441b8c4C8C0E4A8c4c4c4c4c4c4c4c4",
+      // Replace with actual USDC contract
+      rpcUrl: "https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY",
+      // Replace with actual RPC URL
+      chainId: 1
+    };
+  }
+  /**
+   * Get default bridge configuration for testnet
+   * @returns L1BridgeConfig
+   */
+  static getTestnetConfig() {
+    return {
+      l1BridgeContract: "0x0000000000000000000000000000000000000000",
+      // Replace with actual testnet bridge contract
+      usdcContract: "0x0000000000000000000000000000000000000000",
+      // Replace with actual testnet USDC contract
+      rpcUrl: "https://eth-sepolia.g.alchemy.com/v2/YOUR_API_KEY",
+      // Replace with actual testnet RPC URL
+      chainId: 11155111
+      // Sepolia testnet
+    };
+  }
+};
+
+
+
+exports.L1BridgeClient = L1BridgeClient;

package/dist/chunk-LBVNEQ5R.cjs

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/api/info-private/position-funding.ts
+async function getPositionFunding(client, params, authorization) {
+  const config = {
+    params: {
+      account_index: params.account_index,
+      limit: params.limit,
+      ...params.market_id !== void 0 ? { market_id: params.market_id } : {},
+      ...params.cursor ? { cursor: params.cursor } : {},
+      ...params.side ? { side: params.side } : {},
+      ...params.auth ? { auth: params.auth } : {}
+    }
+  };
+  if (authorization) {
+    config.headers = { Authorization: authorization };
+  }
+  return client.get("/api/v1/positionFunding", config).then((response) => response.data);
+}
+
+
+
+exports.getPositionFunding = getPositionFunding;

package/dist/chunk-LYNZNSLV.js

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

package/dist/chunk-MAPH47LH.cjs

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

package/dist/chunk-MOMFTZ7N.cjs

@@ -0,0 +1,357 @@
+"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/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;
+          _optionalChain([this, 'access', _ => _.config, 'access', _2 => _2.onOpen, 'optionalCall', _3 => _3()]);
+          this.resubscribeAll();
+          resolve();
+        };
+        this.ws.onmessage = (event) => {
+          try {
+            const message = JSON.parse(event.data);
+            _optionalChain([this, 'access', _4 => _4.config, 'access', _5 => _5.onMessage, 'optionalCall', _6 => _6(message)]);
+            this.handleSubscriptionMessage(message);
+          } catch (error) {
+          }
+        };
+        this.ws.onerror = (error) => {
+          this.isConnecting = false;
+          _optionalChain([this, 'access', _7 => _7.config, 'access', _8 => _8.onError, 'optionalCall', _9 => _9(new Error("WebSocket error"))]);
+          reject(new Error("WebSocket error"));
+        };
+        this.ws.onclose = () => {
+          this.isConnected = false;
+          _optionalChain([this, 'access', _10 => _10.config, 'access', _11 => _11.onClose, 'optionalCall', _12 => _12()]);
+          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));
+      _optionalChain([this, 'access', _13 => _13.config, 'access', _14 => _14.onError, 'optionalCall', _15 => _15(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());
+  }
+};
+
+
+
+exports.WsClient = WsClient;

package/dist/chunk-MZCKU6FF.js

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

package/dist/chunk-NIMYOIVU.cjs

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

package/dist/chunk-NIT6TCVS.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/api/info/candles.ts
+async function getCandlesticks(client, params) {
+  return client.get("/api/v1/candles", { params }).then((response) => response.data);
+}
+
+
+
+exports.getCandlesticks = getCandlesticks;

package/dist/chunk-NOFXPTLU.js

@@ -0,0 +1,8 @@
+// src/api/info/root-status.ts
+async function getRootStatus(client) {
+  return client.get("/").then((response) => response.data);
+}
+
+export {
+  getRootStatus
+};

package/dist/chunk-NRZGE42C.js

@@ -0,0 +1,23 @@
+// src/api/info-private/pnl.ts
+async function getPnL(client, params, authorization) {
+  const config = {
+    params: {
+      by: params.by,
+      value: params.value,
+      resolution: params.resolution,
+      start_timestamp: params.start_timestamp,
+      end_timestamp: params.end_timestamp,
+      count_back: params.count_back,
+      ...params.auth ? { auth: params.auth } : {},
+      ...params.ignore_transfers !== void 0 ? { ignore_transfers: params.ignore_transfers } : {}
+    }
+  };
+  if (authorization) {
+    config.headers = { Authorization: authorization };
+  }
+  return client.get("/api/v1/pnl", config).then((response) => response.data);
+}
+
+export {
+  getPnL
+};