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

package/dist/index.d.mts

@@ -0,0 +1,3686 @@
+import { AxiosInstance } from 'axios';
+
+/**
+ * Minimal HTTP Client interface for Lighter API
+ */
+interface MinimalHTTPClient {
+    /**
+     * Get the next nonce for an account and API key
+     */
+    getNextNonce(accountIndex: bigint, apiKeyIndex: number): Promise<bigint>;
+    /**
+     * Get the public key for an account and API key
+     */
+    getApiKey(accountIndex: bigint, apiKeyIndex: number): Promise<string>;
+    /**
+     * Get account information by L1 address or account index
+     */
+    getAccount(by: 'l1_address' | 'account_index', value: string): Promise<LighterAccount[]>;
+}
+interface LighterAsset {
+    symbol: string;
+    asset_id: number;
+    balance: string;
+    locked_balance: string;
+}
+interface LighterPosition {
+}
+interface LighterShare {
+}
+interface LighterAccount {
+    code: number;
+    account_type: number;
+    index: number;
+    l1_address: string;
+    cancel_all_time: number;
+    total_order_count: number;
+    total_isolated_order_count: number;
+    pending_order_count: number;
+    available_balance: string;
+    status: number;
+    collateral: string;
+    transaction_time: number;
+    account_index: number;
+    name: string;
+    description: string;
+    can_invite: boolean;
+    referral_points_percentage: string;
+    positions: LighterPosition[];
+    assets: LighterAsset[];
+    total_asset_value: string;
+    cross_asset_value: string;
+    shares: LighterShare[];
+}
+
+/**
+ * HTTP Client implementation for Lighter API
+ */
+
+/**
+ * HTTP Client for Lighter exchange API
+ */
+declare class HttpClient implements MinimalHTTPClient {
+    private readonly endpoint;
+    private readonly timeout;
+    constructor(baseUrl: string, timeout?: number);
+    /**
+     * Make a GET request to the API
+     */
+    private get;
+    /**
+     * Get the next nonce for an account and API key
+     */
+    getNextNonce(accountIndex: bigint, apiKeyIndex: number): Promise<bigint>;
+    /**
+     * Get the public key for an account and API key
+     */
+    getApiKey(accountIndex: bigint, apiKeyIndex: number): Promise<string>;
+    /**
+     * Get account information by L1 address or account index
+     */
+    getAccount(by: 'l1_address' | 'account_index', value: string): Promise<LighterAccount[]>;
+    /**
+     * Get account information by L1 address (convenience method)
+     */
+    getAccountByL1Address(l1Address: string): Promise<LighterAccount[]>;
+    /**
+     * Get account information by account index (convenience method)
+     */
+    getAccountByIndex(accountIndex: string): Promise<LighterAccount[]>;
+}
+/**
+ * Create a new HTTP client
+ */
+declare function newHttpClient(baseUrl: string): MinimalHTTPClient | null;
+
+/**
+ * ECgFp5 Elliptic Curve Implementation
+ *
+ * This implements the ECgFp5 curve used in the Lighter protocol for Schnorr signatures.
+ * ECgFp5 is an elliptic curve defined over the quintic extension of the Goldilocks field.
+ *
+ * Key properties:
+ * - Prime order (no cofactor) - eliminates small subgroup attacks
+ * - Complete addition formulas
+ * - Canonical point encoding
+ *
+ * Reference: https://github.com/pornin/ecgfp5
+ */
+declare const SCALAR_ORDER = 1067993516717146951041484916571792702745057740581727230159139685185762082554198619328292418486241n;
+/**
+ * GFp5 Element - Quintic extension of Goldilocks field
+ * Represents elements as polynomials a0 + a1*x + a2*x^2 + a3*x^3 + a4*x^4 mod (x^5 - 3)
+ */
+declare class GFp5Element {
+    readonly coeffs: bigint[];
+    constructor(coeffs: bigint[]);
+    static zero(): GFp5Element;
+    static one(): GFp5Element;
+    static two(): GFp5Element;
+    isZero(): boolean;
+    equals(other: GFp5Element): boolean;
+    neg(): GFp5Element;
+    add(other: GFp5Element): GFp5Element;
+    sub(other: GFp5Element): GFp5Element;
+    double(): GFp5Element;
+    /**
+     * Multiply two GFp5 elements
+     * Uses the reduction rule: x^5 = 3 (since x^5 - 3 = 0)
+     */
+    mul(other: GFp5Element): GFp5Element;
+    square(): GFp5Element;
+    /**
+     * Scalar multiplication
+     */
+    scalarMul(scalar: bigint): GFp5Element;
+    /**
+     * Compute self^(2^power)
+     */
+    expPowerOf2(power: number): GFp5Element;
+    /**
+     * Frobenius endomorphism: x -> x^p
+     */
+    frobenius(): GFp5Element;
+    repeatedFrobenius(count: number): GFp5Element;
+    /**
+     * Compute multiplicative inverse (or zero if input is zero)
+     */
+    inverseOrZero(): GFp5Element;
+    div(other: GFp5Element): GFp5Element;
+    toLittleEndianBytes(): Uint8Array;
+    static fromLittleEndianBytes(bytes: Uint8Array): GFp5Element;
+}
+/**
+ * ECgFp5 Scalar - Element of the scalar field (mod ORDER)
+ */
+declare class ECgFp5Scalar {
+    readonly value: bigint;
+    constructor(value: bigint);
+    static zero(): ECgFp5Scalar;
+    static one(): ECgFp5Scalar;
+    isCanonical(): boolean;
+    equals(other: ECgFp5Scalar): boolean;
+    add(other: ECgFp5Scalar): ECgFp5Scalar;
+    sub(other: ECgFp5Scalar): ECgFp5Scalar;
+    mul(other: ECgFp5Scalar): ECgFp5Scalar;
+    toLittleEndianBytes(): Uint8Array;
+    static fromLittleEndianBytes(bytes: Uint8Array): ECgFp5Scalar;
+    /**
+     * Create from big integer (reduces mod ORDER)
+     */
+    static fromNonCanonicalBigInt(val: bigint): ECgFp5Scalar;
+    /**
+     * Convert from a GFp5Element to a scalar
+     * This is used when converting hash output to a scalar
+     * Note: Each coefficient is already reduced mod GOLDILOCKS_MODULUS (< 2^64),
+     * so the combined value fits in 320 bits and is then reduced mod SCALAR_ORDER
+     */
+    static fromGFp5(fp5: GFp5Element): ECgFp5Scalar;
+}
+/**
+ * ECgFp5 Point - A point on the ECgFp5 curve
+ * Uses fractional (x, z, u, t) coordinates where (x, u) = (x, x/y) = (X/Z, U/T)
+ */
+declare class ECgFp5Point {
+    readonly x: GFp5Element;
+    readonly z: GFp5Element;
+    readonly u: GFp5Element;
+    readonly t: GFp5Element;
+    constructor(x: GFp5Element, z: GFp5Element, u: GFp5Element, t: GFp5Element);
+    static neutral(): ECgFp5Point;
+    static B(): GFp5Element;
+    static B_MUL2(): GFp5Element;
+    static B_MUL4(): GFp5Element;
+    static generator(): ECgFp5Point;
+    isNeutral(): boolean;
+    equals(other: ECgFp5Point): boolean;
+    /**
+     * Encode point to GFp5 element (w = t/u)
+     */
+    encode(): GFp5Element;
+    /**
+     * Add two points using complete addition formulas
+     * Cost: 10 field multiplications
+     */
+    add(other: ECgFp5Point): ECgFp5Point;
+    /**
+     * Double this point
+     */
+    double(): ECgFp5Point;
+    /**
+     * Multiply point by scalar using double-and-add
+     */
+    mul(scalar: ECgFp5Scalar): ECgFp5Point;
+}
+/**
+ * Sample a random scalar using cryptographically secure random number generator
+ */
+declare function sampleScalar(): ECgFp5Scalar;
+/**
+ * Generate public key from private key: pk = sk * G
+ */
+declare function schnorrPkFromSk(sk: ECgFp5Scalar): GFp5Element;
+/**
+ * Schnorr Signature
+ */
+declare class SchnorrSignature {
+    readonly s: ECgFp5Scalar;
+    readonly e: ECgFp5Scalar;
+    constructor(s: ECgFp5Scalar, e: ECgFp5Scalar);
+    /**
+     * Serialize to bytes: s (40 bytes) || e (40 bytes)
+     */
+    toBytes(): Uint8Array;
+    static fromBytes(bytes: Uint8Array): SchnorrSignature;
+}
+/**
+ * Sign a pre-hashed message using Schnorr signature
+ * hashedMessage should be a GFp5Element (the output of HashToQuinticExtension)
+ *
+ * Algorithm:
+ * 1. Sample random k
+ * 2. Compute r = k * G (commitment)
+ * 3. Encode r to get r_encoded (a GFp5 element)
+ * 4. Compute e = H(r_encoded || hashedMessage)
+ * 5. Compute s = k - e * sk
+ * 6. Return (s, e)
+ */
+declare function schnorrSignHashedMessage(hashedMessage: GFp5Element, sk: ECgFp5Scalar): SchnorrSignature;
+/**
+ * Sign a pre-hashed message using Schnorr signature with deterministic k (for testing)
+ * WARNING: Only for testing! Using a fixed k in production is insecure.
+ */
+declare function schnorrSignHashedMessageDeterministic(hashedMessage: GFp5Element, sk: ECgFp5Scalar, k: ECgFp5Scalar): SchnorrSignature;
+
+/**
+ * Key Manager for Lighter protocol
+ * Handles key generation and signing using the Schnorr signature scheme over ECgFp5
+ */
+
+/**
+ * Signer interface
+ */
+interface Signer {
+    sign(hashedMessage: Uint8Array): Uint8Array;
+}
+/**
+ * Key Manager interface
+ */
+interface KeyManager extends Signer {
+    pubKey(): GFp5Element;
+    pubKeyBytes(): Uint8Array;
+    prvKeyBytes(): Uint8Array;
+}
+/**
+ * Create a new KeyManager from private key bytes
+ */
+declare function newKeyManager(privateKeyBytes: Uint8Array): KeyManager;
+/**
+ * Generate a new API key pair
+ * Returns [privateKey, publicKey] as hex strings
+ */
+declare function generateApiKey(seed?: string): Promise<[string, string]>;
+/**
+ * Convert bytes to hex string
+ */
+declare function bytesToHex(bytes: Uint8Array): string;
+/**
+ * Convert hex string to bytes
+ */
+declare function hexToBytes(hex: string): Uint8Array;
+
+/**
+ * Transaction Types
+ */
+declare const TxType: {
+    readonly Empty: 0;
+    readonly L1Deposit: 1;
+    readonly L1ChangePubKey: 2;
+    readonly L1CreateMarket: 3;
+    readonly L1UpdateMarket: 4;
+    readonly L1CancelAllOrders: 5;
+    readonly L1Withdraw: 6;
+    readonly L1CreateOrder: 7;
+    readonly L2ChangePubKey: 8;
+    readonly L2CreateSubAccount: 9;
+    readonly L2CreatePublicPool: 10;
+    readonly L2UpdatePublicPool: 11;
+    readonly L2Transfer: 12;
+    readonly L2Withdraw: 13;
+    readonly L2CreateOrder: 14;
+    readonly L2CancelOrder: 15;
+    readonly L2CancelAllOrders: 16;
+    readonly L2ModifyOrder: 17;
+    readonly L2MintShares: 18;
+    readonly L2BurnShares: 19;
+    readonly L2UpdateLeverage: 20;
+    readonly InternalClaimOrder: 21;
+    readonly InternalCancelOrder: 22;
+    readonly InternalDeleverage: 23;
+    readonly InternalExitPosition: 24;
+    readonly InternalCancelAllOrders: 25;
+    readonly InternalLiquidatePosition: 26;
+    readonly InternalCreateOrder: 27;
+    readonly L2CreateGroupedOrders: 28;
+    readonly L2UpdateMargin: 29;
+    readonly L1BurnShares: 30;
+};
+type TxTypeValue = (typeof TxType)[keyof typeof TxType];
+/**
+ * Order Types
+ */
+declare const OrderType: {
+    readonly Limit: 0;
+    readonly Market: 1;
+    readonly StopLoss: 2;
+    readonly StopLossLimit: 3;
+    readonly TakeProfit: 4;
+    readonly TakeProfitLimit: 5;
+    readonly TWAP: 6;
+    readonly TWAPSub: 7;
+    readonly Liquidation: 8;
+};
+type OrderTypeValue = (typeof OrderType)[keyof typeof OrderType];
+declare const ApiMaxOrderType: 6;
+/**
+ * Order Time-In-Force
+ */
+declare const TimeInForce: {
+    readonly ImmediateOrCancel: 0;
+    readonly GoodTillTime: 1;
+    readonly PostOnly: 2;
+};
+type TimeInForceValue = (typeof TimeInForce)[keyof typeof TimeInForce];
+/**
+ * Grouping Types
+ */
+declare const GroupingType: {
+    readonly None: 0;
+    readonly OneTriggersTheOther: 1;
+    readonly OneCancelsTheOther: 2;
+    readonly OneTriggersAOneCancelsTheOther: 3;
+};
+type GroupingTypeValue = (typeof GroupingType)[keyof typeof GroupingType];
+/**
+ * Cancel All Orders Time-In-Force
+ */
+declare const CancelAllTimeInForce: {
+    readonly Immediate: 0;
+    readonly Scheduled: 1;
+    readonly AbortScheduled: 2;
+};
+type CancelAllTimeInForceValue = (typeof CancelAllTimeInForce)[keyof typeof CancelAllTimeInForce];
+/**
+ * Asset Margin Mode
+ */
+declare const AssetMarginMode: {
+    readonly Disabled: 0;
+    readonly Enabled: 1;
+};
+type AssetMarginModeValue = (typeof AssetMarginMode)[keyof typeof AssetMarginMode];
+/**
+ * Asset Route Type
+ */
+declare const AssetRouteType: {
+    readonly Perps: 0;
+    readonly Spot: 1;
+};
+type AssetRouteTypeValue = (typeof AssetRouteType)[keyof typeof AssetRouteType];
+/**
+ * Position Margin Mode
+ */
+declare const MarginMode: {
+    readonly Cross: 0;
+    readonly Isolated: 1;
+};
+type MarginModeValue = (typeof MarginMode)[keyof typeof MarginMode];
+/**
+ * Margin Update Direction
+ */
+declare const MarginDirection: {
+    readonly Remove: 0;
+    readonly Add: 1;
+};
+type MarginDirectionValue = (typeof MarginDirection)[keyof typeof MarginDirection];
+/**
+ * Numeric Constants
+ */
+declare const ONE_USDC = 1000000n;
+declare const FEE_TICK = 1000000n;
+declare const MARGIN_FRACTION_TICK = 10000n;
+declare const SHARE_TICK = 10000;
+declare const MIN_ACCOUNT_INDEX = 0n;
+declare const MAX_ACCOUNT_INDEX = 281474976710654n;
+declare const MAX_MASTER_ACCOUNT_INDEX = 140737488355327n;
+declare const MIN_SUB_ACCOUNT_INDEX = 140737488355328n;
+declare const MIN_API_KEY_INDEX = 0;
+declare const MAX_API_KEY_INDEX = 254;
+declare const NIL_API_KEY_INDEX = 255;
+declare const MIN_MARKET_INDEX = 0;
+declare const MIN_PERPS_MARKET_INDEX = 0;
+declare const MAX_PERPS_MARKET_INDEX = 254;
+declare const NIL_MARKET_INDEX = 255;
+declare const MIN_SPOT_MARKET_INDEX = 2048;
+declare const MAX_SPOT_MARKET_INDEX = 4094;
+declare const NATIVE_ASSET_INDEX = 1;
+declare const USDC_ASSET_INDEX = 3;
+declare const MIN_ASSET_INDEX = 1;
+declare const MAX_ASSET_INDEX = 62;
+declare const NIL_ASSET_INDEX = 0;
+declare const MAX_INVESTED_PUBLIC_POOL_COUNT = 16n;
+declare const INITIAL_POOL_SHARE_VALUE = 1000n;
+declare const MIN_INITIAL_TOTAL_SHARES: bigint;
+declare const MAX_INITIAL_TOTAL_SHARES: bigint;
+declare const MAX_POOL_SHARES: bigint;
+declare const MAX_BURNT_SHARE_USDC_VALUE: bigint;
+declare const MAX_POOL_ENTRY_USDC: bigint;
+declare const MIN_POOL_SHARES_TO_MINT_OR_BURN = 1n;
+declare const MAX_POOL_SHARES_TO_MINT_OR_BURN: bigint;
+declare const MIN_NONCE = 0n;
+declare const MIN_ORDER_NONCE = 0n;
+declare const MAX_ORDER_NONCE: bigint;
+declare const NIL_CLIENT_ORDER_INDEX = 0n;
+declare const NIL_ORDER_INDEX = 0n;
+declare const MIN_CLIENT_ORDER_INDEX = 1n;
+declare const MAX_CLIENT_ORDER_INDEX: bigint;
+declare const MIN_ORDER_INDEX: bigint;
+declare const MAX_ORDER_INDEX: bigint;
+declare const MIN_ORDER_BASE_AMOUNT = 1n;
+declare const MAX_ORDER_BASE_AMOUNT: bigint;
+declare const NIL_ORDER_BASE_AMOUNT = 0n;
+declare const NIL_ORDER_PRICE = 0;
+declare const MIN_ORDER_PRICE = 1;
+declare const MAX_ORDER_PRICE = 4294967295;
+declare const MIN_ORDER_CANCEL_ALL_PERIOD: number;
+declare const MAX_ORDER_CANCEL_ALL_PERIOD: number;
+declare const NIL_ORDER_EXPIRY = 0n;
+declare const MIN_ORDER_EXPIRY = 1n;
+declare const MAX_ORDER_EXPIRY: bigint;
+declare const MIN_ORDER_EXPIRY_PERIOD: number;
+declare const MAX_ORDER_EXPIRY_PERIOD: number;
+declare const NIL_ORDER_TRIGGER_PRICE = 0;
+declare const MIN_ORDER_TRIGGER_PRICE = 1;
+declare const MAX_ORDER_TRIGGER_PRICE = 4294967295;
+declare const MAX_GROUPED_ORDER_COUNT = 4;
+declare const MIN_TRANSFER_AMOUNT = 0n;
+declare const MAX_TRANSFER_AMOUNT: bigint;
+declare const MAX_TRANSFER_FEE: bigint;
+declare const MIN_WITHDRAWAL_AMOUNT = 1n;
+declare const MAX_WITHDRAWAL_AMOUNT: bigint;
+declare const MIN_USDC_AMOUNT = 0n;
+declare const MAX_USDC_AMOUNT: bigint;
+declare const MIN_TIMESTAMP = 0n;
+declare const MAX_TIMESTAMP: bigint;
+declare const DEFAULT_EXPIRE_TIME_MS: number;
+declare const FETCH_NONCE_FROM_SERVER = -1n;
+
+/**
+ * Validation errors for transactions
+ */
+declare class ValidationError extends Error {
+    constructor(message: string);
+}
+declare const ErrAccountIndexTooLow: ValidationError;
+declare const ErrAccountIndexTooHigh: ValidationError;
+declare const ErrFromAccountIndexTooLow: ValidationError;
+declare const ErrFromAccountIndexTooHigh: ValidationError;
+declare const ErrToAccountIndexTooLow: ValidationError;
+declare const ErrToAccountIndexTooHigh: ValidationError;
+declare const ErrApiKeyIndexTooLow: ValidationError;
+declare const ErrApiKeyIndexTooHigh: ValidationError;
+declare const ErrInvalidMarketIndex: ValidationError;
+declare const ErrAssetIndexTooLow: ValidationError;
+declare const ErrAssetIndexTooHigh: ValidationError;
+declare const ErrRouteTypeInvalid: ValidationError;
+declare const ErrClientOrderIndexTooLow: ValidationError;
+declare const ErrClientOrderIndexTooHigh: ValidationError;
+declare const ErrOrderIndexTooLow: ValidationError;
+declare const ErrOrderIndexTooHigh: ValidationError;
+declare const ErrBaseAmountTooLow: ValidationError;
+declare const ErrBaseAmountTooHigh: ValidationError;
+declare const ErrPriceTooLow: ValidationError;
+declare const ErrPriceTooHigh: ValidationError;
+declare const ErrIsAskInvalid: ValidationError;
+declare const ErrOrderTypeInvalid: ValidationError;
+declare const ErrOrderTimeInForceInvalid: ValidationError;
+declare const ErrOrderReduceOnlyInvalid: ValidationError;
+declare const ErrOrderExpiryInvalid: ValidationError;
+declare const ErrOrderTriggerPriceInvalid: ValidationError;
+declare const ErrNonceTooLow: ValidationError;
+declare const ErrExpiredAtInvalid: ValidationError;
+declare const ErrTransferAmountTooLow: ValidationError;
+declare const ErrTransferAmountTooHigh: ValidationError;
+declare const ErrTransferFeeNegative: ValidationError;
+declare const ErrTransferFeeTooHigh: ValidationError;
+declare const ErrWithdrawalAmountTooLow: ValidationError;
+declare const ErrWithdrawalAmountTooHigh: ValidationError;
+declare const ErrUSDCAmountTooLow: ValidationError;
+declare const ErrUSDCAmountTooHigh: ValidationError;
+declare const ErrInvalidPublicKeyLength: ValidationError;
+declare const ErrMarginModeInvalid: ValidationError;
+declare const ErrMarginDirectionInvalid: ValidationError;
+declare const ErrPublicPoolIndexTooLow: ValidationError;
+declare const ErrShareAmountTooLow: ValidationError;
+declare const ErrShareAmountTooHigh: ValidationError;
+declare const ErrOperatorFeeTooLow: ValidationError;
+declare const ErrOperatorFeeTooHigh: ValidationError;
+declare const ErrInitialTotalSharesTooLow: ValidationError;
+declare const ErrInitialTotalSharesTooHigh: ValidationError;
+declare const ErrMinOperatorShareRateTooHigh: ValidationError;
+declare const ErrCancelAllTimeInForceInvalid: ValidationError;
+declare const ErrCancelAllTimeTooLow: ValidationError;
+declare const ErrCancelAllTimeTooHigh: ValidationError;
+declare const ErrGroupingTypeInvalid: ValidationError;
+declare const ErrTooManyGroupedOrders: ValidationError;
+declare const ErrNoOrdersInGroup: ValidationError;
+
+/**
+ * Transaction options for signing transactions
+ */
+interface TransactOpts {
+    /** Account index for the transaction */
+    fromAccountIndex?: bigint;
+    /** API key index */
+    apiKeyIndex?: number;
+    /** Transaction expiry timestamp in milliseconds */
+    expiredAt?: bigint;
+    /** Nonce for the transaction. If -1 or undefined, will be fetched from server */
+    nonce?: bigint;
+    /** If true, transaction won't be submitted */
+    dryRun?: boolean;
+}
+/**
+ * Change public key request
+ */
+interface ChangePubKeyReq {
+    /** New public key (40 bytes) */
+    pubKey: Uint8Array;
+}
+/**
+ * Transfer request
+ */
+interface TransferTxReq {
+    /** Destination account index */
+    toAccountIndex: bigint;
+    /** Asset index */
+    assetIndex: number;
+    /** Source route type (0=Perps, 1=Spot) */
+    fromRouteType: number;
+    /** Destination route type (0=Perps, 1=Spot) */
+    toRouteType: number;
+    /** Amount to transfer */
+    amount: bigint;
+    /** USDC fee */
+    usdcFee: bigint;
+    /** Memo (32 bytes) */
+    memo: Uint8Array;
+}
+/**
+ * Withdraw request
+ */
+interface WithdrawTxReq {
+    /** Asset index */
+    assetIndex: number;
+    /** Route type (0=Perps, 1=Spot) */
+    routeType: number;
+    /** Amount to withdraw */
+    amount: bigint;
+}
+/**
+ * Create order request
+ */
+interface CreateOrderTxReq {
+    /** Market index */
+    marketIndex: number;
+    /** Client order index */
+    clientOrderIndex: bigint;
+    /** Base amount */
+    baseAmount: bigint;
+    /** Price */
+    price: number;
+    /** Is ask order (1=ask, 0=bid) */
+    isAsk: number;
+    /** Order type */
+    type: number;
+    /** Time in force */
+    timeInForce: number;
+    /** Reduce only flag */
+    reduceOnly: number;
+    /** Trigger price for stop/take profit orders */
+    triggerPrice: number;
+    /** Order expiry timestamp */
+    orderExpiry: bigint;
+}
+/**
+ * Create grouped orders request
+ */
+interface CreateGroupedOrdersTxReq {
+    /** Grouping type */
+    groupingType: number;
+    /** Orders to create */
+    orders: CreateOrderTxReq[];
+}
+/**
+ * Modify order request
+ */
+interface ModifyOrderTxReq {
+    /** Market index */
+    marketIndex: number;
+    /** Order index to modify */
+    index: bigint;
+    /** New base amount */
+    baseAmount: bigint;
+    /** New price */
+    price: number;
+    /** New trigger price */
+    triggerPrice: number;
+}
+/**
+ * Cancel order request
+ */
+interface CancelOrderTxReq {
+    /** Market index */
+    marketIndex: number;
+    /** Order index or client order index to cancel */
+    index: bigint;
+}
+/**
+ * Cancel all orders request
+ */
+interface CancelAllOrdersTxReq {
+    /** Time in force (0=Immediate, 1=Scheduled, 2=AbortScheduled) */
+    timeInForce: number;
+    /** Time for scheduled cancel */
+    time: bigint;
+}
+/**
+ * Create public pool request
+ */
+interface CreatePublicPoolTxReq {
+    /** Operator fee */
+    operatorFee: bigint;
+    /** Initial total shares */
+    initialTotalShares: bigint;
+    /** Minimum operator share rate */
+    minOperatorShareRate: number;
+}
+/**
+ * Update public pool request
+ */
+interface UpdatePublicPoolTxReq {
+    /** Public pool index */
+    publicPoolIndex: bigint;
+    /** Pool status */
+    status: number;
+    /** Operator fee */
+    operatorFee: bigint;
+    /** Minimum operator share rate */
+    minOperatorShareRate: number;
+}
+/**
+ * Mint shares request
+ */
+interface MintSharesTxReq {
+    /** Public pool index */
+    publicPoolIndex: bigint;
+    /** Share amount */
+    shareAmount: bigint;
+}
+/**
+ * Burn shares request
+ */
+interface BurnSharesTxReq {
+    /** Public pool index */
+    publicPoolIndex: bigint;
+    /** Share amount */
+    shareAmount: bigint;
+}
+/**
+ * Update leverage request
+ */
+interface UpdateLeverageTxReq {
+    /** Market index */
+    marketIndex: number;
+    /** Initial margin fraction */
+    initialMarginFraction: number;
+    /** Margin mode (0=Cross, 1=Isolated) */
+    marginMode: number;
+}
+/**
+ * Update margin request
+ */
+interface UpdateMarginTxReq {
+    /** Market index */
+    marketIndex: number;
+    /** USDC amount */
+    usdcAmount: bigint;
+    /** Direction (0=Remove, 1=Add) */
+    direction: number;
+}
+
+/**
+ * Transaction Info types with validation and hashing
+ */
+/**
+ * Base interface for transaction info
+ */
+interface TxInfo {
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+    signature?: Uint8Array;
+    signedHash?: string;
+}
+/**
+ * Order Info structure
+ */
+interface OrderInfo {
+    marketIndex: number;
+    clientOrderIndex: bigint;
+    baseAmount: bigint;
+    price: number;
+    isAsk: number;
+    type: number;
+    timeInForce: number;
+    reduceOnly: number;
+    triggerPrice: number;
+    orderExpiry: bigint;
+}
+/**
+ * L2 Create Order Transaction Info
+ */
+declare class L2CreateOrderTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    orderInfo: OrderInfo;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        orderInfo: OrderInfo;
+        expiredAt: bigint;
+        nonce: bigint;
+    });
+    getTxType(): number;
+    validate(): void;
+    private validateOrderType;
+    hash(chainId: number): Uint8Array;
+}
+/**
+ * L2 Cancel Order Transaction Info
+ */
+declare class L2CancelOrderTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    marketIndex: number;
+    index: bigint;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        marketIndex: number;
+        index: bigint;
+        expiredAt: bigint;
+        nonce: bigint;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+}
+/**
+ * L2 Modify Order Transaction Info
+ */
+declare class L2ModifyOrderTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    marketIndex: number;
+    index: bigint;
+    baseAmount: bigint;
+    price: number;
+    triggerPrice: number;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        marketIndex: number;
+        index: bigint;
+        baseAmount: bigint;
+        price: number;
+        triggerPrice: number;
+        expiredAt: bigint;
+        nonce: bigint;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+}
+/**
+ * L2 Cancel All Orders Transaction Info
+ */
+declare class L2CancelAllOrdersTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    timeInForce: number;
+    time: bigint;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        timeInForce: number;
+        time: bigint;
+        expiredAt: bigint;
+        nonce: bigint;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+}
+/**
+ * L2 Withdraw Transaction Info
+ */
+declare class L2WithdrawTxInfo implements TxInfo {
+    fromAccountIndex: bigint;
+    apiKeyIndex: number;
+    assetIndex: number;
+    routeType: number;
+    amount: bigint;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        fromAccountIndex: bigint;
+        apiKeyIndex: number;
+        assetIndex: number;
+        routeType: number;
+        amount: bigint;
+        expiredAt: bigint;
+        nonce: bigint;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+}
+/**
+ * L2 Transfer Transaction Info
+ */
+declare class L2TransferTxInfo implements TxInfo {
+    fromAccountIndex: bigint;
+    apiKeyIndex: number;
+    toAccountIndex: bigint;
+    assetIndex: number;
+    fromRouteType: number;
+    toRouteType: number;
+    amount: bigint;
+    usdcFee: bigint;
+    memo: Uint8Array;
+    expiredAt: bigint;
+    nonce: bigint;
+    l1Sig?: string;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        fromAccountIndex: bigint;
+        apiKeyIndex: number;
+        toAccountIndex: bigint;
+        assetIndex: number;
+        fromRouteType: number;
+        toRouteType: number;
+        amount: bigint;
+        usdcFee: bigint;
+        memo: Uint8Array;
+        expiredAt: bigint;
+        nonce: bigint;
+        l1Sig?: string;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+    /**
+     * Get L1 signature body for this transfer transaction
+     * Used for calculating L1 address from signature
+     */
+    getL1SignatureBody(chainId: number): string;
+}
+/**
+ * L2 Change Pub Key Transaction Info
+ */
+declare class L2ChangePubKeyTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    pubKey: Uint8Array;
+    expiredAt: bigint;
+    nonce: bigint;
+    l1Sig?: string;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        pubKey: Uint8Array;
+        expiredAt: bigint;
+        nonce: bigint;
+        l1Sig?: string;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+    /**
+     * Get L1 signature body for this change pub key transaction
+     * Used for calculating L1 address from signature
+     */
+    getL1SignatureBody(): string;
+}
+/**
+ * L2 Create Sub Account Transaction Info
+ */
+declare class L2CreateSubAccountTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        expiredAt: bigint;
+        nonce: bigint;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+}
+/**
+ * L2 Update Leverage Transaction Info
+ */
+declare class L2UpdateLeverageTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    marketIndex: number;
+    initialMarginFraction: number;
+    marginMode: number;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        marketIndex: number;
+        initialMarginFraction: number;
+        marginMode: number;
+        expiredAt: bigint;
+        nonce: bigint;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+}
+/**
+ * L2 Update Margin Transaction Info
+ */
+declare class L2UpdateMarginTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    marketIndex: number;
+    usdcAmount: bigint;
+    direction: number;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        marketIndex: number;
+        usdcAmount: bigint;
+        direction: number;
+        expiredAt: bigint;
+        nonce: bigint;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+}
+
+/**
+ * Additional Transaction Info types for pools and grouped orders
+ */
+
+/**
+ * L2 Create Grouped Orders Transaction Info
+ */
+declare class L2CreateGroupedOrdersTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    groupingType: number;
+    orders: OrderInfo[];
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        groupingType: number;
+        orders: OrderInfo[];
+        expiredAt: bigint;
+        nonce: bigint;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+}
+/**
+ * L2 Create Public Pool Transaction Info
+ */
+declare class L2CreatePublicPoolTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    operatorFee: bigint;
+    initialTotalShares: bigint;
+    minOperatorShareRate: number;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        operatorFee: bigint;
+        initialTotalShares: bigint;
+        minOperatorShareRate: number;
+        expiredAt: bigint;
+        nonce: bigint;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+}
+/**
+ * L2 Update Public Pool Transaction Info
+ */
+declare class L2UpdatePublicPoolTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    publicPoolIndex: bigint;
+    status: number;
+    operatorFee: bigint;
+    minOperatorShareRate: number;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        publicPoolIndex: bigint;
+        status: number;
+        operatorFee: bigint;
+        minOperatorShareRate: number;
+        expiredAt: bigint;
+        nonce: bigint;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+}
+/**
+ * L2 Mint Shares Transaction Info
+ */
+declare class L2MintSharesTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    publicPoolIndex: bigint;
+    shareAmount: bigint;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        publicPoolIndex: bigint;
+        shareAmount: bigint;
+        expiredAt: bigint;
+        nonce: bigint;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+}
+/**
+ * L2 Burn Shares Transaction Info
+ */
+declare class L2BurnSharesTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    publicPoolIndex: bigint;
+    shareAmount: bigint;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        publicPoolIndex: bigint;
+        shareAmount: bigint;
+        expiredAt: bigint;
+        nonce: bigint;
+    });
+    getTxType(): number;
+    validate(): void;
+    hash(chainId: number): Uint8Array;
+}
+
+/**
+ * Transaction Info Serializer
+ *
+ * Converts TypeScript TxInfo objects to JSON format compatible with the Lighter API.
+ * The API expects PascalCase field names matching the Go struct definitions.
+ */
+
+/**
+ * Serialize L2CreateOrderTxInfo to JSON
+ */
+declare function serializeCreateOrder(txInfo: L2CreateOrderTxInfo): string;
+/**
+ * Serialize L2CancelOrderTxInfo to JSON
+ */
+declare function serializeCancelOrder(txInfo: L2CancelOrderTxInfo): string;
+/**
+ * Serialize L2ModifyOrderTxInfo to JSON
+ */
+declare function serializeModifyOrder(txInfo: L2ModifyOrderTxInfo): string;
+/**
+ * Serialize L2CancelAllOrdersTxInfo to JSON
+ */
+declare function serializeCancelAllOrders(txInfo: L2CancelAllOrdersTxInfo): string;
+/**
+ * Serialize L2WithdrawTxInfo to JSON
+ */
+declare function serializeWithdraw(txInfo: L2WithdrawTxInfo): string;
+/**
+ * Serialize L2TransferTxInfo to JSON
+ */
+declare function serializeTransfer(txInfo: L2TransferTxInfo): string;
+/**
+ * Serialize L2ChangePubKeyTxInfo to JSON
+ */
+declare function serializeChangePubKey(txInfo: L2ChangePubKeyTxInfo): string;
+/**
+ * Serialize L2CreateSubAccountTxInfo to JSON
+ */
+declare function serializeCreateSubAccount(txInfo: L2CreateSubAccountTxInfo): string;
+/**
+ * Serialize L2UpdateLeverageTxInfo to JSON
+ */
+declare function serializeUpdateLeverage(txInfo: L2UpdateLeverageTxInfo): string;
+/**
+ * Serialize L2UpdateMarginTxInfo to JSON
+ */
+declare function serializeUpdateMargin(txInfo: L2UpdateMarginTxInfo): string;
+/**
+ * Serialize L2CreatePublicPoolTxInfo to JSON
+ */
+declare function serializeCreatePublicPool(txInfo: L2CreatePublicPoolTxInfo): string;
+/**
+ * Serialize L2UpdatePublicPoolTxInfo to JSON
+ */
+declare function serializeUpdatePublicPool(txInfo: L2UpdatePublicPoolTxInfo): string;
+/**
+ * Serialize L2MintSharesTxInfo to JSON
+ */
+declare function serializeMintShares(txInfo: L2MintSharesTxInfo): string;
+/**
+ * Serialize L2BurnSharesTxInfo to JSON
+ */
+declare function serializeBurnShares(txInfo: L2BurnSharesTxInfo): string;
+/**
+ * Serialize L2CreateGroupedOrdersTxInfo to JSON
+ */
+declare function serializeCreateGroupedOrders(txInfo: L2CreateGroupedOrdersTxInfo): string;
+/**
+ * Generic serializer - determines the type and calls the appropriate serializer
+ */
+declare function serializeTxInfo(txInfo: TxInfo): string;
+
+interface WebSocketConfig {
+    url?: string;
+    minReconnectionDelay?: number;
+    maxReconnectionDelay?: number;
+    maxReconnectAttempts?: number;
+    onMessage?: (data: any) => void;
+    onError?: (error: Error) => void;
+    onClose?: () => void;
+    onOpen?: () => void;
+}
+interface WebSocketSubscription<TPayload = any> {
+    channel: string;
+    auth?: string;
+    params?: Record<string, any>;
+    parser?: (payload: any) => TPayload;
+    handler?: (payload: TPayload) => void;
+}
+interface WsPriceLevel {
+    price: string;
+    size: string;
+}
+interface WsOrderBookSnapshot {
+    code: number;
+    asks: WsPriceLevel[];
+    bids: WsPriceLevel[];
+    begin_nonce: number;
+    nonce: number;
+    offset: number;
+}
+interface WsOrderBookUpdate {
+    channel: string;
+    offset: number;
+    order_book: WsOrderBookSnapshot;
+    type: "subscribed/order_book" | "update/order_book";
+}
+interface WsMarketStats {
+    market_id: number;
+    index_price: string;
+    mark_price: string;
+    open_interest: string;
+    last_trade_price: string;
+    current_funding_rate: string;
+    funding_rate: string;
+    funding_timestamp: number;
+    daily_base_token_volume: number;
+    daily_quote_token_volume: number;
+    daily_price_low: number;
+    daily_price_high: number;
+    daily_price_change: number;
+}
+interface WsMarketStatsUpdate {
+    channel: string;
+    market_stats: Record<number, WsMarketStats>;
+    type: "update/market_stats" | "subscribed/market_stats";
+}
+interface WsSpotMarketStats {
+    symbol: string;
+    market_id: number;
+    index_price: string;
+    mid_price: string;
+    last_trade_price: string;
+    daily_base_token_volume: number;
+    daily_quote_token_volume: number;
+    daily_price_low: number;
+    daily_price_high: number;
+    daily_price_change: number;
+}
+interface WsSpotMarketStatsUpdate {
+    channel: string;
+    spot_market_stats: Record<number, WsSpotMarketStats>;
+    type: "update/spot_market_stats" | "subscribed/spot_market_stats";
+}
+interface WsTrade {
+    trade_id: number;
+    tx_hash: string;
+    type: string;
+    market_id: number;
+    size: string;
+    price: string;
+    usd_amount: string;
+    ask_id: number;
+    bid_id: number;
+    ask_account_id: number;
+    bid_account_id: number;
+    is_maker_ask: boolean;
+    block_height: number;
+    timestamp: number;
+    taker_fee?: number;
+    taker_position_size_before?: string;
+    taker_entry_quote_before?: string;
+    taker_initial_margin_fraction_before?: number;
+    taker_position_sign_changed?: boolean;
+    maker_fee?: number;
+    maker_position_size_before?: string;
+    maker_entry_quote_before?: string;
+    maker_initial_margin_fraction_before?: number;
+    maker_position_sign_changed?: boolean;
+}
+interface WsTradeUpdate {
+    channel: string;
+    trades: WsTrade[];
+    type: "subscribed/trade" | "update/trade";
+}
+interface WsOrder {
+    order_index: number;
+    client_order_index: number;
+    order_id: string;
+    client_order_id: string;
+    market_index: number;
+    owner_account_index: number;
+    initial_base_amount: string;
+    price: string;
+    nonce: number;
+    remaining_base_amount: string;
+    is_ask: boolean;
+    base_size: number;
+    base_price: number;
+    filled_base_amount: string;
+    filled_quote_amount: string;
+    side: string;
+    type: string;
+    time_in_force: string;
+    reduce_only: boolean;
+    trigger_price: string;
+    order_expiry: number;
+    status: string;
+    trigger_status: string;
+    trigger_time: number;
+    parent_order_index: number;
+    parent_order_id: string;
+    to_trigger_order_id_0?: string;
+    to_trigger_order_id_1?: string;
+    to_cancel_order_id_0?: string;
+    to_cancel_order_id_1?: string;
+    block_height: number;
+    timestamp: number;
+}
+interface WsFundingHistoryEntry {
+    timestamp: number;
+    market_id: number;
+    funding_id: number;
+    change: string;
+    rate: string;
+    position_size: string;
+    position_side: string;
+}
+interface WsAccountPosition {
+    market_id: number;
+    symbol: string;
+    initial_margin_fraction: string;
+    open_order_count: number;
+    pending_order_count: number;
+    position_tied_order_count: number;
+    sign: number;
+    position: string;
+    avg_entry_price: string;
+    position_value: string;
+    unrealized_pnl: string;
+    realized_pnl: string;
+    liquidation_price: string;
+    total_funding_paid_out?: string;
+    margin_mode: number;
+    allocated_margin: string;
+}
+interface WsPoolShare {
+    public_pool_index: number;
+    shares_amount: number;
+    entry_usdc: string;
+}
+interface WsAccountAllUpdate {
+    account: number;
+    channel: string;
+    daily_trades_count: number;
+    daily_volume: number;
+    weekly_trades_count: number;
+    weekly_volume: number;
+    monthly_trades_count: number;
+    monthly_volume: number;
+    total_trades_count: number;
+    total_volume: number;
+    funding_histories: Record<string, WsFundingHistoryEntry[]>;
+    positions: Record<string, WsAccountPosition>;
+    shares: WsPoolShare[];
+    trades: Record<string, WsTrade[]>;
+    type: "subscribed/account_all" | "update/account_all";
+}
+interface WsAccountMarketUpdate {
+    account: number;
+    channel: string;
+    funding_history?: WsFundingHistoryEntry;
+    orders: WsOrder[];
+    position?: WsAccountPosition;
+    trades: WsTrade[];
+    type: "subscribed/account_market" | "update/account_market";
+}
+interface WsStatsBreakdown {
+    collateral: string;
+    portfolio_value: string;
+    leverage: string;
+    available_balance: string;
+    margin_usage: string;
+    buying_power: string;
+}
+interface WsUserStats {
+    collateral: string;
+    portfolio_value: string;
+    leverage: string;
+    available_balance: string;
+    margin_usage: string;
+    buying_power: string;
+    cross_stats: WsStatsBreakdown;
+    total_stats: WsStatsBreakdown;
+}
+interface WsUserStatsUpdate {
+    channel: string;
+    stats: WsUserStats;
+    type: "subscribed/user_stats" | "update/user_stats";
+}
+interface WsAccountAsset {
+    symbol: string;
+    asset_id: number;
+    balance: string;
+    locked_balance: string;
+}
+interface WsAccountAllAssetsUpdate {
+    channel: string;
+    assets: Record<string, WsAccountAsset>;
+    type: "subscribed/account_all_assets" | "update/account_all_assets";
+}
+interface WsTransaction {
+    hash: string;
+    type: number;
+    info: string;
+    event_info: string;
+    status: number;
+    transaction_index: number;
+    l1_address: string;
+    account_index: number;
+    nonce: number;
+    expire_at: number;
+    block_height: number;
+    queued_at: number;
+    executed_at: number;
+    sequence_index: number;
+    parent_hash: string;
+}
+interface WsTransactionUpdate {
+    channel: string;
+    txs: WsTransaction[];
+    type: "subscribed/transaction" | "update/transaction";
+}
+interface WsHeightUpdate {
+    channel: string;
+    height: number;
+    type: "subscribed/height" | "update/height";
+}
+interface WsPositionFunding {
+    timestamp: number;
+    market_id: number;
+    funding_id: number;
+    change: string;
+    rate: string;
+    position_size: string;
+    position_side: string;
+}
+interface WsPoolDataUpdate {
+    channel: string;
+    account: number;
+    trades: Record<string, WsTrade[]>;
+    orders: Record<string, WsOrder[]>;
+    positions: Record<string, WsAccountPosition>;
+    shares: WsPoolShare[];
+    funding_histories: Record<string, WsPositionFunding[]>;
+    type: "subscribed/pool_data" | "update/pool_data";
+}
+interface WsPoolInfoDailyMetric {
+    timestamp: number;
+    daily_return?: number;
+    share_price?: number;
+}
+interface WsPoolInfo {
+    status: number;
+    operator_fee: string;
+    min_operator_share_rate: string;
+    total_shares: number;
+    operator_shares: number;
+    annual_percentage_yield: number;
+    daily_returns: WsPoolInfoDailyMetric[];
+    share_prices: WsPoolInfoDailyMetric[];
+}
+interface WsPoolInfoUpdate {
+    channel: string;
+    pool_info: WsPoolInfo;
+    type: "subscribed/pool_info" | "update/pool_info";
+}
+interface WsNotificationBase {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    kind: string;
+    account_index: number;
+    ack: boolean;
+    acked_at: string | null;
+}
+interface WsLiquidationNotificationContent {
+    id: string;
+    is_ask: boolean;
+    usdc_amount: string;
+    size: string;
+    market_index: number;
+    price: string;
+    timestamp: number;
+    avg_price: string;
+}
+interface WsDeleverageNotificationContent {
+    id: string;
+    usdc_amount: string;
+    size: string;
+    market_index: number;
+    settlement_price: string;
+    timestamp: number;
+}
+interface WsAnnouncementNotificationContent {
+    title: string;
+    content: string;
+    created_at: number;
+}
+type WsNotificationContent = WsLiquidationNotificationContent | WsDeleverageNotificationContent | WsAnnouncementNotificationContent | Record<string, any>;
+interface WsNotification extends WsNotificationBase {
+    content: WsNotificationContent;
+}
+interface WsNotificationUpdate {
+    channel: string;
+    notifs: WsNotification[];
+    type: "subscribed/notification" | "update/notification";
+}
+interface WsAccountAllOrdersUpdate {
+    channel: string;
+    orders: Record<string, WsOrder[]>;
+    type: "subscribed/account_all_orders" | "update/account_all_orders";
+}
+interface WsAccountOrdersUpdate {
+    account: number;
+    channel: string;
+    nonce?: number;
+    orders: Record<string, WsOrder[]>;
+    type: "subscribed/account_orders" | "update/account_orders";
+}
+interface WsAccountAllTradesUpdate {
+    channel: string;
+    trades: Record<string, WsTrade[]>;
+    total_volume: number;
+    monthly_volume: number;
+    weekly_volume: number;
+    daily_volume: number;
+    type: "subscribed/account_all_trades" | "update/account_all_trades";
+}
+interface WsAccountAllPositionsUpdate {
+    channel: string;
+    positions: Record<string, WsAccountPosition>;
+    shares: WsPoolShare[];
+    type: "subscribed/account_all_positions" | "update/account_all_positions";
+}
+
+interface L1DepositParams {
+    ethPrivateKey: string;
+    usdcAmount: number;
+    l2AccountIndex: number;
+    rpcUrl?: string;
+    gasPrice?: string;
+    gasLimit?: number;
+}
+interface L1DepositResult {
+    l1TxHash: string;
+    l2AccountIndex: number;
+    amount: string;
+    status: "pending" | "completed" | "failed";
+    blockNumber?: number;
+    gasUsed?: string;
+}
+interface L1BridgeConfig {
+    l1BridgeContract: string;
+    usdcContract: string;
+    rpcUrl: string;
+    chainId: number;
+}
+
+/**
+ * Transaction Client for signing and managing Lighter transactions
+ */
+
+/**
+ * Transaction Client for a specific (account, apiKey) pair
+ */
+declare class TxClient {
+    private readonly apiClient;
+    private readonly chainId;
+    private readonly keyManager;
+    private readonly _accountIndex;
+    private readonly _apiKeyIndex;
+    constructor(apiClient: MinimalHTTPClient | null, privateKey: string, accountIndex: bigint, apiKeyIndex: number, chainId: number);
+    /**
+     * Fill in default transaction options
+     */
+    fulfillDefaultOpts(opts?: TransactOpts): Promise<TransactOpts>;
+    /**
+     * Get chain ID
+     */
+    getChainId(): number;
+    /**
+     * Get key manager
+     */
+    getKeyManager(): KeyManager;
+    /**
+     * Get account index
+     */
+    get accountIndex(): bigint;
+    /**
+     * Get API key index
+     */
+    get apiKeyIndex(): number;
+    /**
+     * Get HTTP client
+     */
+    http(): MinimalHTTPClient | null;
+    /**
+     * Check that the client's API key matches the one on the server
+     */
+    check(): Promise<void>;
+    /**
+     * Create an auth token
+     */
+    getAuthToken(deadline: Date): Promise<string>;
+    /**
+     * Sign a create order transaction
+     */
+    signCreateOrder(tx: CreateOrderTxReq, opts?: TransactOpts): Promise<L2CreateOrderTxInfo>;
+    /**
+     * Sign a cancel order transaction
+     */
+    signCancelOrder(tx: CancelOrderTxReq, opts?: TransactOpts): Promise<L2CancelOrderTxInfo>;
+    /**
+     * Sign a modify order transaction
+     */
+    signModifyOrder(tx: ModifyOrderTxReq, opts?: TransactOpts): Promise<L2ModifyOrderTxInfo>;
+    /**
+     * Sign a cancel all orders transaction
+     */
+    signCancelAllOrders(tx: CancelAllOrdersTxReq, opts?: TransactOpts): Promise<L2CancelAllOrdersTxInfo>;
+    /**
+     * Sign a withdraw transaction
+     */
+    signWithdraw(tx: WithdrawTxReq, opts?: TransactOpts): Promise<L2WithdrawTxInfo>;
+    /**
+     * Sign a transfer transaction
+     */
+    signTransfer(tx: TransferTxReq, opts?: TransactOpts): Promise<L2TransferTxInfo>;
+    /**
+     * Sign a change public key transaction
+     */
+    signChangePubKey(tx: ChangePubKeyReq, opts?: TransactOpts): Promise<L2ChangePubKeyTxInfo>;
+    /**
+     * Sign a create sub account transaction
+     */
+    signCreateSubAccount(opts?: TransactOpts): Promise<L2CreateSubAccountTxInfo>;
+    /**
+     * Sign an update leverage transaction
+     */
+    signUpdateLeverage(tx: UpdateLeverageTxReq, opts?: TransactOpts): Promise<L2UpdateLeverageTxInfo>;
+    /**
+     * Sign an update margin transaction
+     */
+    signUpdateMargin(tx: UpdateMarginTxReq, opts?: TransactOpts): Promise<L2UpdateMarginTxInfo>;
+    /**
+     * Sign a create grouped orders transaction
+     */
+    signCreateGroupedOrders(tx: CreateGroupedOrdersTxReq, opts?: TransactOpts): Promise<L2CreateGroupedOrdersTxInfo>;
+    /**
+     * Sign a create public pool transaction
+     */
+    signCreatePublicPool(tx: CreatePublicPoolTxReq, opts?: TransactOpts): Promise<L2CreatePublicPoolTxInfo>;
+    /**
+     * Sign an update public pool transaction
+     */
+    signUpdatePublicPool(tx: UpdatePublicPoolTxReq, opts?: TransactOpts): Promise<L2UpdatePublicPoolTxInfo>;
+    /**
+     * Sign a mint shares transaction
+     */
+    signMintShares(tx: MintSharesTxReq, opts?: TransactOpts): Promise<L2MintSharesTxInfo>;
+    /**
+     * Sign a burn shares transaction
+     */
+    signBurnShares(tx: BurnSharesTxReq, opts?: TransactOpts): Promise<L2BurnSharesTxInfo>;
+}
+
+/**
+ * Client Manager for handling multiple TxClients
+ * Similar to the Go SDK's SharedClientManager
+ */
+
+declare const DEFAULT_API_KEY_INDEX = 255;
+declare const DEFAULT_ACCOUNT_INDEX = -1n;
+/**
+ * Get a client for specific account and API key
+ */
+declare function getClient(apiKeyIndex?: number, accountIndex?: bigint): TxClient;
+/**
+ * Create a new TxClient and store it
+ */
+declare function createClient(httpClient: MinimalHTTPClient | null, privateKey: string, chainId: number, apiKeyIndex: number, accountIndex: bigint): TxClient;
+/**
+ * Check that a client exists and the API key matches the one on the server
+ */
+declare function checkClient(apiKeyIndex?: number, accountIndex?: bigint): Promise<void>;
+
+/**
+ * Clear all stored clients (useful for testing)
+ */
+declare function clearClients(): void;
+/**
+ * Get the default client
+ */
+declare function getDefaultClient(): TxClient | null;
+
+interface AccountRequest {
+    by: "index" | "l1_address";
+    value: string;
+}
+interface AccountPosition {
+    market_id: number;
+    symbol: string;
+    initial_margin_fraction: string;
+    open_order_count: number;
+    pending_order_count: number;
+    position_tied_order_count: number;
+    sign: number;
+    position: string;
+    avg_entry_price: string;
+    position_value: string;
+    unrealized_pnl: string;
+    realized_pnl: string;
+    liquidation_price: string;
+    margin_mode: number;
+    allocated_margin: string;
+}
+interface AccountAsset {
+    symbol: string;
+    asset_id: number;
+    balance: string;
+    locked_balance: string;
+}
+interface AccountShare {
+    public_pool_index: number;
+    shares_amount: number;
+    entry_usdc: string;
+}
+interface AccountInfo {
+    code: number;
+    message?: string;
+    account_type: number;
+    index: number;
+    l1_address: string;
+    cancel_all_time: number;
+    total_order_count: number;
+    total_isolated_order_count: number;
+    pending_order_count: number;
+    available_balance: string;
+    status: number;
+    collateral: string;
+    account_index: number;
+    name: string;
+    description: string;
+    can_invite: boolean;
+    referral_points_percentage: string;
+    positions: AccountPosition[];
+    assets: AccountAsset[];
+    total_asset_value: string;
+    cross_asset_value: string;
+    shares: AccountShare[];
+}
+interface AccountResponse {
+    code: number;
+    message?: string;
+    total: number;
+    accounts: AccountInfo[];
+}
+declare function getAccountInfo(client: AxiosInstance, params: AccountRequest): Promise<AccountResponse>;
+
+interface AccountByL1AddressRequest {
+    l1_address: string;
+}
+interface AccountAccountByL1AddressResponse {
+    code: number;
+    message?: string;
+    account_index: number;
+    l1_address: string;
+}
+declare function getAccountByL1Address(client: AxiosInstance, params: AccountByL1AddressRequest): Promise<AccountAccountByL1AddressResponse>;
+
+interface Announcement {
+    id: number;
+    title: string;
+    content: string;
+    created_at: number;
+    updated_at: number;
+    is_active: boolean;
+}
+interface AnnouncementsResponse {
+    code: number;
+    message?: string;
+    announcements: Announcement[];
+}
+declare function getAnnouncements(client: AxiosInstance): Promise<AnnouncementsResponse>;
+
+interface ApiKeysRequest {
+    account_index: number;
+    api_key_index: number;
+}
+interface ApiKey {
+    account_index: number;
+    api_key_index: number;
+    nonce: number;
+    public_key: string;
+    transaction_time: number;
+}
+interface ApiKeysResponse {
+    api_keys: ApiKey[];
+}
+declare function getApiKeys(client: AxiosInstance, params: ApiKeysRequest): Promise<ApiKeysResponse>;
+
+interface AssetDetailsRequest {
+    asset_id?: number;
+}
+interface AssetDetail {
+    asset_id: number;
+    symbol: string;
+    l1_decimals: number;
+    decimals: number;
+    extension_multiplier: number;
+    min_transfer_amount: number;
+    min_withdrawal_amount: number;
+    margin_mode: number;
+    index_price: number;
+    l1_address: string;
+    tick_size: string;
+}
+interface AssetDetailsResponse {
+    code: number;
+    message?: string;
+    asset_details: AssetDetail[];
+}
+declare function getAssetDetails(client: AxiosInstance, params?: AssetDetailsRequest): Promise<AssetDetailsResponse>;
+
+interface Candlestick {
+    t: number;
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    v: number;
+}
+interface CandlesRequest {
+    market_id: number;
+    resolution: string;
+    start_timestamp: number;
+    end_timestamp: number;
+    count_back: number;
+}
+interface CandlesResponse {
+    c: Candlestick[];
+}
+declare function getCandlesticks(client: AxiosInstance, params: CandlesRequest): Promise<CandlesResponse>;
+
+interface ExchangeStatsResponse {
+    total_volume_24h: string;
+    total_trades_24h: number;
+    total_orders_24h: number;
+    active_markets: number;
+}
+declare function getExchangeStats(client: AxiosInstance): Promise<ExchangeStatsResponse>;
+
+interface FastBridgeInfoResponse {
+    code: number;
+    message?: string;
+    fast_bridge_limit: string;
+}
+declare function getFastBridgeInfo(client: AxiosInstance): Promise<FastBridgeInfoResponse>;
+
+interface FundingRate {
+    market_id: number;
+    exchange: "binance" | "bybit" | "hyperliquid" | "lighter";
+    symbol: string;
+    rate: number;
+}
+interface FundingRatesResponse {
+    code: number;
+    message?: string;
+    funding_rates: FundingRate[];
+}
+declare function getFundingRates(client: AxiosInstance): Promise<FundingRatesResponse>;
+
+interface Funding {
+    timestamp: number;
+    market_id: number;
+    funding_id: number;
+    rate: string;
+}
+interface FundingsRequest {
+    market_id: number;
+    resolution: string;
+    start_timestamp?: number;
+    end_timestamp?: number;
+    count_back?: number;
+}
+interface FundingsResponse {
+    fundings: Funding[];
+}
+declare function getFundings(client: AxiosInstance, params: FundingsRequest): Promise<FundingsResponse>;
+
+interface NextNonceRequest {
+    account_index: number;
+    api_key_index: number;
+}
+interface NextNonceResponse {
+    account_index: number;
+    api_key_index: number;
+    nonce: number;
+}
+declare function getNextNonce(client: AxiosInstance, params: NextNonceRequest): Promise<NextNonceResponse>;
+
+interface OrderBookDetailsRequest {
+    market_id?: number;
+}
+interface OrderBookDetail {
+    symbol: string;
+    market_id: number;
+    market_type: string;
+    status: string;
+    taker_fee: string;
+    maker_fee: string;
+    liquidation_fee: string;
+    min_base_amount: string;
+    min_quote_amount: string;
+    order_quote_limit: string;
+    supported_size_decimals: number;
+    supported_price_decimals: number;
+    supported_quote_decimals: number;
+    size_decimals: number;
+    price_decimals: number;
+    quote_multiplier: number;
+    default_initial_margin_fraction: number;
+    min_initial_margin_fraction: number;
+    maintenance_margin_fraction: number;
+    closeout_margin_fraction: number;
+    last_trade_price: number;
+    daily_trades_count: number;
+    daily_base_token_volume: number;
+    daily_quote_token_volume: number;
+    daily_price_low: number;
+    daily_price_high: number;
+    daily_price_change: number;
+    open_interest: number;
+    daily_chart: any;
+    market_config: {
+        market_margin_mode: number;
+        insurance_fund_account_index: number;
+    };
+}
+interface SpotOrderBookDetail {
+    symbol: string;
+    market_id: number;
+    market_type: string;
+    base_asset_id: string;
+    quote_asset_id: string;
+    status: string;
+    taker_fee: string;
+    maker_fee: string;
+    liquidation_fee: string;
+    min_base_amount: string;
+    min_quote_amount: string;
+    order_quote_limit: string;
+    supported_size_decimals: number;
+    supported_price_decimals: number;
+    supported_quote_decimals: number;
+    size_decimals: number;
+    price_decimals: number;
+    last_trade_price: number;
+    daily_trades_count: number;
+    daily_base_token_volume: number;
+    daily_quote_token_volume: number;
+    daily_price_low: number;
+    daily_price_high: number;
+    daily_price_change: number;
+}
+interface OrderBookDetailsResponse {
+    code: number;
+    order_book_details: OrderBookDetail[];
+    spot_order_book_details: SpotOrderBookDetail[];
+}
+declare function getOrderBookDetails(client: AxiosInstance, params?: OrderBookDetailsRequest): Promise<OrderBookDetailsResponse>;
+interface OrderBookOrdersRequest {
+    market_id: number;
+    limit?: number;
+}
+interface OrderBookOrder {
+    order_index: number;
+    order_id: string;
+    owner_account_index: number;
+    initial_base_amount: string;
+    remaining_base_amount: string;
+    price: string;
+    order_expiry: number;
+}
+interface OrderBookOrdersResponse {
+    code?: number;
+    total_asks?: number;
+    total_bids?: number;
+    bids?: OrderBookOrder[];
+    asks?: OrderBookOrder[];
+}
+declare function getOrderBookOrders(client: AxiosInstance, params: OrderBookOrdersRequest): Promise<OrderBookOrdersResponse>;
+
+interface PriceLevel {
+    price: string;
+    size: string;
+}
+interface OrderBook {
+    market_id: number;
+    bids: PriceLevel[];
+    asks: PriceLevel[];
+    last_update_id: string;
+}
+type OrderBooksResponse = OrderBook[];
+declare function getOrderBooks(client: AxiosInstance): Promise<OrderBooksResponse>;
+
+interface TradesRequest {
+    auth?: string;
+    market_id?: number;
+    account_index?: number;
+    order_index?: number;
+    sort_by: "block_height" | "timestamp" | "trade_id";
+    sort_dir?: "desc";
+    cursor?: string;
+    from?: number;
+    ask_filter?: number;
+    limit: number;
+}
+interface Trade {
+    trade_id: number;
+    tx_hash: string;
+    type: "trade" | "liquidation" | "deleverage";
+    market_id: number;
+    size: string;
+    price: string;
+    usd_amount: string;
+    ask_id: number;
+    bid_id: number;
+    ask_account_id: number;
+    bid_account_id: number;
+    is_maker_ask: boolean;
+    block_height: number;
+    timestamp: number;
+    taker_fee: number;
+    taker_position_size_before: string;
+    taker_entry_quote_before: string;
+    taker_initial_margin_fraction_before: number;
+    taker_position_sign_changed: boolean;
+    maker_fee: number;
+    maker_position_size_before: string;
+    maker_entry_quote_before: string;
+    maker_initial_margin_fraction_before: number;
+    maker_position_sign_changed: boolean;
+}
+interface TradesResponse {
+    code: number;
+    message?: string;
+    next_cursor?: string;
+    trades: Trade[];
+}
+declare function getTrades(client: AxiosInstance, params: TradesRequest, authorization?: string): Promise<TradesResponse>;
+
+interface RecentTradesRequest {
+    market_id: number;
+    limit: number;
+}
+type RecentTradesResponse = Trade[];
+declare function getRecentTrades(client: AxiosInstance, params: RecentTradesRequest): Promise<RecentTradesResponse>;
+
+interface RootInfoResponse {
+    contract_address: string;
+}
+declare function getRootInfo(client: AxiosInstance): Promise<RootInfoResponse>;
+
+interface RootStatusResponse {
+    status: number;
+    network_id: number;
+    timestamp: string;
+}
+declare function getRootStatus(client: AxiosInstance): Promise<RootStatusResponse>;
+
+interface TransactionRequest {
+    by: "hash" | "index";
+    value: string;
+}
+interface Transaction {
+    hash: string;
+    block_height: number;
+    sequence_index: number;
+    account_index: number;
+    nonce: number;
+    type: string | number;
+    info?: string;
+    event_info?: string;
+    data?: any;
+    status: number | "pending" | "confirmed" | "failed";
+    transaction_index?: number;
+    l1_address?: string;
+    expire_at?: number;
+    queued_at?: number;
+    committed_at?: number;
+    verified_at?: number;
+    executed_at?: number;
+    parent_hash?: string;
+    created_at?: string;
+    updated_at?: string;
+    code?: number;
+    message?: string;
+}
+declare function getTransaction(client: AxiosInstance, params: TransactionRequest): Promise<Transaction>;
+
+interface TransactionFromL1TxHashRequest {
+    l1_tx_hash: string;
+}
+declare function getTransactionFromL1TxHash(client: AxiosInstance, params: TransactionFromL1TxHashRequest): Promise<Transaction>;
+
+interface TransactionsRequest {
+    cursor?: string;
+    limit?: number;
+}
+type TransactionsResponse = Transaction[];
+declare function getTransactions(client: AxiosInstance, params?: TransactionsRequest): Promise<TransactionsResponse>;
+
+interface WithdrawalDelayResponse {
+    seconds: number;
+}
+declare function getWithdrawalDelay(client: AxiosInstance): Promise<WithdrawalDelayResponse>;
+
+type index$2_AccountAccountByL1AddressResponse = AccountAccountByL1AddressResponse;
+type index$2_AccountAsset = AccountAsset;
+type index$2_AccountByL1AddressRequest = AccountByL1AddressRequest;
+type index$2_AccountInfo = AccountInfo;
+type index$2_AccountPosition = AccountPosition;
+type index$2_AccountRequest = AccountRequest;
+type index$2_AccountResponse = AccountResponse;
+type index$2_AccountShare = AccountShare;
+type index$2_Announcement = Announcement;
+type index$2_AnnouncementsResponse = AnnouncementsResponse;
+type index$2_ApiKey = ApiKey;
+type index$2_ApiKeysRequest = ApiKeysRequest;
+type index$2_ApiKeysResponse = ApiKeysResponse;
+type index$2_AssetDetail = AssetDetail;
+type index$2_AssetDetailsRequest = AssetDetailsRequest;
+type index$2_AssetDetailsResponse = AssetDetailsResponse;
+type index$2_CandlesRequest = CandlesRequest;
+type index$2_CandlesResponse = CandlesResponse;
+type index$2_Candlestick = Candlestick;
+type index$2_ExchangeStatsResponse = ExchangeStatsResponse;
+type index$2_FastBridgeInfoResponse = FastBridgeInfoResponse;
+type index$2_Funding = Funding;
+type index$2_FundingRate = FundingRate;
+type index$2_FundingRatesResponse = FundingRatesResponse;
+type index$2_FundingsRequest = FundingsRequest;
+type index$2_FundingsResponse = FundingsResponse;
+type index$2_NextNonceRequest = NextNonceRequest;
+type index$2_NextNonceResponse = NextNonceResponse;
+type index$2_OrderBook = OrderBook;
+type index$2_OrderBookDetail = OrderBookDetail;
+type index$2_OrderBookDetailsRequest = OrderBookDetailsRequest;
+type index$2_OrderBookDetailsResponse = OrderBookDetailsResponse;
+type index$2_OrderBookOrder = OrderBookOrder;
+type index$2_OrderBookOrdersRequest = OrderBookOrdersRequest;
+type index$2_OrderBookOrdersResponse = OrderBookOrdersResponse;
+type index$2_OrderBooksResponse = OrderBooksResponse;
+type index$2_PriceLevel = PriceLevel;
+type index$2_RecentTradesRequest = RecentTradesRequest;
+type index$2_RecentTradesResponse = RecentTradesResponse;
+type index$2_RootInfoResponse = RootInfoResponse;
+type index$2_RootStatusResponse = RootStatusResponse;
+type index$2_SpotOrderBookDetail = SpotOrderBookDetail;
+type index$2_Transaction = Transaction;
+type index$2_TransactionFromL1TxHashRequest = TransactionFromL1TxHashRequest;
+type index$2_TransactionRequest = TransactionRequest;
+type index$2_TransactionsRequest = TransactionsRequest;
+type index$2_TransactionsResponse = TransactionsResponse;
+type index$2_WithdrawalDelayResponse = WithdrawalDelayResponse;
+declare const index$2_getAccountByL1Address: typeof getAccountByL1Address;
+declare const index$2_getAccountInfo: typeof getAccountInfo;
+declare const index$2_getAnnouncements: typeof getAnnouncements;
+declare const index$2_getApiKeys: typeof getApiKeys;
+declare const index$2_getAssetDetails: typeof getAssetDetails;
+declare const index$2_getCandlesticks: typeof getCandlesticks;
+declare const index$2_getExchangeStats: typeof getExchangeStats;
+declare const index$2_getFastBridgeInfo: typeof getFastBridgeInfo;
+declare const index$2_getFundingRates: typeof getFundingRates;
+declare const index$2_getFundings: typeof getFundings;
+declare const index$2_getNextNonce: typeof getNextNonce;
+declare const index$2_getOrderBookDetails: typeof getOrderBookDetails;
+declare const index$2_getOrderBookOrders: typeof getOrderBookOrders;
+declare const index$2_getOrderBooks: typeof getOrderBooks;
+declare const index$2_getRecentTrades: typeof getRecentTrades;
+declare const index$2_getRootInfo: typeof getRootInfo;
+declare const index$2_getRootStatus: typeof getRootStatus;
+declare const index$2_getTransaction: typeof getTransaction;
+declare const index$2_getTransactionFromL1TxHash: typeof getTransactionFromL1TxHash;
+declare const index$2_getTransactions: typeof getTransactions;
+declare const index$2_getWithdrawalDelay: typeof getWithdrawalDelay;
+declare namespace index$2 {
+  export { type index$2_AccountAccountByL1AddressResponse as AccountAccountByL1AddressResponse, type index$2_AccountAsset as AccountAsset, type index$2_AccountByL1AddressRequest as AccountByL1AddressRequest, type index$2_AccountInfo as AccountInfo, type index$2_AccountPosition as AccountPosition, type index$2_AccountRequest as AccountRequest, type index$2_AccountResponse as AccountResponse, type index$2_AccountShare as AccountShare, type index$2_Announcement as Announcement, type index$2_AnnouncementsResponse as AnnouncementsResponse, type index$2_ApiKey as ApiKey, type index$2_ApiKeysRequest as ApiKeysRequest, type index$2_ApiKeysResponse as ApiKeysResponse, type index$2_AssetDetail as AssetDetail, type index$2_AssetDetailsRequest as AssetDetailsRequest, type index$2_AssetDetailsResponse as AssetDetailsResponse, type index$2_CandlesRequest as CandlesRequest, type index$2_CandlesResponse as CandlesResponse, type index$2_Candlestick as Candlestick, type index$2_ExchangeStatsResponse as ExchangeStatsResponse, type index$2_FastBridgeInfoResponse as FastBridgeInfoResponse, type index$2_Funding as Funding, type index$2_FundingRate as FundingRate, type index$2_FundingRatesResponse as FundingRatesResponse, type index$2_FundingsRequest as FundingsRequest, type index$2_FundingsResponse as FundingsResponse, type index$2_NextNonceRequest as NextNonceRequest, type index$2_NextNonceResponse as NextNonceResponse, type index$2_OrderBook as OrderBook, type index$2_OrderBookDetail as OrderBookDetail, type index$2_OrderBookDetailsRequest as OrderBookDetailsRequest, type index$2_OrderBookDetailsResponse as OrderBookDetailsResponse, type index$2_OrderBookOrder as OrderBookOrder, type index$2_OrderBookOrdersRequest as OrderBookOrdersRequest, type index$2_OrderBookOrdersResponse as OrderBookOrdersResponse, type index$2_OrderBooksResponse as OrderBooksResponse, type index$2_PriceLevel as PriceLevel, type index$2_RecentTradesRequest as RecentTradesRequest, type index$2_RecentTradesResponse as RecentTradesResponse, type index$2_RootInfoResponse as RootInfoResponse, type index$2_RootStatusResponse as RootStatusResponse, type index$2_SpotOrderBookDetail as SpotOrderBookDetail, type index$2_Transaction as Transaction, type index$2_TransactionFromL1TxHashRequest as TransactionFromL1TxHashRequest, type index$2_TransactionRequest as TransactionRequest, type index$2_TransactionsRequest as TransactionsRequest, type index$2_TransactionsResponse as TransactionsResponse, type index$2_WithdrawalDelayResponse as WithdrawalDelayResponse, index$2_getAccountByL1Address as getAccountByL1Address, index$2_getAccountInfo as getAccountInfo, index$2_getAnnouncements as getAnnouncements, index$2_getApiKeys as getApiKeys, index$2_getAssetDetails as getAssetDetails, index$2_getCandlesticks as getCandlesticks, index$2_getExchangeStats as getExchangeStats, index$2_getFastBridgeInfo as getFastBridgeInfo, index$2_getFundingRates as getFundingRates, index$2_getFundings as getFundings, index$2_getNextNonce as getNextNonce, index$2_getOrderBookDetails as getOrderBookDetails, index$2_getOrderBookOrders as getOrderBookOrders, index$2_getOrderBooks as getOrderBooks, index$2_getRecentTrades as getRecentTrades, index$2_getRootInfo as getRootInfo, index$2_getRootStatus as getRootStatus, index$2_getTransaction as getTransaction, index$2_getTransactionFromL1TxHash as getTransactionFromL1TxHash, index$2_getTransactions as getTransactions, index$2_getWithdrawalDelay as getWithdrawalDelay };
+}
+
+interface InfoClientConfig {
+    baseURL?: string;
+}
+/**
+ * InfoClient - Client for public info endpoints
+ *
+ * Provides access to all public API endpoints that don't require authentication.
+ *
+ * @example
+ * ```typescript
+ * const client = new InfoClient({
+ *   baseURL: "https://mainnet.zklighter.elliot.ai"
+ * });
+ *
+ * const account = await client.getAccountInfo({ by: "index", value: "0" });
+ * const orderBooks = await client.getOrderBooks();
+ * ```
+ */
+declare class InfoClient {
+    private readonly config;
+    private readonly axiosInstance;
+    constructor(config?: InfoClientConfig);
+    private createAxiosInstance;
+    /**
+     * Get account information by index or L2 address
+     * @param params - Account lookup parameters (by index or L2 address)
+     * @returns Account information including balances and positions
+     * @example
+     * ```typescript
+     * const account = await client.getAccountInfo({ by: "index", value: "0" });
+     * ```
+     */
+    getAccountInfo(params: AccountRequest): Promise<AccountResponse>;
+    /**
+     * Get account information by L1 address
+     * @param params - L1 address lookup parameters
+     * @returns Account information associated with the L1 address
+     * @example
+     * ```typescript
+     * const account = await client.getAccountByL1Address({ l1_address: "0x..." });
+     * ```
+     */
+    getAccountByL1Address(params: AccountByL1AddressRequest): Promise<AccountAccountByL1AddressResponse>;
+    /**
+     * Get API keys for an account
+     * @param params - Account index to retrieve API keys for
+     * @returns List of API keys associated with the account
+     * @example
+     * ```typescript
+     * const keys = await client.getApiKeys({ account_index: 0 });
+     * ```
+     */
+    getApiKeys(params: ApiKeysRequest): Promise<ApiKeysResponse>;
+    /**
+     * Get system announcements
+     * @returns List of active announcements
+     * @example
+     * ```typescript
+     * const announcements = await client.getAnnouncements();
+     * ```
+     */
+    getAnnouncements(): Promise<AnnouncementsResponse>;
+    /**
+     * Get asset details for a specific asset or all assets
+     * @param params - Optional asset_index to get details for a specific asset
+     * @returns Asset details including symbol, decimals, limits, and pricing information
+     * @example
+     * ```typescript
+     * // Get all assets
+     * const allAssets = await client.getAssetDetails();
+     *
+     * // Get specific asset
+     * const asset = await client.getAssetDetails({ asset_index: 0 });
+     * ```
+     */
+    getAssetDetails(params?: AssetDetailsRequest): Promise<AssetDetailsResponse>;
+    /**
+     * Get candlestick data for a market
+     * @param params - Candlestick query parameters including market_id, resolution, and time range
+     * @returns Array of candlestick data
+     * @example
+     * ```typescript
+     * const candles = await client.getCandlesticks({
+     *   market_id: 1,
+     *   resolution: "1h",
+     *   start_timestamp: 1234567890,
+     *   end_timestamp: 1234567900
+     * });
+     * ```
+     */
+    getCandlesticks(params: CandlesRequest): Promise<CandlesResponse>;
+    /**
+     * Get funding history for a market
+     * @param params - Funding query parameters including market_id and time range
+     * @returns Array of funding data
+     * @example
+     * ```typescript
+     * const fundings = await client.getFundings({
+     *   market_id: 1,
+     *   start_timestamp: 1234567890,
+     *   end_timestamp: 1234567900
+     * });
+     * ```
+     */
+    getFundings(params: FundingsRequest): Promise<FundingsResponse>;
+    /**
+     * Get exchange statistics
+     * @returns Exchange-wide statistics including volume, fees, and markets
+     * @example
+     * ```typescript
+     * const stats = await client.getExchangeStats();
+     * ```
+     */
+    getExchangeStats(): Promise<ExchangeStatsResponse>;
+    /**
+     * Get fast bridge information
+     * @returns Fast bridge configuration and status
+     * @example
+     * ```typescript
+     * const bridgeInfo = await client.getFastBridgeInfo();
+     * ```
+     */
+    getFastBridgeInfo(): Promise<FastBridgeInfoResponse>;
+    /**
+     * Get current funding rates for all markets
+     * @returns Funding rates for all markets
+     * @example
+     * ```typescript
+     * const rates = await client.getFundingRates();
+     * ```
+     */
+    getFundingRates(): Promise<FundingRatesResponse>;
+    /**
+     * Get the next nonce for an account
+     * @param params - Account index to get nonce for
+     * @returns Next nonce value
+     * @example
+     * ```typescript
+     * const nonce = await client.getNextNonce({ account_index: 0 });
+     * ```
+     */
+    getNextNonce(params: NextNonceRequest): Promise<NextNonceResponse>;
+    /**
+     * Get all order books
+     * @returns List of all order books with their configurations
+     * @example
+     * ```typescript
+     * const orderBooks = await client.getOrderBooks();
+     * ```
+     */
+    getOrderBooks(): Promise<OrderBooksResponse>;
+    /**
+     * Get detailed information about a specific order book
+     * @param params - Optional market_id to get details for a specific market
+     * @returns Order book details including market information
+     * @example
+     * ```typescript
+     * const details = await client.getOrderBookDetails({ market_id: 1 });
+     * ```
+     */
+    getOrderBookDetails(params?: OrderBookDetailsRequest): Promise<OrderBookDetailsResponse>;
+    /**
+     * Get orders in an order book
+     * @param params - Market ID and optional depth/limit parameters
+     * @returns Bids and asks in the order book
+     * @example
+     * ```typescript
+     * const orders = await client.getOrderBookOrders({ market_id: 1, limit: 50 });
+     * ```
+     */
+    getOrderBookOrders(params: OrderBookOrdersRequest): Promise<OrderBookOrdersResponse>;
+    /**
+     * Get recent trades for a market
+     * @param params - Market ID and optional limit
+     * @returns Recent trades for the market
+     * @example
+     * ```typescript
+     * const trades = await client.getRecentTrades({ market_id: 1, limit: 50 });
+     * ```
+     */
+    getRecentTrades(params: RecentTradesRequest): Promise<RecentTradesResponse>;
+    /**
+     * Get a specific transaction by hash
+     * @param params - Transaction hash to look up
+     * @returns Transaction details
+     * @example
+     * ```typescript
+     * const tx = await client.getTransaction({ tx_hash: "0x..." });
+     * ```
+     */
+    getTransaction(params: TransactionRequest): Promise<Transaction>;
+    /**
+     * Get transactions with optional filtering
+     * @param params - Optional filter parameters for transaction queries
+     * @returns List of transactions
+     * @example
+     * ```typescript
+     * const txs = await client.getTransactions({ limit: 50 });
+     * ```
+     */
+    getTransactions(params?: TransactionsRequest): Promise<TransactionsResponse>;
+    /**
+     * Get L2 transaction from L1 transaction hash
+     * @param params - L1 transaction hash
+     * @returns Corresponding L2 transaction
+     * @example
+     * ```typescript
+     * const tx = await client.getTransactionFromL1TxHash({ l1_tx_hash: "0x..." });
+     * ```
+     */
+    getTransactionFromL1TxHash(params: TransactionFromL1TxHashRequest): Promise<Transaction>;
+    /**
+     * Get withdrawal delay in seconds
+     * @returns Withdrawal delay configuration
+     * @example
+     * ```typescript
+     * const delay = await client.getWithdrawalDelay();
+     * console.log(`Withdrawal delay: ${delay.seconds} seconds`);
+     * ```
+     */
+    getWithdrawalDelay(): Promise<WithdrawalDelayResponse>;
+    /**
+     * Get root status information
+     * @returns Root status including network status, network_id, and timestamp
+     * @example
+     * ```typescript
+     * const status = await client.getRootStatus();
+     * ```
+     */
+    getRootStatus(): Promise<RootStatusResponse>;
+}
+
+interface Order {
+    order_index: number;
+    client_order_index: number;
+    order_id: string;
+    client_order_id: string;
+    market_index: number;
+    owner_account_index: number;
+    initial_base_amount: string;
+    price: string;
+    nonce: number;
+    remaining_base_amount: string;
+    is_ask: boolean;
+    base_size: number;
+    base_price: number;
+    filled_base_amount: string;
+    filled_quote_amount: string;
+    side: string;
+    type: string;
+    time_in_force: string;
+    reduce_only: boolean;
+    trigger_price: string;
+    order_expiry: number;
+    status: string;
+    trigger_status: string;
+    trigger_time: number;
+    parent_order_index: number;
+    parent_order_id: string;
+    to_trigger_order_id_0?: string;
+    to_trigger_order_id_1?: string;
+    to_cancel_order_id_0?: string;
+    to_cancel_order_id_1?: string;
+    block_height: number;
+    timestamp: number;
+}
+interface Orders {
+    code: number;
+    orders: Order[];
+}
+interface AccountInactiveOrdersRequest {
+    account_index: number;
+    limit: number;
+    auth?: string;
+    market_id?: number;
+    ask_filter?: number;
+    between_timestamps?: string;
+    cursor?: string;
+}
+declare function getAccountInactiveOrders(client: AxiosInstance, params: AccountInactiveOrdersRequest, authorization?: string): Promise<Orders>;
+
+interface AccountActiveOrdersRequest {
+    account_index: number;
+    market_id: number;
+    auth?: string;
+}
+declare function getAccountActiveOrders(client: AxiosInstance, params: AccountActiveOrdersRequest, authorization?: string): Promise<Orders>;
+
+interface AccountLimitsRequest {
+    account_index: number;
+    auth?: string;
+}
+interface AccountLimitsResponse {
+    code: number;
+    message?: string;
+    max_llp_percentage: number;
+    user_tier: string;
+    can_create_public_pool: boolean;
+}
+declare function getAccountLimits(client: AxiosInstance, params: AccountLimitsRequest, authorization?: string): Promise<AccountLimitsResponse>;
+
+interface AccountMetadataRequest {
+    by: "index" | "l1_address";
+    value: string;
+    auth?: string;
+}
+interface AccountMetadataInfo {
+    account_index: number;
+    name: string;
+    description: string;
+    can_invite: boolean;
+    referral_points_percentage: string;
+}
+interface AccountMetadataResponse {
+    code: number;
+    message?: string;
+    account_metadatas: AccountMetadataInfo;
+}
+declare function getAccountMetadata(client: AxiosInstance, params: AccountMetadataRequest, authorization?: string): Promise<AccountMetadataResponse>;
+
+interface DepositHistoryRequest {
+    account_index: number;
+    l1_address: string;
+    cursor?: string;
+    filter?: string;
+}
+interface DepositHistoryItem {
+    id: string;
+    account_index: number;
+    l1_address: string;
+    l2_address: string;
+    amount: string;
+    l1_tx_hash: string;
+    status: string;
+    timestamp: number;
+    created_at: string;
+}
+interface DepositHistoryResponse {
+    code: number;
+    deposits: DepositHistoryItem[];
+    cursor?: string;
+}
+declare function getDepositHistory(client: AxiosInstance, params: DepositHistoryRequest, authorization?: string): Promise<DepositHistoryResponse>;
+
+interface ExportRequest {
+    type: "funding" | "trade";
+    account_index?: number;
+    market_id?: number;
+    auth?: string;
+}
+interface ExportResponse {
+    code: number;
+    message?: string;
+    data_url: string;
+}
+declare function getExport(client: AxiosInstance, params: ExportRequest, authorization?: string): Promise<ExportResponse>;
+
+interface FastWithdrawInfoRequest {
+    account_index: number;
+    auth?: string;
+}
+interface FastWithdrawInfoResponse {
+    code: number;
+    message?: string;
+    to_account_index: number;
+    withdraw_limit: string;
+    max_withdrawal_amount: string;
+}
+declare function getFastWithdrawInfo(client: AxiosInstance, params: FastWithdrawInfoRequest, authorization?: string): Promise<FastWithdrawInfoResponse>;
+
+interface L1MetadataRequest {
+    l1_address: string;
+    auth?: string;
+}
+interface L1MetadataResponse {
+    code: number;
+    message?: string;
+    l1_address: string;
+    can_invite: boolean;
+    referral_points_percentage: string;
+}
+declare function getL1Metadata(client: AxiosInstance, params: L1MetadataRequest, authorization?: string): Promise<L1MetadataResponse>;
+
+interface LiquidationsRequest {
+    account_index: number;
+    market_id?: number;
+    cursor?: string;
+    limit: number;
+    auth?: string;
+}
+interface LiquidationTrade {
+    price: string;
+    size: string;
+    taker_fee: string;
+    maker_fee: string;
+}
+interface LiquidationPosition {
+    market_id: number;
+    symbol: string;
+    initial_margin_fraction: string;
+    open_order_count: number;
+    pending_order_count: number;
+    position_tied_order_count: number;
+    sign: number;
+    position: string;
+    avg_entry_price: string;
+    position_value: string;
+    unrealized_pnl: string;
+    realized_pnl: string;
+    liquidation_price: string;
+    total_funding_paid_out?: string;
+    margin_mode: number;
+    allocated_margin: string;
+}
+interface RiskParameters {
+    market_id: number;
+    collateral: string;
+    total_account_value: string;
+    initial_margin_req: string;
+    maintenance_margin_req: string;
+    close_out_margin_req: string;
+}
+interface RiskInfo {
+    cross_risk_parameters: RiskParameters;
+    isolated_risk_parameters: RiskParameters[];
+}
+interface LiquidationInfoObject {
+    positions: LiquidationPosition[];
+    risk_info_before: RiskInfo;
+    risk_info_after: RiskInfo;
+    mark_prices: Record<string, any>;
+}
+interface LiquidationInfo {
+    id: string;
+    market_id: number;
+    type: "partial" | "deleverage";
+    trade: LiquidationTrade;
+    info: LiquidationInfoObject;
+    executed_at: number;
+}
+interface LiquidationsResponse {
+    code: number;
+    liquidations: LiquidationInfo[];
+}
+declare function getLiquidations(client: AxiosInstance, params: LiquidationsRequest, authorization?: string): Promise<LiquidationsResponse>;
+
+interface PnLRequest {
+    by: string;
+    value: string;
+    resolution: string;
+    start_timestamp: number;
+    end_timestamp: number;
+    count_back: number;
+    auth?: string;
+    ignore_transfers?: boolean;
+}
+interface PnLEntry {
+    timestamp: number;
+    pnl: string;
+    cumulative_pnl: string;
+}
+interface PnLResponse {
+    code: number;
+    entries: PnLEntry[];
+}
+declare function getPnL(client: AxiosInstance, params: PnLRequest, authorization?: string): Promise<PnLResponse>;
+
+interface PositionFundingRequest {
+    account_index: number;
+    limit: number;
+    market_id?: number;
+    cursor?: string;
+    side?: "long" | "short" | "all";
+    auth?: string;
+}
+interface PositionFundingItem {
+    timestamp: number;
+    market_id: number;
+    funding_id: number;
+    change: string;
+    rate: string;
+    position_size: string;
+    position_side: "long" | "short";
+}
+interface PositionFundingResponse {
+    code: number;
+    message?: string;
+    position_fundings: PositionFundingItem[];
+    next_cursor?: string;
+}
+declare function getPositionFunding(client: AxiosInstance, params: PositionFundingRequest, authorization?: string): Promise<PositionFundingResponse>;
+
+interface PublicPoolsRequest {
+    filter?: string;
+    limit?: number;
+    index?: number;
+}
+interface PublicPoolShare {
+    token: string;
+    amount: string;
+    value: string;
+}
+interface PublicPool {
+    id: string;
+    name: string;
+    description: string;
+    total_value_locked: string;
+    apy: string;
+    shares: PublicPoolShare[];
+}
+type PublicPoolsResponse = PublicPool[];
+declare function getPublicPools(client: AxiosInstance, params?: PublicPoolsRequest, authorization?: string): Promise<PublicPoolsResponse>;
+
+interface ReferralPointsRequest {
+    account_index: number;
+}
+interface ReferralPointEntry {
+    l1_address: string;
+    total_points: number;
+    week_points: number;
+    total_reward_points: number;
+    week_reward_points: number;
+    reward_point_multiplier: string;
+}
+interface ReferralPointsResponse {
+    referrals: ReferralPointEntry[];
+    user_total_points: number;
+    user_last_week_points: number;
+    user_total_referral_reward_points: number;
+    user_last_week_referral_reward_points: number;
+    reward_point_multiplier: string;
+}
+declare function getReferralPoints(client: AxiosInstance, params: ReferralPointsRequest, authorization?: string): Promise<ReferralPointsResponse>;
+
+interface TokensRequest {
+    account_index: number;
+    auth?: string;
+}
+interface ApiToken {
+    token_id: number;
+    api_token: string;
+    name: string;
+    account_index: number;
+    expiry: number;
+    sub_account_access: boolean;
+    revoked: boolean;
+    scopes: string;
+}
+interface TokensResponse {
+    code: number;
+    message?: string;
+    api_tokens: ApiToken[];
+}
+declare function getTokens(client: AxiosInstance, params: TokensRequest, authorization?: string): Promise<TokensResponse>;
+
+interface TransferFeeInfoRequest {
+    account_index: number;
+    to_account_index?: number;
+    auth?: string;
+}
+interface TransferFeeInfoResponse {
+    code: number;
+    message?: string;
+    transfer_fee_usdc: number;
+}
+declare function getTransferFeeInfo(client: AxiosInstance, params: TransferFeeInfoRequest, authorization?: string): Promise<TransferFeeInfoResponse>;
+
+interface TransferHistoryRequest {
+    account_index: number;
+    cursor?: string;
+    auth?: string;
+}
+interface Transfer {
+    id: string;
+    amount: string;
+    timestamp: number;
+    type: "L2TransferInflow" | "L2TransferOutflow" | "L2BurnSharesInflow" | "L2BurnSharesOutflow" | "L2MintSharesInflow" | "L2MintSharesOutflow";
+    from_l1_address: string;
+    to_l1_address: string;
+    from_account_index: number;
+    to_account_index: number;
+    tx_hash: string;
+}
+interface TransferHistoryResponse {
+    code: number;
+    message?: string;
+    transfers: Transfer[];
+    cursor: string;
+}
+declare function getTransferHistory(client: AxiosInstance, params: TransferHistoryRequest, authorization?: string): Promise<TransferHistoryResponse>;
+
+interface WithdrawHistoryRequest {
+    account_index: number;
+    l1_address: string;
+    cursor?: string;
+    filter?: string;
+}
+interface WithdrawHistoryItem {
+    id: string;
+    account_index: number;
+    l1_address: string;
+    l2_address: string;
+    amount: string;
+    l1_tx_hash: string;
+    status: string;
+    timestamp: number;
+    created_at: string;
+}
+interface WithdrawHistoryResponse {
+    code: number;
+    withdrawals: WithdrawHistoryItem[];
+    cursor?: string;
+}
+declare function getWithdrawHistory(client: AxiosInstance, params: WithdrawHistoryRequest, authorization?: string): Promise<WithdrawHistoryResponse>;
+
+type index$1_AccountActiveOrdersRequest = AccountActiveOrdersRequest;
+type index$1_AccountInactiveOrdersRequest = AccountInactiveOrdersRequest;
+type index$1_AccountLimitsRequest = AccountLimitsRequest;
+type index$1_AccountLimitsResponse = AccountLimitsResponse;
+type index$1_AccountMetadataInfo = AccountMetadataInfo;
+type index$1_AccountMetadataRequest = AccountMetadataRequest;
+type index$1_AccountMetadataResponse = AccountMetadataResponse;
+type index$1_ApiToken = ApiToken;
+type index$1_DepositHistoryItem = DepositHistoryItem;
+type index$1_DepositHistoryRequest = DepositHistoryRequest;
+type index$1_DepositHistoryResponse = DepositHistoryResponse;
+type index$1_ExportRequest = ExportRequest;
+type index$1_ExportResponse = ExportResponse;
+type index$1_FastWithdrawInfoRequest = FastWithdrawInfoRequest;
+type index$1_FastWithdrawInfoResponse = FastWithdrawInfoResponse;
+type index$1_L1MetadataRequest = L1MetadataRequest;
+type index$1_L1MetadataResponse = L1MetadataResponse;
+type index$1_LiquidationInfo = LiquidationInfo;
+type index$1_LiquidationInfoObject = LiquidationInfoObject;
+type index$1_LiquidationPosition = LiquidationPosition;
+type index$1_LiquidationTrade = LiquidationTrade;
+type index$1_LiquidationsRequest = LiquidationsRequest;
+type index$1_LiquidationsResponse = LiquidationsResponse;
+type index$1_Order = Order;
+type index$1_Orders = Orders;
+type index$1_PnLEntry = PnLEntry;
+type index$1_PnLRequest = PnLRequest;
+type index$1_PnLResponse = PnLResponse;
+type index$1_PositionFundingItem = PositionFundingItem;
+type index$1_PositionFundingRequest = PositionFundingRequest;
+type index$1_PositionFundingResponse = PositionFundingResponse;
+type index$1_PublicPool = PublicPool;
+type index$1_PublicPoolShare = PublicPoolShare;
+type index$1_PublicPoolsRequest = PublicPoolsRequest;
+type index$1_PublicPoolsResponse = PublicPoolsResponse;
+type index$1_ReferralPointEntry = ReferralPointEntry;
+type index$1_ReferralPointsRequest = ReferralPointsRequest;
+type index$1_ReferralPointsResponse = ReferralPointsResponse;
+type index$1_RiskInfo = RiskInfo;
+type index$1_RiskParameters = RiskParameters;
+type index$1_TokensRequest = TokensRequest;
+type index$1_TokensResponse = TokensResponse;
+type index$1_Trade = Trade;
+type index$1_TradesRequest = TradesRequest;
+type index$1_TradesResponse = TradesResponse;
+type index$1_Transfer = Transfer;
+type index$1_TransferFeeInfoRequest = TransferFeeInfoRequest;
+type index$1_TransferFeeInfoResponse = TransferFeeInfoResponse;
+type index$1_TransferHistoryRequest = TransferHistoryRequest;
+type index$1_TransferHistoryResponse = TransferHistoryResponse;
+type index$1_WithdrawHistoryItem = WithdrawHistoryItem;
+type index$1_WithdrawHistoryRequest = WithdrawHistoryRequest;
+type index$1_WithdrawHistoryResponse = WithdrawHistoryResponse;
+declare const index$1_getAccountActiveOrders: typeof getAccountActiveOrders;
+declare const index$1_getAccountInactiveOrders: typeof getAccountInactiveOrders;
+declare const index$1_getAccountLimits: typeof getAccountLimits;
+declare const index$1_getAccountMetadata: typeof getAccountMetadata;
+declare const index$1_getDepositHistory: typeof getDepositHistory;
+declare const index$1_getExport: typeof getExport;
+declare const index$1_getFastWithdrawInfo: typeof getFastWithdrawInfo;
+declare const index$1_getL1Metadata: typeof getL1Metadata;
+declare const index$1_getLiquidations: typeof getLiquidations;
+declare const index$1_getPnL: typeof getPnL;
+declare const index$1_getPositionFunding: typeof getPositionFunding;
+declare const index$1_getPublicPools: typeof getPublicPools;
+declare const index$1_getReferralPoints: typeof getReferralPoints;
+declare const index$1_getTokens: typeof getTokens;
+declare const index$1_getTrades: typeof getTrades;
+declare const index$1_getTransferFeeInfo: typeof getTransferFeeInfo;
+declare const index$1_getTransferHistory: typeof getTransferHistory;
+declare const index$1_getWithdrawHistory: typeof getWithdrawHistory;
+declare namespace index$1 {
+  export { type index$1_AccountActiveOrdersRequest as AccountActiveOrdersRequest, type index$1_AccountInactiveOrdersRequest as AccountInactiveOrdersRequest, type index$1_AccountLimitsRequest as AccountLimitsRequest, type index$1_AccountLimitsResponse as AccountLimitsResponse, type index$1_AccountMetadataInfo as AccountMetadataInfo, type index$1_AccountMetadataRequest as AccountMetadataRequest, type index$1_AccountMetadataResponse as AccountMetadataResponse, type index$1_ApiToken as ApiToken, type index$1_DepositHistoryItem as DepositHistoryItem, type index$1_DepositHistoryRequest as DepositHistoryRequest, type index$1_DepositHistoryResponse as DepositHistoryResponse, type index$1_ExportRequest as ExportRequest, type index$1_ExportResponse as ExportResponse, type index$1_FastWithdrawInfoRequest as FastWithdrawInfoRequest, type index$1_FastWithdrawInfoResponse as FastWithdrawInfoResponse, type index$1_L1MetadataRequest as L1MetadataRequest, type index$1_L1MetadataResponse as L1MetadataResponse, type index$1_LiquidationInfo as LiquidationInfo, type index$1_LiquidationInfoObject as LiquidationInfoObject, type index$1_LiquidationPosition as LiquidationPosition, type index$1_LiquidationTrade as LiquidationTrade, type index$1_LiquidationsRequest as LiquidationsRequest, type index$1_LiquidationsResponse as LiquidationsResponse, type index$1_Order as Order, type index$1_Orders as Orders, type index$1_PnLEntry as PnLEntry, type index$1_PnLRequest as PnLRequest, type index$1_PnLResponse as PnLResponse, type index$1_PositionFundingItem as PositionFundingItem, type index$1_PositionFundingRequest as PositionFundingRequest, type index$1_PositionFundingResponse as PositionFundingResponse, type index$1_PublicPool as PublicPool, type index$1_PublicPoolShare as PublicPoolShare, type index$1_PublicPoolsRequest as PublicPoolsRequest, type index$1_PublicPoolsResponse as PublicPoolsResponse, type index$1_ReferralPointEntry as ReferralPointEntry, type index$1_ReferralPointsRequest as ReferralPointsRequest, type index$1_ReferralPointsResponse as ReferralPointsResponse, type index$1_RiskInfo as RiskInfo, type index$1_RiskParameters as RiskParameters, type index$1_TokensRequest as TokensRequest, type index$1_TokensResponse as TokensResponse, type index$1_Trade as Trade, type index$1_TradesRequest as TradesRequest, type index$1_TradesResponse as TradesResponse, type index$1_Transfer as Transfer, type index$1_TransferFeeInfoRequest as TransferFeeInfoRequest, type index$1_TransferFeeInfoResponse as TransferFeeInfoResponse, type index$1_TransferHistoryRequest as TransferHistoryRequest, type index$1_TransferHistoryResponse as TransferHistoryResponse, type index$1_WithdrawHistoryItem as WithdrawHistoryItem, type index$1_WithdrawHistoryRequest as WithdrawHistoryRequest, type index$1_WithdrawHistoryResponse as WithdrawHistoryResponse, index$1_getAccountActiveOrders as getAccountActiveOrders, index$1_getAccountInactiveOrders as getAccountInactiveOrders, index$1_getAccountLimits as getAccountLimits, index$1_getAccountMetadata as getAccountMetadata, index$1_getDepositHistory as getDepositHistory, index$1_getExport as getExport, index$1_getFastWithdrawInfo as getFastWithdrawInfo, index$1_getL1Metadata as getL1Metadata, index$1_getLiquidations as getLiquidations, index$1_getPnL as getPnL, index$1_getPositionFunding as getPositionFunding, index$1_getPublicPools as getPublicPools, index$1_getReferralPoints as getReferralPoints, index$1_getTokens as getTokens, index$1_getTrades as getTrades, index$1_getTransferFeeInfo as getTransferFeeInfo, index$1_getTransferHistory as getTransferHistory, index$1_getWithdrawHistory as getWithdrawHistory };
+}
+
+interface InfoPrivateClientConfig {
+    baseURL?: string;
+    txClient: TxClient;
+}
+/**
+ * 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
+ * });
+ * ```
+ */
+declare class InfoPrivateClient {
+    private readonly baseURL;
+    private readonly axiosInstance;
+    private readonly txClient;
+    constructor(config: InfoPrivateClientConfig);
+    private createAxiosInstance;
+    /**
+     * Get the axios instance for custom requests
+     */
+    getAxiosInstance(): 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
+     * });
+     * ```
+     */
+    getAccountActiveOrders(params: AccountActiveOrdersRequest): Promise<Orders>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    getAccountInactiveOrders(params: AccountInactiveOrdersRequest): Promise<Orders>;
+    /**
+     * 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 });
+     * ```
+     */
+    getAccountLimits(params: AccountLimitsRequest): Promise<AccountLimitsResponse>;
+    /**
+     * 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 });
+     * ```
+     */
+    getAccountMetadata(params: AccountMetadataRequest): Promise<AccountMetadataResponse>;
+    /**
+     * 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...' });
+     * ```
+     */
+    getL1Metadata(params: L1MetadataRequest): Promise<L1MetadataResponse>;
+    /**
+     * 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 });
+     * ```
+     */
+    getTokens(params: TokensRequest): Promise<TokensResponse>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    getDepositHistory(params: DepositHistoryRequest): Promise<DepositHistoryResponse>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    getWithdrawHistory(params: WithdrawHistoryRequest): Promise<WithdrawHistoryResponse>;
+    /**
+     * 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 });
+     * ```
+     */
+    getFastWithdrawInfo(params: FastWithdrawInfoRequest): Promise<FastWithdrawInfoResponse>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    getTransferFeeInfo(params: TransferFeeInfoRequest): Promise<TransferFeeInfoResponse>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    getTransferHistory(params: TransferHistoryRequest): Promise<TransferHistoryResponse>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    getLiquidations(params: LiquidationsRequest): Promise<LiquidationsResponse>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    getPnL(params: PnLRequest): Promise<PnLResponse>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    getPositionFunding(params: PositionFundingRequest): Promise<PositionFundingResponse>;
+    /**
+     * 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 });
+     * ```
+     */
+    getPublicPools(params?: PublicPoolsRequest): Promise<PublicPoolsResponse>;
+    /**
+     * 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 });
+     * ```
+     */
+    getReferralPoints(params: ReferralPointsRequest): Promise<ReferralPointsResponse>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    getTrades(params: TradesRequest): Promise<TradesResponse>;
+    /**
+     * 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'
+     * });
+     * ```
+     */
+    getExport(params: ExportRequest): Promise<ExportResponse>;
+}
+
+interface ChangeAccountTierRequest {
+    account_index: number;
+    new_tier: string;
+    auth?: string;
+}
+interface ChangeAccountTierResponse {
+    code: number;
+    message?: string;
+}
+declare function changeAccountTier(client: AxiosInstance, params: ChangeAccountTierRequest, authorization?: string): Promise<ChangeAccountTierResponse>;
+
+interface FastWithdrawRequest {
+    tx_info: string;
+    to_address: string;
+    auth?: string;
+}
+interface FastWithdrawResponse {
+    code: number;
+    message?: string;
+}
+declare function fastWithdraw(client: AxiosInstance, params: FastWithdrawRequest, authorization?: string): Promise<FastWithdrawResponse>;
+
+interface NotificationAckRequest {
+    notif_id: string;
+    account_index: number;
+}
+interface NotificationAckResponse {
+    code: number;
+    message?: string;
+}
+declare function acknowledgeNotification(client: AxiosInstance, params: NotificationAckRequest, authorization?: string): Promise<NotificationAckResponse>;
+
+interface SendTransactionRequest {
+    account_index: number;
+    api_key_index: number;
+    transaction: string;
+    price_protection?: boolean;
+}
+interface SendTxFormRequest {
+    tx_type: number;
+    tx_info: string;
+    price_protection?: boolean;
+}
+interface SendTxWithIndicesRequest {
+    tx_type: number;
+    tx_info: string;
+    account_index: number;
+    api_key_index: number;
+    price_protection?: boolean;
+}
+interface TxHashResponse {
+    hash?: string;
+    tx_hash?: string;
+    code?: number;
+    message?: string;
+    predicted_execution_time_ms?: number;
+}
+declare function sendTransaction(client: AxiosInstance, params: SendTransactionRequest): Promise<TxHashResponse>;
+declare function sendTx(client: AxiosInstance, params: SendTxFormRequest): Promise<TxHashResponse>;
+declare function sendTxWithIndices(client: AxiosInstance, params: SendTxWithIndicesRequest): Promise<TxHashResponse>;
+declare function sendTxJson(client: AxiosInstance, params: SendTxWithIndicesRequest): Promise<TxHashResponse>;
+
+interface SendTransactionBatchFormRequest {
+    tx_types: string;
+    tx_infos: string;
+}
+interface SendTransactionBatchJsonRequest {
+    account_index: number;
+    api_key_index: number;
+    transactions: string[];
+}
+type SendTransactionBatchRequest = SendTransactionBatchFormRequest | SendTransactionBatchJsonRequest;
+interface TxHashesResponse {
+    hashes?: string[];
+    tx_hash?: string[];
+    code?: number;
+    message?: string;
+    predicted_execution_time_ms?: number;
+}
+declare function sendTransactionBatch(client: AxiosInstance, params: SendTransactionBatchRequest): Promise<TxHashesResponse>;
+
+interface TokensCreateRequest {
+    name: string;
+    account_index: number;
+    expiry: number;
+    sub_account_access: boolean;
+    scopes?: string;
+}
+interface TokensCreateResponse {
+    code: number;
+    message?: string;
+    token_id: number;
+    api_token: string;
+    name: string;
+    account_index: number;
+    expiry: number;
+    sub_account_access: boolean;
+    revoked: boolean;
+    scopes: string;
+}
+declare function createToken(client: AxiosInstance, params: TokensCreateRequest, authorization?: string): Promise<TokensCreateResponse>;
+
+interface TokensRevokeRequest {
+    token_id: number;
+    account_index: number;
+}
+interface TokensRevokeResponse {
+    code: number;
+    message?: string;
+    token_id: number;
+    revoked: boolean;
+}
+declare function revokeToken(client: AxiosInstance, params: TokensRevokeRequest, authorization?: string): Promise<TokensRevokeResponse>;
+
+type index_ChangeAccountTierRequest = ChangeAccountTierRequest;
+type index_ChangeAccountTierResponse = ChangeAccountTierResponse;
+type index_FastWithdrawRequest = FastWithdrawRequest;
+type index_FastWithdrawResponse = FastWithdrawResponse;
+type index_NotificationAckRequest = NotificationAckRequest;
+type index_NotificationAckResponse = NotificationAckResponse;
+type index_SendTransactionBatchFormRequest = SendTransactionBatchFormRequest;
+type index_SendTransactionBatchJsonRequest = SendTransactionBatchJsonRequest;
+type index_SendTransactionBatchRequest = SendTransactionBatchRequest;
+type index_SendTransactionRequest = SendTransactionRequest;
+type index_SendTxFormRequest = SendTxFormRequest;
+type index_SendTxWithIndicesRequest = SendTxWithIndicesRequest;
+type index_TokensCreateRequest = TokensCreateRequest;
+type index_TokensCreateResponse = TokensCreateResponse;
+type index_TokensRevokeRequest = TokensRevokeRequest;
+type index_TokensRevokeResponse = TokensRevokeResponse;
+type index_TxHashResponse = TxHashResponse;
+type index_TxHashesResponse = TxHashesResponse;
+declare const index_acknowledgeNotification: typeof acknowledgeNotification;
+declare const index_changeAccountTier: typeof changeAccountTier;
+declare const index_createToken: typeof createToken;
+declare const index_fastWithdraw: typeof fastWithdraw;
+declare const index_revokeToken: typeof revokeToken;
+declare const index_sendTransaction: typeof sendTransaction;
+declare const index_sendTransactionBatch: typeof sendTransactionBatch;
+declare const index_sendTx: typeof sendTx;
+declare const index_sendTxJson: typeof sendTxJson;
+declare const index_sendTxWithIndices: typeof sendTxWithIndices;
+declare namespace index {
+  export { type index_ChangeAccountTierRequest as ChangeAccountTierRequest, type index_ChangeAccountTierResponse as ChangeAccountTierResponse, type index_FastWithdrawRequest as FastWithdrawRequest, type index_FastWithdrawResponse as FastWithdrawResponse, type index_NotificationAckRequest as NotificationAckRequest, type index_NotificationAckResponse as NotificationAckResponse, type index_SendTransactionBatchFormRequest as SendTransactionBatchFormRequest, type index_SendTransactionBatchJsonRequest as SendTransactionBatchJsonRequest, type index_SendTransactionBatchRequest as SendTransactionBatchRequest, type index_SendTransactionRequest as SendTransactionRequest, type index_SendTxFormRequest as SendTxFormRequest, type index_SendTxWithIndicesRequest as SendTxWithIndicesRequest, type index_TokensCreateRequest as TokensCreateRequest, type index_TokensCreateResponse as TokensCreateResponse, type index_TokensRevokeRequest as TokensRevokeRequest, type index_TokensRevokeResponse as TokensRevokeResponse, type index_TxHashResponse as TxHashResponse, type index_TxHashesResponse as TxHashesResponse, index_acknowledgeNotification as acknowledgeNotification, index_changeAccountTier as changeAccountTier, index_createToken as createToken, index_fastWithdraw as fastWithdraw, index_revokeToken as revokeToken, index_sendTransaction as sendTransaction, index_sendTransactionBatch as sendTransactionBatch, index_sendTx as sendTx, index_sendTxJson as sendTxJson, index_sendTxWithIndices as sendTxWithIndices };
+}
+
+interface ExchangeClientConfig {
+    baseURL?: string;
+    txClient: TxClient;
+}
+/**
+ * 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),
+ * });
+ * ```
+ */
+declare class ExchangeClient {
+    private readonly baseURL;
+    private readonly axiosInstance;
+    private readonly txClient;
+    constructor(config: ExchangeClientConfig);
+    private createAxiosInstance;
+    /**
+     * Create an auth token using the TxClient
+     */
+    private createAuthToken;
+    /**
+     * Get the axios instance for custom requests
+     */
+    getAxiosInstance(): AxiosInstance;
+    /**
+     * Get the TxClient for direct signing operations
+     */
+    getTxClient(): TxClient;
+    /**
+     * Send a transaction
+     */
+    sendTransaction(params: SendTransactionRequest): Promise<TxHashResponse>;
+    /**
+     * Send a transaction with form data
+     */
+    sendTx(params: SendTxFormRequest): Promise<TxHashResponse>;
+    /**
+     * Send a transaction with account and API key indices
+     */
+    sendTxWithIndices(params: SendTxWithIndicesRequest): Promise<TxHashResponse>;
+    /**
+     * Send a transaction with JSON payload
+     */
+    sendTxJson(params: SendTxWithIndicesRequest): Promise<TxHashResponse>;
+    /**
+     * Send a batch of transactions
+     */
+    sendTransactionBatch(params: SendTransactionBatchRequest): Promise<TxHashesResponse>;
+    /**
+     * Create and send an order using TypeScript signing
+     */
+    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>;
+    /**
+     * Cancel an order using TypeScript signing
+     */
+    cancelOrder(params: {
+        marketIndex: number;
+        orderIndex: bigint;
+        priceProtection?: boolean;
+    }): Promise<TxHashResponse>;
+    /**
+     * Cancel all orders using TypeScript signing
+     */
+    cancelAllOrders(params: {
+        timeInForce: number;
+        time: bigint;
+        priceProtection?: boolean;
+    }): Promise<TxHashResponse>;
+    /**
+     * Transfer funds using TypeScript signing
+     */
+    transfer(params: {
+        toAccountIndex: bigint;
+        assetIndex: number;
+        fromRouteType: number;
+        toRouteType: number;
+        amount: bigint;
+        usdcFee: bigint;
+        memo: string;
+        priceProtection?: boolean;
+    }): Promise<TxHashResponse>;
+    /**
+     * Withdraw funds using TypeScript signing
+     */
+    withdraw(params: {
+        assetIndex: number;
+        routeType: number;
+        amount: bigint;
+        priceProtection?: boolean;
+    }): Promise<TxHashResponse>;
+    /**
+     * Update leverage using TypeScript signing
+     */
+    updateLeverage(params: {
+        marketIndex: number;
+        initialMarginFraction: number;
+        marginMode: number;
+        priceProtection?: boolean;
+    }): Promise<TxHashResponse>;
+    /**
+     * Modify an order using TypeScript signing
+     */
+    modifyOrder(params: {
+        marketIndex: number;
+        index: bigint;
+        baseAmount: bigint;
+        price: number;
+        triggerPrice: number;
+        priceProtection?: boolean;
+    }): Promise<TxHashResponse>;
+    /**
+     * Create a subaccount using TypeScript signing
+     */
+    createSubAccount(params?: {
+        priceProtection?: boolean;
+    }): Promise<TxHashResponse>;
+    /**
+     * Create a public pool using TypeScript signing
+     */
+    createPublicPool(params: {
+        operatorFee: bigint;
+        initialTotalShares: bigint;
+        minOperatorShareRate: number;
+        priceProtection?: boolean;
+    }): Promise<TxHashResponse>;
+    /**
+     * Update a public pool using TypeScript signing
+     */
+    updatePublicPool(params: {
+        publicPoolIndex: bigint;
+        status: number;
+        operatorFee: bigint;
+        minOperatorShareRate: number;
+        priceProtection?: boolean;
+    }): Promise<TxHashResponse>;
+    /**
+     * Mint shares using TypeScript signing
+     */
+    mintShares(params: {
+        publicPoolIndex: bigint;
+        shareAmount: bigint;
+        priceProtection?: boolean;
+    }): Promise<TxHashResponse>;
+    /**
+     * Burn shares using TypeScript signing
+     */
+    burnShares(params: {
+        publicPoolIndex: bigint;
+        shareAmount: bigint;
+        priceProtection?: boolean;
+    }): Promise<TxHashResponse>;
+    /**
+     * Update margin using TypeScript signing
+     */
+    updateMargin(params: {
+        marketIndex: number;
+        usdcAmount: bigint;
+        direction: number;
+        priceProtection?: boolean;
+    }): Promise<TxHashResponse>;
+    /**
+     * Create grouped orders using TypeScript signing
+     */
+    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>;
+    /**
+     * Create multiple orders in a batch using TypeScript signing
+     */
+    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>;
+    /**
+     * Generate change public key L1 sign message
+     */
+    generateChangePubKeyL1SignMessage(pubKeyHex: string, nonce: number, accountIndex: bigint, newApiKeyIndex: number): string;
+    /**
+     * Change public key using TypeScript signing
+     */
+    changePubKey(params: {
+        pubKey: string;
+        l1Sig: string;
+        priceProtection?: boolean;
+    }): Promise<TxHashResponse>;
+    /**
+     * Acknowledge a notification
+     */
+    acknowledgeNotification(params: NotificationAckRequest): Promise<NotificationAckResponse>;
+    /**
+     * Change account tier
+     */
+    changeAccountTier(params: ChangeAccountTierRequest): Promise<ChangeAccountTierResponse>;
+    /**
+     * Fast withdraw funds
+     */
+    fastWithdraw(params: FastWithdrawRequest): Promise<FastWithdrawResponse>;
+    /**
+     * Create API token
+     */
+    createToken(params: TokensCreateRequest): Promise<TokensCreateResponse>;
+    /**
+     * Revoke API token
+     */
+    revokeToken(params: TokensRevokeRequest): Promise<TokensRevokeResponse>;
+}
+
+type Unsubscribe = () => void;
+declare class WsClient {
+    private ws;
+    private config;
+    private readonly url;
+    private messageHandlers;
+    constructor(config?: WebSocketConfig);
+    connect(): void;
+    disconnect(): void;
+    private subscribe;
+    subscribeOrderBook(marketIndex: number, handler: (update: WsOrderBookUpdate) => void): Unsubscribe;
+    subscribeMarketStats(market: number | "all", handler: (update: WsMarketStatsUpdate) => void): Unsubscribe;
+    subscribeSpotMarketStats(market: number | "all", handler: (update: WsSpotMarketStatsUpdate) => void): Unsubscribe;
+    subscribeTrades(marketIndex: number, handler: (update: WsTradeUpdate) => void): Unsubscribe;
+    subscribeAccountAll(accountId: number, handler: (update: WsAccountAllUpdate) => void): Unsubscribe;
+    subscribeAccountMarket(marketId: number, accountId: number, auth: string, handler: (update: WsAccountMarketUpdate) => void): Unsubscribe;
+    subscribeUserStats(accountId: number, handler: (update: WsUserStatsUpdate) => void): Unsubscribe;
+    subscribeAccountAllAssets(accountId: number, auth: string, handler: (update: WsAccountAllAssetsUpdate) => void): Unsubscribe;
+    subscribeTransactions(handler: (update: WsTransactionUpdate) => void): Unsubscribe;
+    subscribeExecutedTransactions(handler: (update: WsTransactionUpdate) => void): Unsubscribe;
+    subscribeAccountTransactions(accountId: number, auth: string, handler: (update: WsTransactionUpdate) => void): Unsubscribe;
+    subscribeAccountAllOrders(accountId: number, auth: string, handler: (update: WsAccountAllOrdersUpdate) => void): Unsubscribe;
+    subscribeHeight(handler: (update: WsHeightUpdate) => void): Unsubscribe;
+    subscribePoolData(accountId: number, auth: string, handler: (update: WsPoolDataUpdate) => void): Unsubscribe;
+    subscribePoolInfo(accountId: number, auth: string, handler: (update: WsPoolInfoUpdate) => void): Unsubscribe;
+    subscribeNotifications(accountId: number, auth: string, handler: (update: WsNotificationUpdate) => void): Unsubscribe;
+    subscribeAccountOrders(marketIndex: number, accountId: number, auth: string, handler: (update: WsAccountOrdersUpdate) => void): Unsubscribe;
+    subscribeAccountAllTrades(accountId: number, auth: string, handler: (update: WsAccountAllTradesUpdate) => void): Unsubscribe;
+    subscribeAccountAllPositions(accountId: number, auth: string, handler: (update: WsAccountAllPositionsUpdate) => void): Unsubscribe;
+    send(message: any): void;
+    private normalizeChannel;
+    private passthroughParser;
+    private handleSubscriptionMessage;
+    private resubscribeAll;
+    getSubscriptions(): string[];
+}
+
+/**
+ * Goldilocks field element
+ */
+declare class GoldilocksElement {
+    readonly value: bigint;
+    constructor(value: bigint);
+    add(other: GoldilocksElement): GoldilocksElement;
+    sub(other: GoldilocksElement): GoldilocksElement;
+    mul(other: GoldilocksElement): GoldilocksElement;
+    square(): GoldilocksElement;
+    static fromUint32(value: number): GoldilocksElement;
+    static fromInt64(value: bigint): GoldilocksElement;
+    static fromUint64(value: bigint): GoldilocksElement;
+    static zero(): GoldilocksElement;
+    static one(): GoldilocksElement;
+    toLittleEndianBytes(): Uint8Array;
+    static fromLittleEndianBytes(bytes: Uint8Array): GoldilocksElement;
+}
+/**
+ * Convert bytes to Goldilocks field elements
+ * Each element holds up to 7 bytes of data
+ */
+declare function bytesToFieldElements(bytes: Uint8Array): GoldilocksElement[];
+
+/**
+ * Poseidon2 hash function over Goldilocks field (Plonky2 variant)
+ *
+ * This is a correct implementation matching the Go poseidon_crypto library.
+ * Constants are taken from the Plonky3/Plonky2 reference implementation.
+ */
+
+/**
+ * Poseidon2 permutation
+ */
+declare function permute(state: bigint[]): void;
+/**
+ * Poseidon2 sponge hash function
+ * Compatible with Go HashToQuinticExtension
+ */
+declare function poseidon2Hash(inputs: GoldilocksElement[]): GoldilocksElement[];
+/**
+ * Hash field elements to a quintic extension element (40 bytes)
+ */
+declare function hashToQuinticExtension(elements: GoldilocksElement[]): Uint8Array;
+
+/**
+ * ECgFp5 Scalar Field
+ *
+ * The scalar field for ECgFp5 curve with prime order ~2^319
+ * ORDER = 1067993516717146951041484916571792702745057740581727230159139685185762082554198619328292418486241
+ *
+ * Ported from Go poseidon_crypto/curve/ecgfp5/scalar_field.go
+ */
+
+declare const ORDER = 1067993516717146951041484916571792702745057740581727230159139685185762082554198619328292418486241n;
+
+export { ApiMaxOrderType, AssetMarginMode, type AssetMarginModeValue, AssetRouteType, type AssetRouteTypeValue, type BurnSharesTxReq, type CancelAllOrdersTxReq, CancelAllTimeInForce, type CancelAllTimeInForceValue, type CancelOrderTxReq, type ChangePubKeyReq, type CreateGroupedOrdersTxReq, type CreateOrderTxReq, type CreatePublicPoolTxReq, DEFAULT_ACCOUNT_INDEX, DEFAULT_API_KEY_INDEX, DEFAULT_EXPIRE_TIME_MS, ECgFp5Point, ECgFp5Scalar, ErrAccountIndexTooHigh, ErrAccountIndexTooLow, ErrApiKeyIndexTooHigh, ErrApiKeyIndexTooLow, ErrAssetIndexTooHigh, ErrAssetIndexTooLow, ErrBaseAmountTooHigh, ErrBaseAmountTooLow, ErrCancelAllTimeInForceInvalid, ErrCancelAllTimeTooHigh, ErrCancelAllTimeTooLow, ErrClientOrderIndexTooHigh, ErrClientOrderIndexTooLow, ErrExpiredAtInvalid, ErrFromAccountIndexTooHigh, ErrFromAccountIndexTooLow, ErrGroupingTypeInvalid, ErrInitialTotalSharesTooHigh, ErrInitialTotalSharesTooLow, ErrInvalidMarketIndex, ErrInvalidPublicKeyLength, ErrIsAskInvalid, ErrMarginDirectionInvalid, ErrMarginModeInvalid, ErrMinOperatorShareRateTooHigh, ErrNoOrdersInGroup, ErrNonceTooLow, ErrOperatorFeeTooHigh, ErrOperatorFeeTooLow, ErrOrderExpiryInvalid, ErrOrderIndexTooHigh, ErrOrderIndexTooLow, ErrOrderReduceOnlyInvalid, ErrOrderTimeInForceInvalid, ErrOrderTriggerPriceInvalid, ErrOrderTypeInvalid, ErrPriceTooHigh, ErrPriceTooLow, ErrPublicPoolIndexTooLow, ErrRouteTypeInvalid, ErrShareAmountTooHigh, ErrShareAmountTooLow, ErrToAccountIndexTooHigh, ErrToAccountIndexTooLow, ErrTooManyGroupedOrders, ErrTransferAmountTooHigh, ErrTransferAmountTooLow, ErrTransferFeeNegative, ErrTransferFeeTooHigh, ErrUSDCAmountTooHigh, ErrUSDCAmountTooLow, ErrWithdrawalAmountTooHigh, ErrWithdrawalAmountTooLow, index as ExchangeApi, ExchangeClient, FEE_TICK, FETCH_NONCE_FROM_SERVER, GFp5Element, GoldilocksElement, GroupingType, type GroupingTypeValue, HttpClient, INITIAL_POOL_SHARE_VALUE, index$2 as InfoApi, InfoClient, index$1 as InfoPrivateApi, InfoPrivateClient, type KeyManager, type L1BridgeConfig, type L1DepositParams, type L1DepositResult, L2BurnSharesTxInfo, L2CancelAllOrdersTxInfo, L2CancelOrderTxInfo, L2ChangePubKeyTxInfo, L2CreateGroupedOrdersTxInfo, L2CreateOrderTxInfo, L2CreatePublicPoolTxInfo, L2CreateSubAccountTxInfo, L2MintSharesTxInfo, L2ModifyOrderTxInfo, L2TransferTxInfo, L2UpdateLeverageTxInfo, L2UpdateMarginTxInfo, L2UpdatePublicPoolTxInfo, L2WithdrawTxInfo, MARGIN_FRACTION_TICK, MAX_ACCOUNT_INDEX, MAX_API_KEY_INDEX, MAX_ASSET_INDEX, MAX_BURNT_SHARE_USDC_VALUE, MAX_CLIENT_ORDER_INDEX, MAX_GROUPED_ORDER_COUNT, MAX_INITIAL_TOTAL_SHARES, MAX_INVESTED_PUBLIC_POOL_COUNT, MAX_MASTER_ACCOUNT_INDEX, MAX_ORDER_BASE_AMOUNT, MAX_ORDER_CANCEL_ALL_PERIOD, MAX_ORDER_EXPIRY, MAX_ORDER_EXPIRY_PERIOD, MAX_ORDER_INDEX, MAX_ORDER_NONCE, MAX_ORDER_PRICE, MAX_ORDER_TRIGGER_PRICE, MAX_PERPS_MARKET_INDEX, MAX_POOL_ENTRY_USDC, MAX_POOL_SHARES, MAX_POOL_SHARES_TO_MINT_OR_BURN, MAX_SPOT_MARKET_INDEX, MAX_TIMESTAMP, MAX_TRANSFER_AMOUNT, MAX_TRANSFER_FEE, MAX_USDC_AMOUNT, MAX_WITHDRAWAL_AMOUNT, MIN_ACCOUNT_INDEX, MIN_API_KEY_INDEX, MIN_ASSET_INDEX, MIN_CLIENT_ORDER_INDEX, MIN_INITIAL_TOTAL_SHARES, MIN_MARKET_INDEX, MIN_NONCE, MIN_ORDER_BASE_AMOUNT, MIN_ORDER_CANCEL_ALL_PERIOD, MIN_ORDER_EXPIRY, MIN_ORDER_EXPIRY_PERIOD, MIN_ORDER_INDEX, MIN_ORDER_NONCE, MIN_ORDER_PRICE, MIN_ORDER_TRIGGER_PRICE, MIN_PERPS_MARKET_INDEX, MIN_POOL_SHARES_TO_MINT_OR_BURN, MIN_SPOT_MARKET_INDEX, MIN_SUB_ACCOUNT_INDEX, MIN_TIMESTAMP, MIN_TRANSFER_AMOUNT, MIN_USDC_AMOUNT, MIN_WITHDRAWAL_AMOUNT, MarginDirection, type MarginDirectionValue, MarginMode, type MarginModeValue, type MinimalHTTPClient, type MintSharesTxReq, type ModifyOrderTxReq, NATIVE_ASSET_INDEX, NIL_API_KEY_INDEX, NIL_ASSET_INDEX, NIL_CLIENT_ORDER_INDEX, NIL_MARKET_INDEX, NIL_ORDER_BASE_AMOUNT, NIL_ORDER_EXPIRY, NIL_ORDER_INDEX, NIL_ORDER_PRICE, NIL_ORDER_TRIGGER_PRICE, ONE_USDC, ORDER, type OrderInfo, OrderType, type OrderTypeValue, SCALAR_ORDER, SHARE_TICK, SchnorrSignature, type Signer, TimeInForce, type TimeInForceValue, type TransactOpts, type TransferTxReq, TxClient, type TxInfo, TxType, type TxTypeValue, USDC_ASSET_INDEX, type Unsubscribe, type UpdateLeverageTxReq, type UpdateMarginTxReq, type UpdatePublicPoolTxReq, ValidationError, type WebSocketConfig, type WebSocketSubscription, type WithdrawTxReq, type WsAccountAllAssetsUpdate, type WsAccountAllOrdersUpdate, type WsAccountAllPositionsUpdate, type WsAccountAllTradesUpdate, type WsAccountAllUpdate, type WsAccountAsset, type WsAccountMarketUpdate, type WsAccountOrdersUpdate, type WsAccountPosition, type WsAnnouncementNotificationContent, WsClient, type WsDeleverageNotificationContent, type WsFundingHistoryEntry, type WsHeightUpdate, type WsLiquidationNotificationContent, type WsMarketStats, type WsMarketStatsUpdate, type WsNotification, type WsNotificationBase, type WsNotificationContent, type WsNotificationUpdate, type WsOrder, type WsOrderBookSnapshot, type WsOrderBookUpdate, type WsPoolDataUpdate, type WsPoolInfo, type WsPoolInfoDailyMetric, type WsPoolInfoUpdate, type WsPoolShare, type WsPositionFunding, type WsPriceLevel, type WsSpotMarketStats, type WsSpotMarketStatsUpdate, type WsStatsBreakdown, type WsTrade, type WsTradeUpdate, type WsTransaction, type WsTransactionUpdate, type WsUserStats, type WsUserStatsUpdate, bytesToFieldElements, bytesToHex, checkClient, clearClients, createClient, generateApiKey, getClient, getDefaultClient, hashToQuinticExtension, hexToBytes, newHttpClient, newKeyManager, permute, poseidon2Hash, sampleScalar, schnorrPkFromSk, schnorrSignHashedMessage, schnorrSignHashedMessageDeterministic, serializeBurnShares, serializeCancelAllOrders, serializeCancelOrder, serializeChangePubKey, serializeCreateGroupedOrders, serializeCreateOrder, serializeCreatePublicPool, serializeCreateSubAccount, serializeMintShares, serializeModifyOrder, serializeTransfer, serializeTxInfo, serializeUpdateLeverage, serializeUpdateMargin, serializeUpdatePublicPool, serializeWithdraw };