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

package/src/client/info-private-client.ts

@@ -0,0 +1,444 @@
+import axios, { AxiosInstance } from "axios";
+
+import {
+  AccountActiveOrdersRequest,
+  AccountInactiveOrdersRequest,
+  AccountLimitsRequest,
+  AccountLimitsResponse,
+  AccountMetadataRequest,
+  AccountMetadataResponse,
+  DepositHistoryRequest,
+  DepositHistoryResponse,
+  ExportRequest,
+  ExportResponse,
+  FastWithdrawInfoRequest,
+  FastWithdrawInfoResponse,
+  getAccountActiveOrders,
+  getAccountInactiveOrders,
+  getAccountLimits,
+  getAccountMetadata,
+  getDepositHistory,
+  getExport,
+  getFastWithdrawInfo,
+  getL1Metadata,
+  getLiquidations,
+  getPnL,
+  getPositionFunding,
+  getPublicPools,
+  getReferralPoints,
+  getTokens,
+  getTrades,
+  getTransferFeeInfo,
+  getTransferHistory,
+  getWithdrawHistory,
+  L1MetadataRequest,
+  L1MetadataResponse,
+  LiquidationsRequest,
+  LiquidationsResponse,
+  Orders,
+  PnLRequest,
+  PnLResponse,
+  PositionFundingRequest,
+  PositionFundingResponse,
+  PublicPoolsRequest,
+  PublicPoolsResponse,
+  ReferralPointsRequest,
+  ReferralPointsResponse,
+  TokensRequest,
+  TokensResponse,
+  TradesRequest,
+  TradesResponse,
+  TransferFeeInfoRequest,
+  TransferFeeInfoResponse,
+  TransferHistoryRequest,
+  TransferHistoryResponse,
+  WithdrawHistoryRequest,
+  WithdrawHistoryResponse,
+} from "../api/info-private";
+import { TxClient } from "./txClient";
+
+export interface InfoPrivateClientConfig {
+  baseURL?: string;
+  txClient: TxClient;
+}
+
+const DEFAULT_DEADLINE = 120;
+
+/**
+ * InfoPrivateClient - Client for private/authenticated info endpoints
+ *
+ * Provides access to API endpoints that require authentication.
+ * Authentication is handled automatically using the provided TxClient.
+ *
+ * @example
+ * ```typescript
+ * const txClient = createClient(httpClient, privateKey, chainId, apiKeyIndex, accountIndex);
+ * const client = new InfoPrivateClient({
+ *   baseURL: "https://mainnet.zklighter.elliot.ai",
+ *   txClient
+ * });
+ *
+ * const orders = await client.getAccountActiveOrders({
+ *   account_index: 0,
+ *   market_id: 1
+ * });
+ * ```
+ */
+export class InfoPrivateClient {
+  private readonly baseURL: string;
+  private readonly axiosInstance: AxiosInstance;
+  private readonly txClient: TxClient;
+
+  constructor(config: InfoPrivateClientConfig) {
+    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,
+    });
+  }
+
+  /**
+   * Get the axios instance for custom requests
+   */
+  public getAxiosInstance(): AxiosInstance {
+    return this.axiosInstance;
+  }
+
+  /**
+   * 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
+   * });
+   * ```
+   */
+  public async getAccountActiveOrders(
+    params: AccountActiveOrdersRequest,
+  ): Promise<Orders> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getAccountActiveOrders(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * 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
+   * });
+   * ```
+   */
+  public async getAccountInactiveOrders(
+    params: AccountInactiveOrdersRequest,
+  ): Promise<Orders> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getAccountInactiveOrders(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * 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 });
+   * ```
+   */
+  public async getAccountLimits(
+    params: AccountLimitsRequest,
+  ): Promise<AccountLimitsResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getAccountLimits(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get account metadata by index or L1 address
+   * @param params - Account index or L1 address to retrieve metadata for
+   * @returns Account metadata including account index, L1 address, and public key
+   * @example
+   * ```typescript
+   * const metadata = await client.getAccountMetadata({ account_index: 0 });
+   * ```
+   */
+  public async getAccountMetadata(
+    params: AccountMetadataRequest,
+  ): Promise<AccountMetadataResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getAccountMetadata(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get L1 metadata for an address
+   * @param params - L1 address to retrieve metadata for
+   * @returns L1 metadata including all account indices associated with the address
+   * @example
+   * ```typescript
+   * const metadata = await client.getL1Metadata({ l1_address: '0x...' });
+   * ```
+   */
+  public async getL1Metadata(
+    params: L1MetadataRequest,
+  ): Promise<L1MetadataResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getL1Metadata(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get API tokens for an account
+   * @param params - Account index to retrieve tokens for
+   * @returns List of API tokens with their creation dates and expiry information
+   * @example
+   * ```typescript
+   * const tokens = await client.getTokens({ account_index: 0 });
+   * ```
+   */
+  public async getTokens(params: TokensRequest): Promise<TokensResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getTokens(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get deposit history for an account
+   * @param params - Account index and optional filters
+   * @returns List of deposits with pagination support
+   * @example
+   * ```typescript
+   * const deposits = await client.getDepositHistory({
+   *   account_index: 0,
+   *   limit: 50
+   * });
+   * ```
+   */
+  public async getDepositHistory(
+    params: DepositHistoryRequest,
+  ): Promise<DepositHistoryResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getDepositHistory(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get withdrawal history for an account
+   * @param params - Account index and optional filters
+   * @returns List of withdrawals with pagination support
+   * @example
+   * ```typescript
+   * const withdrawals = await client.getWithdrawHistory({
+   *   account_index: 0,
+   *   limit: 50
+   * });
+   * ```
+   */
+  public async getWithdrawHistory(
+    params: WithdrawHistoryRequest,
+  ): Promise<WithdrawHistoryResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getWithdrawHistory(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get fast withdraw information for an account
+   * @param params - Account index to retrieve fast withdraw info for
+   * @returns Fast withdraw information including available liquidity and fees
+   * @example
+   * ```typescript
+   * const info = await client.getFastWithdrawInfo({ account_index: 0 });
+   * ```
+   */
+  public async getFastWithdrawInfo(
+    params: FastWithdrawInfoRequest,
+  ): Promise<FastWithdrawInfoResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getFastWithdrawInfo(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get transfer fee information between accounts
+   * @param params - From and to account indices and optional asset index
+   * @returns Transfer fee information including fee amount and fee percentage
+   * @example
+   * ```typescript
+   * const feeInfo = await client.getTransferFeeInfo({
+   *   from_account_index: 0,
+   *   to_account_index: 1
+   * });
+   * ```
+   */
+  public async getTransferFeeInfo(
+    params: TransferFeeInfoRequest,
+  ): Promise<TransferFeeInfoResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getTransferFeeInfo(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get transfer history for an account
+   * @param params - Account index and optional filters
+   * @returns List of transfers with pagination support
+   * @example
+   * ```typescript
+   * const transfers = await client.getTransferHistory({
+   *   account_index: 0,
+   *   limit: 50
+   * });
+   * ```
+   */
+  public async getTransferHistory(
+    params: TransferHistoryRequest,
+  ): Promise<TransferHistoryResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getTransferHistory(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get liquidation history for an account
+   * @param params - Account index and optional filters
+   * @returns List of liquidations with pagination support
+   * @example
+   * ```typescript
+   * const liquidations = await client.getLiquidations({
+   *   account_index: 0,
+   *   limit: 50
+   * });
+   * ```
+   */
+  public async getLiquidations(
+    params: LiquidationsRequest,
+  ): Promise<LiquidationsResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getLiquidations(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get profit and loss data for an account or market
+   * @param params - Account index and optional market ID
+   * @returns PnL data including realized and unrealized PnL
+   * @example
+   * ```typescript
+   * const pnl = await client.getPnL({
+   *   account_index: 0,
+   *   market_id: 1
+   * });
+   * ```
+   */
+  public async getPnL(params: PnLRequest): Promise<PnLResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getPnL(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get position funding history for an account
+   * @param params - Account index and optional filters
+   * @returns List of funding payments with pagination support
+   * @example
+   * ```typescript
+   * const funding = await client.getPositionFunding({
+   *   account_index: 0,
+   *   limit: 50
+   * });
+   * ```
+   */
+  public async getPositionFunding(
+    params: PositionFundingRequest,
+  ): Promise<PositionFundingResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getPositionFunding(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get public liquidity pools metadata
+   * @param params - Optional account index to filter by owner
+   * @returns List of public pools with metadata
+   * @example
+   * ```typescript
+   * const pools = await client.getPublicPools({ account_index: 0 });
+   * ```
+   */
+  public async getPublicPools(
+    params?: PublicPoolsRequest,
+  ): Promise<PublicPoolsResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getPublicPools(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get referral points for an account
+   * @param params - Account index to retrieve referral points for
+   * @returns Referral points data including total points and referral code
+   * @example
+   * ```typescript
+   * const points = await client.getReferralPoints({ account_index: 0 });
+   * ```
+   */
+  public async getReferralPoints(
+    params: ReferralPointsRequest,
+  ): Promise<ReferralPointsResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getReferralPoints(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Get trades for an account or market
+   * @param params - Account index and optional market ID and filters
+   * @returns List of trades with pagination support
+   * @example
+   * ```typescript
+   * const trades = await client.getTrades({
+   *   account_index: 0,
+   *   market_id: 1,
+   *   limit: 50
+   * });
+   * ```
+   */
+  public async getTrades(params: TradesRequest): Promise<TradesResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getTrades(this.axiosInstance, params, auth);
+  }
+
+  /**
+   * Export data (funding or trade data) for an account
+   * @param params - Account index and export type
+   * @returns Export data in CSV format
+   * @example
+   * ```typescript
+   * const exportData = await client.getExport({
+   *   account_index: 0,
+   *   export_type: 'trades'
+   * });
+   * ```
+   */
+  public async getExport(params: ExportRequest): Promise<ExportResponse> {
+    const deadline = Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE;
+    const auth = await this.txClient.getAuthToken(new Date(deadline * 1000));
+    return getExport(this.axiosInstance, params, auth);
+  }
+}