@andy-liquid-labs/lighter-ts-sdk 1.0.0

package/src/client/exchange-client.ts

@@ -0,0 +1,637 @@
+import axios, { AxiosInstance } from "axios";
+
+import {
+  acknowledgeNotification,
+  changeAccountTier,
+  ChangeAccountTierRequest,
+  ChangeAccountTierResponse,
+  createToken,
+  fastWithdraw,
+  FastWithdrawRequest,
+  FastWithdrawResponse,
+  NotificationAckRequest,
+  NotificationAckResponse,
+  revokeToken,
+  sendTransaction,
+  sendTransactionBatch,
+  SendTransactionBatchRequest,
+  SendTransactionRequest,
+  sendTx,
+  SendTxFormRequest,
+  sendTxJson,
+  sendTxWithIndices,
+  SendTxWithIndicesRequest,
+  TokensCreateRequest,
+  TokensCreateResponse,
+  TokensRevokeRequest,
+  TokensRevokeResponse,
+  TxHashesResponse,
+  TxHashResponse,
+} from "../api/exchange";
+import { TxClient } from "./txClient";
+import { hexToBytes } from "../signer/keyManager";
+import {
+  serializeCreateOrder,
+  serializeCancelOrder,
+  serializeCancelAllOrders,
+  serializeTransfer,
+  serializeWithdraw,
+  serializeUpdateLeverage,
+  serializeModifyOrder,
+  serializeCreateSubAccount,
+  serializeCreatePublicPool,
+  serializeUpdatePublicPool,
+  serializeMintShares,
+  serializeBurnShares,
+  serializeUpdateMargin,
+  serializeCreateGroupedOrders,
+  serializeChangePubKey,
+} from "../types/txInfoSerializer";
+import { TxType } from "../types/constants";
+
+export interface ExchangeClientConfig {
+  baseURL?: string;
+  txClient: TxClient;
+}
+
+const DEFAULT_DEADLINE = 120;
+
+/**
+ * ExchangeClient - Client for exchange/transaction endpoints
+ *
+ * Provides access to transaction sending and signing endpoints.
+ * Uses TypeScript-based signing via TxClient instead of WASM.
+ *
+ * @example
+ * ```typescript
+ * const txClient = createClient(httpClient, privateKey, chainId, apiKeyIndex, accountIndex);
+ * const client = new ExchangeClient({
+ *   baseURL: "https://mainnet.zklighter.elliot.ai",
+ *   txClient
+ * });
+ *
+ * const result = await client.createOrder({
+ *   marketIndex: 0,
+ *   clientOrderIndex: 1,
+ *   baseAmount: 1000000n,
+ *   price: 50000,
+ *   isAsk: 0,
+ *   orderType: 0,
+ *   timeInForce: 1,
+ *   reduceOnly: 0,
+ *   triggerPrice: 0,
+ *   orderExpiry: BigInt(Date.now() + 3600000),
+ * });
+ * ```
+ */
+export class ExchangeClient {
+  private readonly baseURL: string;
+  private readonly axiosInstance: AxiosInstance;
+  private readonly txClient: TxClient;
+
+  constructor(config: ExchangeClientConfig) {
+    this.baseURL = config?.baseURL || "https://mainnet.zklighter.elliot.ai";
+    this.txClient = config.txClient;
+    this.axiosInstance = this.createAxiosInstance();
+  }
+
+  private createAxiosInstance(): AxiosInstance {
+    return axios.create({
+      baseURL: this.baseURL,
+    });
+  }
+
+  /**
+   * Create an auth token using the TxClient
+   */
+  private async createAuthToken(): Promise<string> {
+    const deadline = new Date(Date.now() + DEFAULT_DEADLINE * 1000);
+    return this.txClient.getAuthToken(deadline);
+  }
+
+  /**
+   * Get the axios instance for custom requests
+   */
+  public getAxiosInstance(): AxiosInstance {
+    return this.axiosInstance;
+  }
+
+  /**
+   * Get the TxClient for direct signing operations
+   */
+  public getTxClient(): TxClient {
+    return this.txClient;
+  }
+
+  /**
+   * Send a transaction
+   */
+  public async sendTransaction(
+    params: SendTransactionRequest,
+  ): Promise<TxHashResponse> {
+    return sendTransaction(this.axiosInstance, params);
+  }
+
+  /**
+   * Send a transaction with form data
+   */
+  public async sendTx(params: SendTxFormRequest): Promise<TxHashResponse> {
+    return sendTx(this.axiosInstance, params);
+  }
+
+  /**
+   * Send a transaction with account and API key indices
+   */
+  public async sendTxWithIndices(
+    params: SendTxWithIndicesRequest,
+  ): Promise<TxHashResponse> {
+    return sendTxWithIndices(this.axiosInstance, params);
+  }
+
+  /**
+   * Send a transaction with JSON payload
+   */
+  public async sendTxJson(
+    params: SendTxWithIndicesRequest,
+  ): Promise<TxHashResponse> {
+    return sendTxJson(this.axiosInstance, params);
+  }
+
+  /**
+   * Send a batch of transactions
+   */
+  public async sendTransactionBatch(
+    params: SendTransactionBatchRequest,
+  ): Promise<TxHashesResponse> {
+    return sendTransactionBatch(this.axiosInstance, params);
+  }
+
+  /**
+   * Create and send an order using TypeScript signing
+   */
+  public async createOrder(params: {
+    marketIndex: number;
+    clientOrderIndex: bigint;
+    baseAmount: bigint;
+    price: number;
+    isAsk: number;
+    orderType: number;
+    timeInForce: number;
+    reduceOnly: number;
+    triggerPrice: number;
+    orderExpiry: bigint;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const txInfo = await this.txClient.signCreateOrder({
+      marketIndex: params.marketIndex,
+      clientOrderIndex: params.clientOrderIndex,
+      baseAmount: params.baseAmount,
+      price: params.price,
+      isAsk: params.isAsk,
+      type: params.orderType,
+      timeInForce: params.timeInForce,
+      reduceOnly: params.reduceOnly,
+      triggerPrice: params.triggerPrice,
+      orderExpiry: params.orderExpiry,
+    });
+
+    return this.sendTx({
+      tx_type: TxType.L2CreateOrder,
+      tx_info: serializeCreateOrder(txInfo),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Cancel an order using TypeScript signing
+   */
+  public async cancelOrder(params: {
+    marketIndex: number;
+    orderIndex: bigint;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const txInfo = await this.txClient.signCancelOrder({
+      marketIndex: params.marketIndex,
+      index: params.orderIndex,
+    });
+
+    return this.sendTx({
+      tx_type: TxType.L2CancelOrder,
+      tx_info: serializeCancelOrder(txInfo),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Cancel all orders using TypeScript signing
+   */
+  public async cancelAllOrders(params: {
+    timeInForce: number;
+    time: bigint;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const txInfo = await this.txClient.signCancelAllOrders({
+      timeInForce: params.timeInForce,
+      time: params.time,
+    });
+
+    return this.sendTx({
+      tx_type: TxType.L2CancelAllOrders,
+      tx_info: serializeCancelAllOrders(txInfo),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Transfer funds using TypeScript signing
+   */
+  public async transfer(params: {
+    toAccountIndex: bigint;
+    assetIndex: number;
+    fromRouteType: number;
+    toRouteType: number;
+    amount: bigint;
+    usdcFee: bigint;
+    memo: string;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const memoBytes = new TextEncoder().encode(params.memo);
+    const txInfo = await this.txClient.signTransfer({
+      toAccountIndex: params.toAccountIndex,
+      assetIndex: params.assetIndex,
+      fromRouteType: params.fromRouteType,
+      toRouteType: params.toRouteType,
+      amount: params.amount,
+      usdcFee: params.usdcFee,
+      memo: memoBytes,
+    });
+
+    return this.sendTx({
+      tx_type: TxType.L2Transfer,
+      tx_info: serializeTransfer(txInfo),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Withdraw funds using TypeScript signing
+   */
+  public async withdraw(params: {
+    assetIndex: number;
+    routeType: number;
+    amount: bigint;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const txInfo = await this.txClient.signWithdraw({
+      assetIndex: params.assetIndex,
+      routeType: params.routeType,
+      amount: params.amount,
+    });
+
+    return this.sendTx({
+      tx_type: TxType.L2Withdraw,
+      tx_info: serializeWithdraw(txInfo),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Update leverage using TypeScript signing
+   */
+  public async updateLeverage(params: {
+    marketIndex: number;
+    initialMarginFraction: number;
+    marginMode: number;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const txInfo = await this.txClient.signUpdateLeverage({
+      marketIndex: params.marketIndex,
+      initialMarginFraction: params.initialMarginFraction,
+      marginMode: params.marginMode,
+    });
+
+    return this.sendTx({
+      tx_type: TxType.L2UpdateLeverage,
+      tx_info: serializeUpdateLeverage(txInfo),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Modify an order using TypeScript signing
+   */
+  public async modifyOrder(params: {
+    marketIndex: number;
+    index: bigint;
+    baseAmount: bigint;
+    price: number;
+    triggerPrice: number;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const txInfo = await this.txClient.signModifyOrder({
+      marketIndex: params.marketIndex,
+      index: params.index,
+      baseAmount: params.baseAmount,
+      price: params.price,
+      triggerPrice: params.triggerPrice,
+    });
+
+    return this.sendTx({
+      tx_type: TxType.L2ModifyOrder,
+      tx_info: serializeModifyOrder(txInfo),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Create a subaccount using TypeScript signing
+   */
+  public async createSubAccount(params?: {
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const txInfo = await this.txClient.signCreateSubAccount();
+
+    return this.sendTx({
+      tx_type: TxType.L2CreateSubAccount,
+      tx_info: serializeCreateSubAccount(txInfo),
+      price_protection: params?.priceProtection,
+    });
+  }
+
+  /**
+   * Create a public pool using TypeScript signing
+   */
+  public async createPublicPool(params: {
+    operatorFee: bigint;
+    initialTotalShares: bigint;
+    minOperatorShareRate: number;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const txInfo = await this.txClient.signCreatePublicPool({
+      operatorFee: params.operatorFee,
+      initialTotalShares: params.initialTotalShares,
+      minOperatorShareRate: params.minOperatorShareRate,
+    });
+
+    return this.sendTx({
+      tx_type: TxType.L2CreatePublicPool,
+      tx_info: serializeCreatePublicPool(txInfo),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Update a public pool using TypeScript signing
+   */
+  public async updatePublicPool(params: {
+    publicPoolIndex: bigint;
+    status: number;
+    operatorFee: bigint;
+    minOperatorShareRate: number;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const txInfo = await this.txClient.signUpdatePublicPool({
+      publicPoolIndex: params.publicPoolIndex,
+      status: params.status,
+      operatorFee: params.operatorFee,
+      minOperatorShareRate: params.minOperatorShareRate,
+    });
+
+    return this.sendTx({
+      tx_type: TxType.L2UpdatePublicPool,
+      tx_info: serializeUpdatePublicPool(txInfo),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Mint shares using TypeScript signing
+   */
+  public async mintShares(params: {
+    publicPoolIndex: bigint;
+    shareAmount: bigint;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const txInfo = await this.txClient.signMintShares({
+      publicPoolIndex: params.publicPoolIndex,
+      shareAmount: params.shareAmount,
+    });
+
+    return this.sendTx({
+      tx_type: TxType.L2MintShares,
+      tx_info: serializeMintShares(txInfo),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Burn shares using TypeScript signing
+   */
+  public async burnShares(params: {
+    publicPoolIndex: bigint;
+    shareAmount: bigint;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const txInfo = await this.txClient.signBurnShares({
+      publicPoolIndex: params.publicPoolIndex,
+      shareAmount: params.shareAmount,
+    });
+
+    return this.sendTx({
+      tx_type: TxType.L2BurnShares,
+      tx_info: serializeBurnShares(txInfo),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Update margin using TypeScript signing
+   */
+  public async updateMargin(params: {
+    marketIndex: number;
+    usdcAmount: bigint;
+    direction: number;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const txInfo = await this.txClient.signUpdateMargin({
+      marketIndex: params.marketIndex,
+      usdcAmount: params.usdcAmount,
+      direction: params.direction,
+    });
+
+    return this.sendTx({
+      tx_type: TxType.L2UpdateMargin,
+      tx_info: serializeUpdateMargin(txInfo),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Create grouped orders using TypeScript signing
+   */
+  public async createGroupedOrders(params: {
+    groupingType: number;
+    orders: Array<{
+      marketIndex: number;
+      clientOrderIndex: bigint;
+      baseAmount: bigint;
+      price: number;
+      isAsk: number;
+      type: number;
+      timeInForce: number;
+      reduceOnly: number;
+      triggerPrice: number;
+      orderExpiry: bigint;
+    }>;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const txInfo = await this.txClient.signCreateGroupedOrders({
+      groupingType: params.groupingType,
+      orders: params.orders,
+    });
+
+    return this.sendTx({
+      tx_type: TxType.L2CreateGroupedOrders,
+      tx_info: serializeCreateGroupedOrders(txInfo),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Create multiple orders in a batch using TypeScript signing
+   */
+  public async createBatchOrders(params: {
+    orders: Array<{
+      marketIndex: number;
+      clientOrderIndex: bigint;
+      baseAmount: bigint;
+      price: number;
+      isAsk: number;
+      orderType: number;
+      timeInForce: number;
+      reduceOnly: number;
+      triggerPrice: number;
+      orderExpiry: bigint;
+    }>;
+  }): Promise<TxHashesResponse> {
+    const txTypes: number[] = [];
+    const txInfos: string[] = [];
+
+    // Sign each order
+    for (const order of params.orders) {
+      const txInfo = await this.txClient.signCreateOrder({
+        marketIndex: order.marketIndex,
+        clientOrderIndex: order.clientOrderIndex,
+        baseAmount: order.baseAmount,
+        price: order.price,
+        isAsk: order.isAsk,
+        type: order.orderType,
+        timeInForce: order.timeInForce,
+        reduceOnly: order.reduceOnly,
+        triggerPrice: order.triggerPrice,
+        orderExpiry: order.orderExpiry,
+      });
+
+      txTypes.push(TxType.L2CreateOrder);
+      txInfos.push(serializeCreateOrder(txInfo));
+    }
+
+    return this.sendTransactionBatch({
+      tx_types: JSON.stringify(txTypes),
+      tx_infos: JSON.stringify(txInfos),
+    });
+  }
+
+  /**
+   * Generate change public key L1 sign message
+   */
+  public generateChangePubKeyL1SignMessage(
+    pubKeyHex: string,
+    nonce: number,
+    accountIndex: bigint,
+    newApiKeyIndex: number,
+  ): string {
+    const formatHex16Bytes = (value: bigint | number): string => {
+      const hex = BigInt(value).toString(16);
+      return "0x" + hex.padStart(16, "0");
+    };
+
+    return `Register Lighter Account\n\npubkey: 0x${pubKeyHex.replace("0x", "")}\nnonce: ${formatHex16Bytes(nonce)}\naccount index: ${formatHex16Bytes(accountIndex)}\napi key index: ${formatHex16Bytes(newApiKeyIndex)}\nOnly sign this message for a trusted client!`;
+  }
+
+  /**
+   * Change public key using TypeScript signing
+   */
+  public async changePubKey(params: {
+    pubKey: string;
+    l1Sig: string;
+    priceProtection?: boolean;
+  }): Promise<TxHashResponse> {
+    const pubKeyBytes = hexToBytes(params.pubKey);
+    const txInfo = await this.txClient.signChangePubKey({
+      pubKey: pubKeyBytes,
+    });
+
+    // Add L1 signature to the tx info
+    const txInfoWithL1Sig = {
+      ...JSON.parse(serializeChangePubKey(txInfo)),
+      L1Sig: params.l1Sig,
+    };
+
+    return this.sendTx({
+      tx_type: TxType.L2ChangePubKey,
+      tx_info: JSON.stringify(txInfoWithL1Sig),
+      price_protection: params.priceProtection,
+    });
+  }
+
+  /**
+   * Acknowledge a notification
+   */
+  public async acknowledgeNotification(
+    params: NotificationAckRequest,
+  ): Promise<NotificationAckResponse> {
+    const auth = await this.createAuthToken();
+    return acknowledgeNotification(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Change account tier
+   */
+  public async changeAccountTier(
+    params: ChangeAccountTierRequest,
+  ): Promise<ChangeAccountTierResponse> {
+    const auth = await this.createAuthToken();
+    return changeAccountTier(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Fast withdraw funds
+   */
+  public async fastWithdraw(
+    params: FastWithdrawRequest,
+  ): Promise<FastWithdrawResponse> {
+    const auth = await this.createAuthToken();
+    return fastWithdraw(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Create API token
+   */
+  public async createToken(
+    params: TokensCreateRequest,
+  ): Promise<TokensCreateResponse> {
+    const auth = await this.createAuthToken();
+    return createToken(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Revoke API token
+   */
+  public async revokeToken(
+    params: TokensRevokeRequest,
+  ): Promise<TokensRevokeResponse> {
+    const auth = await this.createAuthToken();
+    return revokeToken(this.axiosInstance, params, auth);
+  }
+}