lighter-sdk-client 0.2.11

package/dist/chunk-KV6G2ZCR.js

@@ -0,0 +1,539 @@
+import {
+  sendTransactionBatch
+} from "./chunk-JNTYHWDJ.js";
+import {
+  sendTransaction,
+  sendTx,
+  sendTxJson,
+  sendTxWithIndices
+} from "./chunk-76SPKVHT.js";
+import {
+  createToken
+} from "./chunk-VW77SNCY.js";
+import {
+  revokeToken
+} from "./chunk-UORSMHI2.js";
+import {
+  changeAccountTier
+} from "./chunk-5WEMEUUI.js";
+import {
+  fastWithdraw
+} from "./chunk-SA6CXVP6.js";
+import {
+  acknowledgeNotification
+} from "./chunk-FJJWUBKM.js";
+
+// src/client/exchange-client.ts
+import axios from "axios";
+var ExchangeClient = class {
+  constructor(config) {
+    this.baseURL = config?.baseURL || "https://mainnet.zklighter.elliot.ai";
+    this.wasmSigning = config.wasmSigner;
+    this.axiosInstance = this.createAxiosInstance();
+  }
+  createAxiosInstance() {
+    return axios.create({
+      baseURL: this.baseURL
+    });
+  }
+  /**
+   * Send a transaction
+   * @param params - Transaction parameters
+   * @returns Promise<TxHashResponse>
+   */
+  async sendTransaction(params) {
+    return sendTransaction(this.axiosInstance, params);
+  }
+  /**
+   * Send a transaction with form data
+   * @param params - Transaction form parameters
+   * @returns Promise<TxHashResponse>
+   */
+  async sendTx(params) {
+    return sendTx(this.axiosInstance, params);
+  }
+  /**
+   * Send a transaction with account and API key indices
+   * @param params - Transaction parameters with indices
+   * @returns Promise<TxHashResponse>
+   */
+  async sendTxWithIndices(params) {
+    return sendTxWithIndices(this.axiosInstance, params);
+  }
+  /**
+   * Send a transaction with JSON payload
+   * @param params - Transaction parameters
+   * @returns Promise<TxHashResponse>
+   */
+  async sendTxJson(params) {
+    return sendTxJson(this.axiosInstance, params);
+  }
+  /**
+   * Send a batch of transactions
+   * @param params - Batch transaction parameters
+   * @returns Promise<TxHashesResponse>
+   */
+  async sendTransactionBatch(params) {
+    return sendTransactionBatch(this.axiosInstance, params);
+  }
+  /**
+   * Create and send an order using WASM signing
+   * @param params - Order parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async createOrder(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signCreateOrder(
+      params.marketIndex,
+      params.clientOrderIndex,
+      params.baseAmount,
+      params.price,
+      params.isAsk,
+      params.orderType,
+      params.timeInForce,
+      params.reduceOnly,
+      params.triggerPrice,
+      params.orderExpiry,
+      params.nonce
+    );
+    if (txResponse.error) {
+      throw new Error(`Failed to sign order: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Cancel an order using WASM signing
+   * @param params - Cancel order parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async cancelOrder(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signCancelOrder(params.marketIndex, params.orderIndex, params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign cancel order: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Cancel all orders using WASM signing
+   * @param params - Cancel all orders parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async cancelAllOrders(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signCancelAllOrders(params.timeInForce, params.time, params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign cancel all orders: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Transfer funds using WASM signing
+   * @param params - Transfer parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async transfer(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signTransfer(params.toAccount, params.usdcAmount, params.fee, params.memo, params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign transfer: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Withdraw funds using WASM signing
+   * @param params - Withdraw parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async withdraw(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signWithdraw(params.usdcAmount, params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign withdraw: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Update leverage using WASM signing
+   * @param params - Update leverage parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async updateLeverage(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signUpdateLeverage(params.marketIndex, params.fraction, params.marginMode, params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign update leverage: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Modify an order using WASM signing
+   * @param params - Modify order parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async modifyOrder(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signModifyOrder(params.marketIndex, params.index, params.baseAmount, params.price, params.triggerPrice, params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign modify order: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Create a subaccount using WASM signing
+   * @param params - Create subaccount parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async createSubAccount(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signCreateSubAccount(params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign create sub-account: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Create a public pool using WASM signing
+   * @param params - Create public pool parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async createPublicPool(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signCreatePublicPool(params.operatorFee, params.initialTotalShares, params.minOperatorShareRate, params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign create public pool: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Update a public pool using WASM signing
+   * @param params - Update public pool parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async updatePublicPool(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signUpdatePublicPool(params.publicPoolIndex, params.status, params.operatorFee, params.minOperatorShareRate, params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign update public pool: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Mint shares using WASM signing
+   * @param params - Mint shares parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async mintShares(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signMintShares(params.publicPoolIndex, params.shareAmount, params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign mint shares: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Burn shares using WASM signing
+   * @param params - Burn shares parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async burnShares(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signBurnShares(params.publicPoolIndex, params.shareAmount, params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign burn shares: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Update margin using WASM signing
+   * @param params - Update margin parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async updateMargin(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signUpdateMargin(params.marketIndex, params.usdcAmount, params.direction, params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign update margin: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Create grouped orders using WASM signing
+   * @param params - Create grouped orders parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async createGroupedOrders(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signCreateGroupedOrders(params.groupingType, params.orders, params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign create grouped orders: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: txResponse.txInfo,
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Generate change public key L1 sign message
+   * @param pubKeyHex - New public key in hex format
+   * @param nonce - Account nonce
+   * @param accountIndex - Account index
+   * @param newApiKeyIndex - New API key index
+   * @returns Promise<string> - Sign message
+   */
+  async generateChangePubKeyL1SignMessage(pubKeyHex, nonce, accountIndex, newApiKeyIndex) {
+    const formatHex16Bytes = (value) => {
+      const hex = value.toString(16);
+      return "0x" + hex.padStart(16, "0");
+    };
+    return `Register Lighter Account
+
+pubkey: 0x${pubKeyHex.replace("0x", "")}
+nonce: ${formatHex16Bytes(nonce)}
+account index: ${formatHex16Bytes(accountIndex)}
+api key index: ${formatHex16Bytes(newApiKeyIndex)}
+Only sign this message for a trusted client!`;
+  }
+  /**
+   * Change public key using WASM signing
+   * @param params - Change public key parameters
+   * @returns Promise<TxHashResponse>
+   * @throws Error if WasmSigning is not configured
+   */
+  async changePubKey(params) {
+    if (!this.wasmSigning) {
+      throw new Error("WasmSigning not configured. Please provide wasmSigning in ExchangeClientConfig.");
+    }
+    const txResponse = this.wasmSigning.signChangePubKey(params.pubKeyHex, params.nonce);
+    if (txResponse.error) {
+      throw new Error(`Failed to sign change pub key: ${txResponse.error}`);
+    }
+    if (!txResponse.txInfo || !txResponse.txType) {
+      throw new Error("Invalid transaction response: missing txInfo or txType");
+    }
+    const txInfo = JSON.parse(txResponse.txInfo);
+    txInfo.L1Sig = params.l1Sig;
+    return this.sendTx({
+      tx_type: parseInt(txResponse.txType),
+      tx_info: JSON.stringify(txInfo),
+      price_protection: params.priceProtection
+    });
+  }
+  /**
+   * Acknowledge a notification
+   * @param params - Notification acknowledgment parameters
+   * @param authorization - Optional authorization token
+   * @returns Promise<NotificationAckResponse>
+   */
+  async acknowledgeNotification(params, authorization) {
+    return acknowledgeNotification(this.axiosInstance, params, authorization);
+  }
+  /**
+   * Change account tier
+   * @param params - Account tier change parameters including account_index and new_tier
+   * @param authorization - Optional authorization token
+   * @returns Promise<ChangeAccountTierResponse>
+   * @example
+   * ```typescript
+   * const result = await client.changeAccountTier({
+   *   account_index: 0,
+   *   new_tier: "premium"
+   * });
+   * ```
+   */
+  async changeAccountTier(params, authorization) {
+    return changeAccountTier(this.axiosInstance, params, authorization);
+  }
+  /**
+   * Fast withdraw funds
+   * @param params - Fast withdraw parameters including tx_info and to_address
+   * @param authorization - Optional authorization token
+   * @returns Promise<FastWithdrawResponse>
+   * @example
+   * ```typescript
+   * const result = await client.fastWithdraw({
+   *   tx_info: "0x...",
+   *   to_address: "0x..."
+   * });
+   * ```
+   */
+  async fastWithdraw(params, authorization) {
+    return fastWithdraw(this.axiosInstance, params, authorization);
+  }
+  /**
+   * Create API token
+   * @param params - Token creation parameters including name, account_index, expiry, and permissions
+   * @param authorization - Optional authorization token
+   * @returns Promise<TokensCreateResponse>
+   * @example
+   * ```typescript
+   * const token = await client.createToken({
+   *   name: "My API Token",
+   *   account_index: 0,
+   *   expiry: Math.floor(Date.now() / 1000) + 86400 * 30, // 30 days
+   *   sub_account_access: true,
+   *   scopes: "read.*"
+   * });
+   * ```
+   */
+  async createToken(params, authorization) {
+    return createToken(this.axiosInstance, params, authorization);
+  }
+  /**
+   * Revoke API token
+   * @param params - Token revocation parameters including token_id and account_index
+   * @param authorization - Optional authorization token
+   * @returns Promise<TokensRevokeResponse>
+   * @example
+   * ```typescript
+   * const result = await client.revokeToken({
+   *   token_id: 123,
+   *   account_index: 0
+   * });
+   * ```
+   */
+  async revokeToken(params, authorization) {
+    return revokeToken(this.axiosInstance, params, authorization);
+  }
+};
+
+export {
+  ExchangeClient
+};