lighter-sdk-client 0.2.11

package/dist/chunk-62KDFQ7D.js

@@ -0,0 +1,367 @@
+import {
+  getTrades
+} from "./chunk-467IJZRE.js";
+import {
+  getTransferFeeInfo
+} from "./chunk-LYNZNSLV.js";
+import {
+  getTransferHistory
+} from "./chunk-3Y76Q54G.js";
+import {
+  getWithdrawHistory
+} from "./chunk-PEALQBVN.js";
+import {
+  getL1Metadata
+} from "./chunk-QXGO7TJ2.js";
+import {
+  getLiquidations
+} from "./chunk-RGVFMOQI.js";
+import {
+  getPnL
+} from "./chunk-NRZGE42C.js";
+import {
+  getPositionFunding
+} from "./chunk-TPGO4YD3.js";
+import {
+  getPublicPools
+} from "./chunk-O3PA6HV2.js";
+import {
+  getReferralPoints
+} from "./chunk-W5VY4TWP.js";
+import {
+  getTokens
+} from "./chunk-OPSCTD6W.js";
+import {
+  getAccountActiveOrders
+} from "./chunk-AMNDQGYL.js";
+import {
+  getAccountInactiveOrders
+} from "./chunk-XQGOXCT4.js";
+import {
+  getAccountLimits
+} from "./chunk-4LNJ2577.js";
+import {
+  getAccountMetadata
+} from "./chunk-5P5CPB5A.js";
+import {
+  getDepositHistory
+} from "./chunk-P32EPCEM.js";
+import {
+  getExport
+} from "./chunk-EBSW5ZYW.js";
+import {
+  getFastWithdrawInfo
+} from "./chunk-ZDNQFOED.js";
+
+// src/client/info-private-client.ts
+import axios from "axios";
+var DEFAULT_DEADLINE = 120;
+var InfoPrivateClient = class {
+  constructor(config) {
+    this.baseURL = config.baseURL || "https://mainnet.zklighter.elliot.ai";
+    this.wasmSigner = config.wasmSigner;
+    this.axiosInstance = this.createAxiosInstance();
+  }
+  createAxiosInstance() {
+    return axios.create({
+      baseURL: this.baseURL
+    });
+  }
+  /**
+   * Get active orders for an account in a specific market
+   * @param params - Account index and market ID to retrieve active orders for
+   * @returns List of active orders
+   * @example
+   * ```typescript
+   * const orders = await client.getAccountActiveOrders({
+   *   account_index: 0,
+   *   market_id: 1
+   * });
+   * ```
+   */
+  async getAccountActiveOrders(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getAccountActiveOrders(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get inactive orders for an account
+   * @param params - Account index and optional filters for inactive orders
+   * @returns List of inactive orders with pagination support
+   * @example
+   * ```typescript
+   * const orders = await client.getAccountInactiveOrders({
+   *   account_index: 0,
+   *   limit: 50,
+   *   market_id: 1
+   * });
+   * ```
+   */
+  async getAccountInactiveOrders(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getAccountInactiveOrders(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get account limits and tier information
+   * @param params - Account index to retrieve limits for
+   * @returns Account limits including max LLP percentage, user tier, and pool creation permissions
+   * @example
+   * ```typescript
+   * const limits = await client.getAccountLimits({ account_index: 0 });
+   * ```
+   */
+  async getAccountLimits(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getAccountLimits(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get account metadata by index or L1 address
+   * @param params - Account lookup parameters (by index or L1 address)
+   * @returns Account metadata including name, description, and referral information
+   * @example
+   * ```typescript
+   * const metadata = await client.getAccountMetadata({
+   *   by: "index",
+   *   value: "0"
+   * });
+   * ```
+   */
+  async getAccountMetadata(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getAccountMetadata(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get L1 metadata for an address
+   * @param params - L1 address to retrieve metadata for
+   * @returns L1 metadata including referral information
+   * @example
+   * ```typescript
+   * const l1Metadata = await client.getL1Metadata({
+   *   l1_address: "0x..."
+   * });
+   * ```
+   */
+  async getL1Metadata(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getL1Metadata(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get API tokens for an account
+   * @param params - Account index to retrieve API tokens for
+   * @returns List of API tokens with details including name, expiry, scopes, and status
+   * @example
+   * ```typescript
+   * const tokens = await client.getTokens({ account_index: 0 });
+   * ```
+   */
+  async getTokens(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getTokens(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get deposit history for an account
+   * @param params - Account index, L1 address, and optional filters
+   * @returns List of deposits with status and timestamps
+   * @example
+   * ```typescript
+   * const deposits = await client.getDepositHistory({
+   *   account_index: 0,
+   *   l1_address: "0x...",
+   *   filter: "pending"
+   * });
+   * ```
+   */
+  async getDepositHistory(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getDepositHistory(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get withdrawal history for an account
+   * @param params - Account index, L1 address, and optional filters
+   * @returns List of withdrawals with status and timestamps
+   * @example
+   * ```typescript
+   * const withdrawals = await client.getWithdrawHistory({
+   *   account_index: 0,
+   *   l1_address: "0x...",
+   *   filter: "completed"
+   * });
+   * ```
+   */
+  async getWithdrawHistory(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getWithdrawHistory(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get fast withdraw information for an account
+   * @param params - Account index to retrieve fast withdraw info for
+   * @returns Fast withdraw limits and account information
+   * @example
+   * ```typescript
+   * const fastWithdrawInfo = await client.getFastWithdrawInfo({
+   *   account_index: 0
+   * });
+   * ```
+   */
+  async getFastWithdrawInfo(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getFastWithdrawInfo(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get transfer fee information between accounts
+   * @param params - Account indices to calculate transfer fee for
+   * @returns Transfer fee in USDC
+   * @example
+   * ```typescript
+   * const feeInfo = await client.getTransferFeeInfo({
+   *   account_index: 0,
+   *   to_account_index: 1
+   * });
+   * ```
+   */
+  async getTransferFeeInfo(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getTransferFeeInfo(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get transfer history for an account
+   * @param params - Account index and optional cursor for pagination
+   * @returns Transfer history with pagination support
+   * @example
+   * ```typescript
+   * const transfers = await client.getTransferHistory({
+   *   account_index: 0,
+   *   cursor: 'optional-cursor-for-pagination'
+   * });
+   * ```
+   */
+  async getTransferHistory(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getTransferHistory(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get liquidation history for an account
+   * @param params - Account index, limit, and optional market/cursor filters
+   * @returns List of liquidations with pagination support
+   * @example
+   * ```typescript
+   * const liquidations = await client.getLiquidations({
+   *   account_index: 0,
+   *   limit: 50,
+   *   market_id: 1
+   * });
+   * ```
+   */
+  async getLiquidations(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getLiquidations(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get profit and loss data for an account or market
+   * @param params - PnL query parameters including resolution, time range, and account/market filters
+   * @returns PnL entries with timestamp, pnl, and cumulative pnl
+   * @example
+   * ```typescript
+   * const pnl = await client.getPnL({
+   *   by: "account_index",
+   *   value: "0",
+   *   resolution: "1d",
+   *   start_timestamp: 1234567890,
+   *   end_timestamp: 1234567900,
+   *   count_back: 30
+   * });
+   * ```
+   */
+  async getPnL(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getPnL(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get position funding history for an account
+   * @param params - Position funding query parameters including account_index, limit, and optional filters
+   * @returns Position funding entries with timestamp, funding rate, and position details
+   * @example
+   * ```typescript
+   * const funding = await client.getPositionFunding({
+   *   account_index: 0,
+   *   limit: 50,
+   *   market_id: 1,
+   *   side: "long"
+   * });
+   * ```
+   */
+  async getPositionFunding(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getPositionFunding(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get public liquidity pools metadata
+   * @param params - Optional filters for pool queries (filter, limit, index)
+   * @returns List of public pools with TVL, APY, and share information
+   * @example
+   * ```typescript
+   * const pools = await client.getPublicPools({
+   *   filter: "all",
+   *   limit: 10,
+   *   index: 0
+   * });
+   * ```
+   */
+  async getPublicPools(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getPublicPools(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get referral points for an account
+   * @param params - Account index to retrieve referral points for
+   * @returns Referral points data including user points and referral list
+   * @example
+   * ```typescript
+   * const points = await client.getReferralPoints({ account_index: 0 });
+   * ```
+   */
+  async getReferralPoints(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getReferralPoints(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Get trades for an account or market
+   * @param params - Trade query parameters including sort_by, limit, and optional filters
+   * @returns List of trades with details including price, size, side, and timestamps
+   * @example
+   * ```typescript
+   * const trades = await client.getTrades({
+   *   sort_by: 'timestamp',
+   *   limit: 50,
+   *   account_index: 0,
+   *   market_id: 1,
+   *   sort_dir: 'desc'
+   * });
+   * ```
+   */
+  async getTrades(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getTrades(this.axiosInstance, params, auth.authToken);
+  }
+  /**
+   * Export data (funding or trade data) for an account
+   * @param params - Export parameters including type (funding or trade) and optional filters
+   * @returns Export response with data URL for downloading the export
+   * @example
+   * ```typescript
+   * const exportData = await client.getExport({
+   *   type: 'trade',
+   *   account_index: 0,
+   *   market_id: 1
+   * });
+   * console.log('Download URL:', exportData.data_url);
+   * ```
+   */
+  async getExport(params) {
+    const auth = this.wasmSigner.createAuthToken(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE);
+    return getExport(this.axiosInstance, params, auth.authToken);
+  }
+};
+
+export {
+  InfoPrivateClient
+};

package/dist/chunk-6CD3YMMG.cjs

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

package/dist/chunk-6GCE6YQR.cjs

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

package/dist/chunk-6LUEPRL7.cjs

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

package/dist/chunk-76SPKVHT.js

@@ -0,0 +1,48 @@
+// src/api/exchange/send-tx.ts
+async function sendTransaction(client, params) {
+  return client.post("/api/v1/sendTx", {
+    account_index: params.account_index,
+    api_key_index: params.api_key_index,
+    transaction: params.transaction,
+    ...params.price_protection !== void 0 ? { price_protection: params.price_protection } : {}
+  }).then((response) => response.data);
+}
+async function sendTx(client, params) {
+  const urlParams = new URLSearchParams();
+  urlParams.append("tx_type", params.tx_type.toString());
+  urlParams.append("tx_info", params.tx_info);
+  urlParams.append("price_protection", params.price_protection !== false ? "true" : "false");
+  return client.post("/api/v1/sendTx", urlParams, {
+    headers: { "Content-Type": "application/x-www-form-urlencoded" }
+  }).then((response) => response.data);
+}
+async function sendTxWithIndices(client, params) {
+  const urlParams = new URLSearchParams();
+  urlParams.append("tx_type", params.tx_type.toString());
+  urlParams.append("tx_info", params.tx_info);
+  urlParams.append("account_index", params.account_index.toString());
+  urlParams.append("api_key_index", params.api_key_index.toString());
+  urlParams.append("price_protection", params.price_protection !== false ? "true" : "false");
+  return client.post("/api/v1/sendTx", urlParams, {
+    headers: { "Content-Type": "application/x-www-form-urlencoded" }
+  }).then((response) => response.data);
+}
+async function sendTxJson(client, params) {
+  const payload = {
+    tx_type: params.tx_type,
+    tx_info: params.tx_info,
+    account_index: params.account_index,
+    api_key_index: params.api_key_index,
+    price_protection: params.price_protection !== false
+  };
+  return client.post("/api/v1/sendTx", payload, {
+    headers: { "Content-Type": "application/json" }
+  }).then((response) => response.data);
+}
+
+export {
+  sendTransaction,
+  sendTx,
+  sendTxWithIndices,
+  sendTxJson
+};

package/dist/chunk-77QSYYAW.js

@@ -0,0 +1,13 @@
+// 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);
+}
+
+export {
+  getNextNonce
+};

package/dist/chunk-7U2USLAM.cjs

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

package/dist/chunk-A2APDMN3.js

@@ -0,0 +1,13 @@
+// src/api/info/asset-details.ts
+async function getAssetDetails(client, params) {
+  const config = {
+    params: {
+      ...params?.asset_index !== void 0 ? { asset_index: params.asset_index } : {}
+    }
+  };
+  return client.get("/api/v1/assetDetails", config).then((response) => response.data);
+}
+
+export {
+  getAssetDetails
+};

package/dist/chunk-AKEQDKGA.js

@@ -0,0 +1,167 @@
+// src/signing/wasm-signer.ts
+var WasmSigner = class {
+  constructor(config) {
+    this.apiKeyIndex = 0;
+    this.accountIndex = 0;
+    this.privateKey = "";
+    this.url = config?.url || "https://mainnet.zklighter.elliot.ai";
+    this.chainId = config?.chainId || 304;
+    this.wasmPath = config?.wasmPath || "/wasm/lighter-signer.wasm";
+    this.wasmExecPath = config?.wasmExecPath || "/wasm/lighter-wasm-exec.js";
+  }
+  async initialize() {
+    await this.loadScript(this.wasmExecPath);
+    const wasmBytes = await this.loadWasm(this.wasmPath);
+    const Go = window.Go;
+    const go = new Go();
+    const result = await WebAssembly.instantiate(wasmBytes, go.importObject);
+    go.run(result.instance);
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+  }
+  generateAPIKey(seed) {
+    if (!window.GenerateAPIKey) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.GenerateAPIKey(seed);
+  }
+  setAccount(privateKey, apiKeyIndex, accountIndex) {
+    this.privateKey = privateKey;
+    this.apiKeyIndex = apiKeyIndex;
+    this.accountIndex = accountIndex;
+  }
+  getAccount() {
+    return {
+      privateKey: this.privateKey,
+      apiKeyIndex: this.apiKeyIndex,
+      accountIndex: this.accountIndex
+    };
+  }
+  createClient() {
+    if (!window.CreateClient) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.CreateClient(this.url, this.privateKey, this.chainId, this.apiKeyIndex, this.accountIndex);
+  }
+  checkClient() {
+    if (!window.CheckClient) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.CheckClient(this.apiKeyIndex, this.accountIndex);
+  }
+  createAuthToken(deadline) {
+    if (!window.CreateAuthToken) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.CreateAuthToken(deadline, this.apiKeyIndex, this.accountIndex);
+  }
+  signChangePubKey(pubKeyHex, nonce) {
+    if (!window.SignChangePubKey) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignChangePubKey(pubKeyHex, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signCreateOrder(marketIndex, clientOrderIndex, baseAmount, price, isAsk, orderType, timeInForce, reduceOnly, triggerPrice, orderExpiry, nonce) {
+    if (!window.SignCreateOrder) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignCreateOrder(marketIndex, clientOrderIndex, baseAmount, price, isAsk, orderType, timeInForce, reduceOnly, triggerPrice, orderExpiry, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signCancelOrder(marketIndex, orderIndex, nonce) {
+    if (!window.SignCancelOrder) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignCancelOrder(marketIndex, orderIndex, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signCancelAllOrders(timeInForce, time, nonce) {
+    if (!window.SignCancelAllOrders) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignCancelAllOrders(timeInForce, time, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signTransfer(toAccount, usdcAmount, fee, memo, nonce) {
+    if (!window.SignTransfer) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignTransfer(toAccount, usdcAmount, fee, memo, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signWithdraw(usdcAmount, nonce) {
+    if (!window.SignWithdraw) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignWithdraw(usdcAmount, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signUpdateLeverage(marketIndex, fraction, marginMode, nonce) {
+    if (!window.SignUpdateLeverage) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignUpdateLeverage(marketIndex, fraction, marginMode, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signModifyOrder(marketIndex, index, baseAmount, price, triggerPrice, nonce) {
+    if (!window.SignModifyOrder) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignModifyOrder(marketIndex, index, baseAmount, price, triggerPrice, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signCreateSubAccount(nonce) {
+    if (!window.SignCreateSubAccount) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignCreateSubAccount(nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signCreatePublicPool(operatorFee, initialTotalShares, minOperatorShareRate, nonce) {
+    if (!window.SignCreatePublicPool) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignCreatePublicPool(operatorFee, initialTotalShares, minOperatorShareRate, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signUpdatePublicPool(publicPoolIndex, status, operatorFee, minOperatorShareRate, nonce) {
+    if (!window.SignUpdatePublicPool) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignUpdatePublicPool(publicPoolIndex, status, operatorFee, minOperatorShareRate, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signMintShares(publicPoolIndex, shareAmount, nonce) {
+    if (!window.SignMintShares) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignMintShares(publicPoolIndex, shareAmount, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signBurnShares(publicPoolIndex, shareAmount, nonce) {
+    if (!window.SignBurnShares) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignBurnShares(publicPoolIndex, shareAmount, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signUpdateMargin(marketIndex, usdcAmount, direction, nonce) {
+    if (!window.SignUpdateMargin) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignUpdateMargin(marketIndex, usdcAmount, direction, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  signCreateGroupedOrders(groupingType, orders, nonce) {
+    if (!window.SignCreateGroupedOrders) {
+      throw new Error("WASM not initialized. Call initialize() first.");
+    }
+    return window.SignCreateGroupedOrders(groupingType, orders, nonce, this.apiKeyIndex, this.accountIndex);
+  }
+  async loadScript(src) {
+    return new Promise((resolve, reject) => {
+      const script = document.createElement("script");
+      script.src = src;
+      script.onload = () => resolve();
+      script.onerror = () => reject(new Error(`Failed to load script: ${src}`));
+      document.head.appendChild(script);
+    });
+  }
+  async loadWasm(path) {
+    const response = await fetch(path);
+    if (!response.ok) {
+      throw new Error(`Failed to load WASM binary: ${response.statusText}`);
+    }
+    return response.arrayBuffer();
+  }
+};
+
+export {
+  WasmSigner
+};

package/dist/chunk-AMNDQGYL.js

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

package/dist/chunk-BA2QFD27.cjs

@@ -0,0 +1,19 @@
+"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/order-book-details.ts
+async function getOrderBookDetails(client, params) {
+  return client.get("/api/v1/orderBookDetails", {
+    params: _optionalChain([params, 'optionalAccess', _ => _.market_id]) !== void 0 ? { market_id: params.market_id } : void 0
+  }).then((response) => response.data);
+}
+async function getOrderBookOrders(client, params) {
+  return client.get("/api/v1/orderBookOrders", {
+    params: {
+      market_id: params.market_id,
+      ...params.limit !== void 0 ? { limit: params.limit } : {}
+    }
+  }).then((response) => response.data);
+}
+
+
+
+
+exports.getOrderBookDetails = getOrderBookDetails; exports.getOrderBookOrders = getOrderBookOrders;