@pear-protocol/exchanges-sdk 0.1.7 → 0.1.9

package/dist/index.d.ts

@@ -1,49 +1,817 @@
-export { CreateExchangeWsConfig, ExchangeWsByConnector, createExchangeWs } from './client/index.js';
-export { createLighterHelper } from './helper/lighter/helper.js';
-export { ASSET_DECIMALS, ApproveIntegratorParams, ApproveIntegratorResult, AssetId, ConnectWalletParams, ConnectWalletResult, DepositParams, LighterHelper, LighterLookupResult, RouteType, WithdrawParams, getAssetDecimals } from './helper/lighter/types.js';
-export { ExchangeHelperExchange, ExchangeHelperMap } from './helper/types.js';
-export { ExchangesSDK } from './sdk.js';
-export { AccountSyncer, AccountSyncerConfig, BaseAccountSyncer, ListExternalFillsParams } from './syncer/base.js';
-export { BinanceAccountSyncer } from './syncer/binance/syncer.js';
-export { BybitAccountSyncer } from './syncer/bybit/syncer.js';
-export { createAccountSyncer } from './syncer/factory.js';
-export { HyperliquidAccountSyncer } from './syncer/hyperliquid/syncer.js';
-export { LighterAccountSyncer } from './syncer/lighter/syncer.js';
-export { OkxAccountSyncer } from './syncer/okx/syncer.js';
-export { CreateAccountTrackerConfig, createAccountTracker } from './tracker/index.js';
-export { ExchangeConnection, ExchangesSDKConfig, HyperliquidAccountCredentials, LighterAccountCredentials, SupportedCredentials } from './types.js';
-export { ACCOUNT_TYPE_LABELS, AccountBalance, AccountPosition, AccountType, AssetBalance, BalanceCallback, ExchangeState, MarginMode, PositionsCallback, StateUpdate, TrackedAssetCallback, TrackedAssetInfo } from './tracker/types.js';
-export { AccountTracker, AccountTrackerConfig, BaseAccountTracker } from './tracker/base.js';
-export { ApiKey } from './client/lighter/rest.js';
-export { BaseWs, MessageListener, OpenListener, WsMessage } from './client/base-ws.js';
-export { BinanceAccountTracker, BinanceAccountTrackerConfig } from './tracker/binance/tracker.js';
-export { BinanceAccountType } from './tracker/binance/types.js';
-export { BinanceExchangeWs } from './client/binance/exchange-ws.js';
-export { BinanceUserDataWs, BinanceUserDataWsConfig, BinanceWsApi, BinanceWsApiConfig } from './client/binance/ws.js';
-export { BybitAccountTracker, BybitAccountTrackerConfig } from './tracker/bybit/tracker.js';
-export { BybitAccountType } from './tracker/bybit/types.js';
-export { BybitExchangeWs } from './client/bybit/exchange-ws.js';
-export { BybitWs, BybitWsConfig } from './client/bybit/ws.js';
-export { ExchangeWs } from './client/exchange-ws.js';
-export { HyperliquidAccountTracker, HyperliquidAccountTrackerConfig } from './tracker/hyperliquid/tracker.js';
-export { HyperliquidAccountType } from './tracker/hyperliquid/types.js';
-export { HyperliquidExchangeWs } from './client/hyperliquid/exchange-ws.js';
-export { HyperliquidWs } from './client/hyperliquid/ws.js';
-export { LighterAccountTracker, LighterAccountTrackerConfig } from './tracker/lighter/tracker.js';
-export { LighterAccountType } from './tracker/lighter/types.js';
-export { LighterExchangeWs } from './client/lighter/exchange-ws.js';
-export { LighterWs } from './client/lighter/ws.js';
-export { OkxAccountTracker, OkxAccountTrackerConfig } from './tracker/okx/tracker.js';
-export { OkxAccountType } from './tracker/okx/types.js';
-export { OkxExchangeWs } from './client/okx/exchange-ws.js';
-export { OkxWs, OkxWsConfig } from './client/okx/ws.js';
-export { WalletClientWithAccount } from './helper/lighter/ethereum/types.js';
-import '@pear-protocol/types';
-import '@pear-protocol/core-sdk';
-import './client/binance/types.js';
-import './client/bybit/types.js';
-import './client/hyperliquid/types.js';
-import './client/lighter/types.js';
-import './client/okx/types.js';
-import 'partysocket';
-import 'viem';
+import { HttpTypes, Connector, BinanceCredentialsDTO, BybitCredentialsDTO, OkxCredentialsDTO, TradeAccount } from '@pear-protocol/types';
+import PearSDK from '@pear-protocol/core-sdk';
+import { WebSocket } from 'partysocket';
+import { WalletClient, Transport, Chain, Account } from 'viem';
+
+type SupportedCredentials = HttpTypes.ExchangeCredentialsResponse['credentials'];
+type ExchangesSDKConfig = {
+    sdk: PearSDK;
+    demo?: boolean;
+    options?: ConnectOptions;
+};
+type AccountHealthStatus = 'active' | 'warning';
+type AccountWarningReason = 'lighter_api_key_invalid' | 'lighter_integrator_not_approved' | 'hyperliquid_api_wallet_invalid' | 'hyperliquid_builder_fee_not_approved' | 'api_key_invalid';
+type AccountStatus = {
+    status: AccountHealthStatus;
+    reasons: AccountWarningReason[];
+};
+type ConnectOptions = {
+    builderAddress?: `0x${string}`;
+    integratorAccountIndex?: number;
+};
+type ExchangeConnection = HttpTypes.ExchangeCredentialsResponse & {
+    ws: ExchangeWsByConnector[Connector];
+};
+
+interface WsMessage {
+    [key: string]: unknown;
+}
+type MessageListener = (data: string) => void;
+type OpenListener = () => void;
+declare abstract class BaseWs {
+    protected ws: WebSocket | null;
+    protected pingTimer: ReturnType<typeof setInterval> | null;
+    private messageListeners;
+    private openListeners;
+    private nextListenerId;
+    protected abstract getWsUrl(): string;
+    protected abstract getPingIntervalMs(): number;
+    protected abstract buildPingMessage(): WsMessage | string | null;
+    connect(): Promise<void>;
+    disconnect(): void;
+    get connected(): boolean;
+    send(msg: WsMessage | string): void;
+    addMessageListener(listener: MessageListener): string;
+    removeMessageListener(id: string): void;
+    addOpenListener(listener: OpenListener): string;
+    removeOpenListener(id: string): void;
+    destroy(): void;
+    private startPing;
+    private stopPing;
+}
+
+declare abstract class ExchangeWs {
+    abstract readonly exchange: Connector;
+    protected abstract connections(): BaseWs[];
+    destroy(): void;
+    get isConnected(): boolean;
+}
+
+type BinanceUserDataWsConfig = {
+    listenKey: string;
+    demo: boolean;
+};
+declare class BinanceUserDataWs extends BaseWs {
+    private readonly listenKey;
+    private readonly demo;
+    constructor(config: BinanceUserDataWsConfig);
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): null;
+}
+type BinanceWsApiConfig = {
+    demo: boolean;
+};
+declare class BinanceWsApi extends BaseWs {
+    private readonly demo;
+    private requestId;
+    constructor(config: BinanceWsApiConfig);
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): null;
+    sendSignedRequest(creds: BinanceCredentialsDTO, method: string, params?: Record<string, unknown>): Promise<number>;
+}
+
+declare class BinanceExchangeWs extends ExchangeWs {
+    userData: BinanceUserDataWs;
+    wsApi: BinanceWsApi;
+    readonly exchange: "binance";
+    constructor(userData: BinanceUserDataWs, wsApi: BinanceWsApi);
+    protected connections(): BaseWs[];
+    static create(config: {
+        demo: boolean;
+        credentials: BinanceCredentialsDTO;
+    }): Promise<BinanceExchangeWs>;
+}
+
+type BybitWsConfig = {
+    demo: boolean;
+};
+declare class BybitWs extends BaseWs {
+    private readonly demo;
+    constructor(config: BybitWsConfig);
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): WsMessage;
+    authenticate(creds: BybitCredentialsDTO): Promise<void>;
+}
+
+declare class BybitExchangeWs extends ExchangeWs {
+    main: BybitWs;
+    private readonly creds;
+    readonly exchange: "bybit";
+    constructor(main: BybitWs, creds: BybitCredentialsDTO);
+    protected connections(): BaseWs[];
+    authenticate(): Promise<void>;
+    static create(config: {
+        demo: boolean;
+        credentials: BybitCredentialsDTO;
+    }): Promise<BybitExchangeWs>;
+}
+
+declare class HyperliquidWs extends BaseWs {
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): null;
+}
+
+declare class HyperliquidExchangeWs extends ExchangeWs {
+    main: HyperliquidWs;
+    readonly exchange: "hyperliquid";
+    constructor(main: HyperliquidWs);
+    protected connections(): BaseWs[];
+    static create(): Promise<HyperliquidExchangeWs>;
+}
+
+declare class LighterWs extends BaseWs {
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): WsMessage;
+}
+
+declare class LighterExchangeWs extends ExchangeWs {
+    main: LighterWs;
+    readonly exchange: "lighter";
+    constructor(main: LighterWs);
+    protected connections(): BaseWs[];
+    static create(): Promise<LighterExchangeWs>;
+}
+
+type OkxWsConfig = {
+    demo: boolean;
+};
+declare class OkxWs extends BaseWs {
+    private readonly demo;
+    constructor(config: OkxWsConfig);
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): string;
+    login(creds: OkxCredentialsDTO): Promise<void>;
+}
+
+declare class OkxExchangeWs extends ExchangeWs {
+    main: OkxWs;
+    private readonly creds;
+    readonly exchange: "okx";
+    constructor(main: OkxWs, creds: OkxCredentialsDTO);
+    protected connections(): BaseWs[];
+    login(): Promise<void>;
+    static create(config: {
+        demo: boolean;
+        credentials: OkxCredentialsDTO;
+    }): Promise<OkxExchangeWs>;
+}
+
+type ExchangeWsByConnector = {
+    binance: BinanceExchangeWs;
+    bybit: BybitExchangeWs;
+    okx: OkxExchangeWs;
+    hyperliquid: HyperliquidExchangeWs;
+    lighter: LighterExchangeWs;
+};
+type CreateExchangeWsConfig = {
+    demo: boolean;
+    credentials: SupportedCredentials;
+};
+declare function createExchangeWs<E extends Connector>(exchange: E, config: CreateExchangeWsConfig): Promise<ExchangeWsByConnector[E]>;
+
+interface HyperliquidHelper {
+    checkApiWallet(params: CheckApiWalletParams): Promise<boolean>;
+    checkBuilderFeeApproval(userAddress: `0x${string}`, builderAddress: `0x${string}`): Promise<boolean>;
+}
+type CheckApiWalletParams = {
+    userAddress: `0x${string}`;
+    agentWalletAddress: `0x${string}`;
+};
+
+declare function createHyperliquidHelper(): HyperliquidHelper;
+
+type WalletClientWithAccount = WalletClient<Transport, Chain | undefined, Account>;
+
+type LighterRawTrade = {
+    trade_id: number;
+    trade_id_str?: string;
+    type: 'trade' | 'liquidation' | 'deleverage' | 'market-settlement' | string;
+    market_id: number;
+    size: string;
+    price: string;
+    usd_amount: string;
+    ask_client_id_str?: string;
+    bid_client_id_str?: string;
+    ask_account_id: number;
+    bid_account_id: number;
+    is_maker_ask: boolean;
+    timestamp: number;
+    taker_fee?: number;
+    taker_position_size_before?: string;
+    maker_fee?: number;
+    maker_position_size_before?: string;
+    integrator_taker_fee?: number;
+    integrator_maker_fee?: number;
+};
+
+type ApiKey = {
+    account_index: number;
+    api_key_index: number;
+    nonce: number;
+    public_key: string;
+    transaction_time: number;
+};
+
+declare const AssetId: {
+    readonly ETH: 1;
+    readonly LIT: 2;
+    readonly USDC: 3;
+    readonly LINK: 5;
+    readonly UNI: 6;
+    readonly AAVE: 7;
+    readonly SKY: 8;
+    readonly LDO: 9;
+};
+type AssetId = (typeof AssetId)[keyof typeof AssetId];
+declare const RouteType: {
+    readonly PERP: 0;
+    readonly SPOT: 1;
+};
+type RouteType = (typeof RouteType)[keyof typeof RouteType];
+declare const ASSET_DECIMALS: Record<number, number>;
+declare function getAssetDecimals(assetId: number): number;
+type ConnectWalletParams = {
+    accountIndex: number;
+};
+type DepositParams = {
+    to: `0x${string}`;
+    assetId: number;
+    routeType: number;
+    amount: string;
+    nativeValue?: string;
+};
+type WithdrawParams = {
+    accountIndex: number;
+    assetId: number;
+    routeType: number;
+    amount: string;
+};
+type ConnectWalletResult = {
+    txHash: string;
+    apiKeyIndex: number;
+    apiPrivateKey: string;
+};
+type ApproveIntegratorParams = {
+    accountIndex: number;
+    apiKeyIndex: number;
+    apiPrivateKey: string;
+};
+type ApproveIntegratorResult = {
+    txHash: string;
+};
+interface LighterHelper {
+    lookupAccount(l1Address: string): Promise<LighterLookupResult>;
+    checkIntegratorApproval(accountIndex: number, integratorAccountIndex: number): Promise<boolean>;
+    connectWallet(walletClient: WalletClientWithAccount, params: ConnectWalletParams): Promise<ConnectWalletResult>;
+    approveIntegrator(walletClient: WalletClientWithAccount, params: ApproveIntegratorParams): Promise<ApproveIntegratorResult>;
+}
+type LighterLookupResult = {
+    mainAccountIndex: number;
+    subAccountIndexes: number[];
+};
+
+declare function createLighterHelper(sdk: PearSDK): LighterHelper;
+
+type ExchangeHelperMap = {
+    hyperliquid: HyperliquidHelper;
+    lighter: LighterHelper;
+};
+type ExchangeHelperExchange = keyof ExchangeHelperMap;
+
+interface AccountSyncerConfig {
+    sdk: PearSDK;
+    connector: Connector;
+    account: TradeAccount;
+    credentials: SupportedCredentials;
+    ws: ExchangeWsByConnector[Connector];
+    demo: boolean;
+}
+interface AccountSyncer {
+    synchronize(): Promise<void>;
+}
+interface ListExternalFillsParams {
+    since: Date;
+    instruments: HttpTypes.Instrument[];
+    openPositions: HttpTypes.OpenPositionLite[];
+    provisionalFills: HttpTypes.ProvisionalFill[];
+}
+declare abstract class BaseAccountSyncer<ExternalFill> implements AccountSyncer {
+    protected sdk: PearSDK;
+    protected connector: Connector;
+    protected account: TradeAccount;
+    protected credentials: SupportedCredentials;
+    protected ws: ExchangeWsByConnector[Connector];
+    protected demo: boolean;
+    constructor(config: AccountSyncerConfig);
+    protected abstract listExternalFills(params: ListExternalFillsParams): Promise<HttpTypes.UnknownExternalFill[]>;
+    protected abstract isReduceOnly(fill: ExternalFill): boolean;
+    synchronize(): Promise<void>;
+}
+
+interface BinanceRawUserTrade {
+    buyer: boolean;
+    commission: string;
+    commissionAsset: string;
+    id: number;
+    maker: boolean;
+    orderId: number;
+    price: string;
+    qty: string;
+    quoteQty: string;
+    realizedPnl: string;
+    side: 'BUY' | 'SELL';
+    positionSide: string;
+    symbol: string;
+    time: number;
+}
+
+declare class BinanceAccountSyncer extends BaseAccountSyncer<BinanceRawUserTrade> {
+    private readonly creds;
+    constructor(config: AccountSyncerConfig);
+    protected listExternalFills({ since, instruments, openPositions, provisionalFills, }: ListExternalFillsParams): Promise<HttpTypes.UnknownExternalFill[]>;
+    protected isReduceOnly(trade: BinanceRawUserTrade): boolean;
+    private collectRequestedInstrumentIds;
+    private mapOrdersBySymbolOrderId;
+    private orderKey;
+}
+
+interface BybitRawExecution {
+    symbol: string;
+    orderId: string;
+    orderLinkId: string;
+    side: 'Buy' | 'Sell';
+    execFee: string;
+    execId: string;
+    execPrice: string;
+    execQty: string;
+    execTime: string;
+    execType: string;
+    closedSize: string;
+}
+
+declare class BybitAccountSyncer extends BaseAccountSyncer<BybitRawExecution> {
+    private readonly creds;
+    constructor(config: AccountSyncerConfig);
+    protected listExternalFills({ since }: ListExternalFillsParams): Promise<HttpTypes.UnknownExternalFill[]>;
+    protected isReduceOnly(execution: BybitRawExecution): boolean;
+}
+
+declare function createAccountSyncer(exchange: Connector, config: AccountSyncerConfig): AccountSyncer;
+
+type UserFillsByTimeResponse = {
+    /** Asset symbol. */
+    coin: string;
+    /**
+     * Price.
+     * @pattern ^[0-9]+(\.[0-9]+)?$
+     */
+    px: string;
+    /**
+     * Size.
+     * @pattern ^[0-9]+(\.[0-9]+)?$
+     */
+    sz: string;
+    /** Order side ("B" = Bid/Buy, "A" = Ask/Sell). */
+    side: 'B' | 'A';
+    /** Timestamp when the trade occurred (in ms since epoch). */
+    time: number;
+    /**
+     * Start position size.
+     * @pattern ^-?[0-9]+(\.[0-9]+)?$
+     */
+    startPosition: string;
+    /** Direction indicator for frontend display. */
+    dir: string;
+    /**
+     * Realized PnL.
+     * @pattern ^-?[0-9]+(\.[0-9]+)?$
+     */
+    closedPnl: string;
+    /**
+     * L1 transaction hash.
+     * @pattern ^0x[a-fA-F0-9]{64}$
+     */
+    hash: `0x${string}`;
+    /** Order ID. */
+    oid: number;
+    /** Indicates if the fill was a taker order. */
+    crossed: boolean;
+    /**
+     * Fee charged or rebate received (negative indicates rebate).
+     * @pattern ^-?[0-9]+(\.[0-9]+)?$
+     */
+    fee: string;
+    /**
+     * Optional fee charged by the UI builder.
+     * @pattern ^-?[0-9]+(\.[0-9]+)?$
+     */
+    builderFee?: string;
+    /** Unique transaction identifier for a partial fill of an order. */
+    tid: number;
+    /** Token in which the fee is denominated (e.g., "USDC"). */
+    feeToken: string;
+    /** ID of the TWAP. */
+    twapId: number | null;
+    /**
+     * Client Order ID.
+     * @pattern ^0x[a-fA-F0-9]{32}$
+     */
+    cloid?: `0x${string}`;
+    /** Liquidation details. */
+    liquidation?: {
+        /**
+         * Address of the liquidated user.
+         * @pattern ^0x[a-fA-F0-9]{40}$
+         */
+        liquidatedUser: `0x${string}`;
+        /**
+         * Mark price at the time of liquidation.
+         * @pattern ^[0-9]+(\.[0-9]+)?$
+         */
+        markPx: string;
+        /** Liquidation method. */
+        method: 'market' | 'backstop';
+    };
+};
+
+declare class HyperliquidAccountSyncer extends BaseAccountSyncer<UserFillsByTimeResponse> {
+    private readonly address;
+    constructor(config: AccountSyncerConfig);
+    protected listExternalFills({ since, instruments, }: ListExternalFillsParams): Promise<HttpTypes.UnknownExternalFill[]>;
+    protected isReduceOnly(fill: UserFillsByTimeResponse): boolean;
+}
+
+declare class LighterAccountSyncer extends BaseAccountSyncer<LighterRawTrade> {
+    private readonly accountIndex;
+    private readonly apiKeyIndex;
+    private readonly apiPrivateKey;
+    constructor(config: AccountSyncerConfig);
+    protected listExternalFills({ since, instruments, }: ListExternalFillsParams): Promise<HttpTypes.UnknownExternalFill[]>;
+    protected isReduceOnly(trade: LighterRawTrade): boolean;
+    private getAccountSide;
+    private getClientOrderId;
+    private isMaker;
+    private getPositionSizeBefore;
+    private getTradeFee;
+    private getIntegratorFee;
+    private feeTickToDecimal;
+}
+
+interface OkxRawFill {
+    instType: string;
+    instId: string;
+    tradeId: string;
+    ordId: string;
+    clOrdId: string;
+    billId: string;
+    fillPx: string;
+    fillSz: string;
+    side: 'buy' | 'sell';
+    posSide: string;
+    execType: string;
+    fee: string;
+    feeCcy: string;
+    fillTime: string;
+    ts: string;
+}
+
+declare class OkxAccountSyncer extends BaseAccountSyncer<OkxRawFill> {
+    private readonly creds;
+    constructor(config: AccountSyncerConfig);
+    protected listExternalFills({ since, instruments, }: ListExternalFillsParams): Promise<HttpTypes.UnknownExternalFill[]>;
+    protected isReduceOnly(fill: OkxRawFill): boolean;
+    private contractsToBase;
+}
+
+declare enum BinanceAccountType {
+    MULTI_ASSET = "MULTI_ASSET",
+    SINGLE_ASSET = "SINGLE_ASSET"
+}
+
+declare enum BybitAccountType {
+    ISOLATED_MARGIN = "ISOLATED_MARGIN",
+    REGULAR_MARGIN = "REGULAR_MARGIN",
+    PORTFOLIO_MARGIN = "PORTFOLIO_MARGIN"
+}
+
+declare enum HyperliquidAccountType {
+    DEFAULT = "default",
+    DEX_ABSTRACTION = "dexAbstraction",
+    DISABLED = "disabled",
+    PORTFOLIO_MARGIN = "portfolioMargin",
+    UNIFIED_ACCOUNT = "unifiedAccount"
+}
+
+declare enum LighterAccountType {
+    BASIC = "basic"
+}
+
+declare enum OkxAccountType {
+    SPOT = "OKX_SPOT",
+    SINGLE_CURRENCY_MARGIN = "OKX_SINGLE",
+    MULTI_CURRENCY_MARGIN = "OKX_MULTI",
+    PORTFOLIO_MARGIN = "OKX_PORTFOLIO"
+}
+
+type MarginMode = 'cross' | 'isolated';
+type AccountType = BinanceAccountType | BybitAccountType | HyperliquidAccountType | LighterAccountType | OkxAccountType;
+declare const ACCOUNT_TYPE_LABELS: Record<AccountType, string>;
+interface AssetBalance {
+    asset: string;
+    free: string;
+    used: string;
+    total: string;
+    walletBalance: string;
+    usdValue: string;
+}
+interface AccountBalance {
+    accountType: AccountType;
+    free: Record<string, string>;
+    used: Record<string, string>;
+    total: Record<string, string>;
+    availableToTrade: string;
+    totalEquity: string;
+    walletBalance: string;
+    unrealizedPnl: string;
+    initialMarginUsed: string;
+    maintenanceMargin: string;
+    marginRatio: string;
+    assets: AssetBalance[];
+    timestamp: number;
+}
+interface AccountPosition {
+    symbol: string;
+    side: 'long' | 'short' | 'both';
+    size: string;
+    entryPrice: string;
+    unrealizedPnl: string;
+    leverage: string;
+    marginType: MarginMode;
+    liquidationPrice: string | null;
+}
+interface TrackedAssetInfo {
+    coin: string;
+    leverage: string;
+    marginType: MarginMode;
+}
+interface ExchangeState {
+    balance: AccountBalance | null;
+    positions: Map<string, AccountPosition>;
+    lastUpdated: number;
+    initialized: boolean;
+}
+type BalanceCallback = (balance: AccountBalance) => void;
+type PositionsCallback = (positions: AccountPosition[]) => void;
+type TrackedAssetCallback = (info: TrackedAssetInfo) => void;
+interface StateUpdate {
+    balance?: AccountBalance;
+    positions?: Map<string, AccountPosition>;
+    trackedAssets?: Map<string, TrackedAssetInfo>;
+}
+
+type ErrorHandler = (error: Error) => void;
+type AccountTrackerConfig = {
+    demo: boolean;
+    onError?: ErrorHandler;
+};
+interface AccountTracker {
+    start(): Promise<void>;
+    disconnect(): Promise<void>;
+    readonly isConnected: boolean;
+    readonly isInitialized: boolean;
+    readonly hasListeners: boolean;
+    trackBalance(cb: BalanceCallback): () => void;
+    trackPosition(cb: PositionsCallback): () => void;
+    trackAsset(asset: string, cb: TrackedAssetCallback): () => void;
+    getBalance(): AccountBalance | null;
+    getPositions(): AccountPosition[];
+    getTrackedAsset(coin: string): TrackedAssetInfo | null;
+}
+declare abstract class BaseAccountTracker implements AccountTracker {
+    protected onError: ErrorHandler;
+    protected demo: boolean;
+    protected credentials: SupportedCredentials | null;
+    private balance;
+    private positions;
+    private initialized;
+    private balanceListeners;
+    private positionListeners;
+    private assetEntries;
+    constructor(config: AccountTrackerConfig);
+    disconnect(): Promise<void>;
+    get isInitialized(): boolean;
+    get hasListeners(): boolean;
+    trackBalance(cb: BalanceCallback): () => void;
+    trackPosition(cb: PositionsCallback): () => void;
+    trackAsset(asset: string, cb: TrackedAssetCallback): () => void;
+    private releaseAssetListener;
+    protected get trackedCoins(): ReadonlySet<string>;
+    getBalance(): AccountBalance | null;
+    getPositions(): AccountPosition[];
+    getTrackedAsset(coin: string): TrackedAssetInfo | null;
+    protected onStateUpdate(update: StateUpdate): void;
+    private applyBalanceUpdate;
+    private applyPositionsUpdate;
+    private applyTrackedAssetsUpdate;
+    private getOrCreateAssetEntry;
+    private positionSnapshot;
+    private notify;
+    private broadcast;
+    abstract start(): Promise<void>;
+    abstract get isConnected(): boolean;
+    protected abstract ensureAssetTracked(asset: string): void;
+    protected abstract releaseAsset(asset: string): void;
+    protected abstract cleanupConnections(): void | Promise<void>;
+}
+
+type BinanceAccountTrackerConfig = AccountTrackerConfig & {
+    credentials: SupportedCredentials;
+    userDataWs: BinanceUserDataWs;
+    wsApiWs: BinanceWsApi;
+    listenKeyRefreshMs?: number;
+    accountPollMs?: number;
+};
+declare class BinanceAccountTracker extends BaseAccountTracker {
+    private readonly creds;
+    private readonly userDataWs;
+    private readonly wsApiWs;
+    private readonly listenKeyRefreshMs;
+    private readonly accountPollMs;
+    private userDataListenerId;
+    private wsApiListenerId;
+    private listenKeyTimer;
+    private pollTimer;
+    private currentPositions;
+    private accountType;
+    private trackedAssetInfos;
+    constructor(config: BinanceAccountTrackerConfig);
+    start(): Promise<void>;
+    protected cleanupConnections(): Promise<void>;
+    get isConnected(): boolean;
+    protected ensureAssetTracked(coin: string): void;
+    protected releaseAsset(coin: string): void;
+    private pollAccountStatus;
+    private routeUserData;
+    private routeWsApi;
+    private handleAccountStatus;
+    private handlePositionRisk;
+    private handleUserDataEvent;
+    private refreshAllPositions;
+}
+
+type BybitAccountTrackerConfig = AccountTrackerConfig & {
+    credentials: SupportedCredentials;
+    ws: BybitExchangeWs;
+};
+declare class BybitAccountTracker extends BaseAccountTracker {
+    private readonly creds;
+    private readonly ws;
+    private messageListenerId;
+    private openListenerId;
+    private rawCoins;
+    private lastWallet;
+    private accountType;
+    private trackedAssetInfos;
+    constructor(config: BybitAccountTrackerConfig);
+    start(): Promise<void>;
+    protected cleanupConnections(): Promise<void>;
+    get isConnected(): boolean;
+    protected ensureAssetTracked(coin: string): void;
+    protected releaseAsset(coin: string): void;
+    private subscribe;
+    private handleInitialData;
+    private routeRaw;
+    private handleMessage;
+    private handleWalletUpdate;
+}
+
+type HyperliquidAccountTrackerConfig = AccountTrackerConfig & {
+    account: TradeAccount;
+    credentials: SupportedCredentials;
+    ws: HyperliquidWs;
+};
+declare class HyperliquidAccountTracker extends BaseAccountTracker {
+    private readonly address;
+    private readonly ws;
+    private messageListenerId;
+    private openListenerId;
+    private subscribedCoins;
+    private lastSummary;
+    private spotCoinBalances;
+    private accountType;
+    private symbolToCollateralToken;
+    private availableToTradeByCollateral;
+    private trackedAssetData;
+    constructor(config: HyperliquidAccountTrackerConfig);
+    start(): Promise<void>;
+    protected cleanupConnections(): Promise<void>;
+    get isConnected(): boolean;
+    protected ensureAssetTracked(coin: string): void;
+    protected releaseAsset(coin: string): void;
+    private isLocked;
+    private addrLower;
+    private sendStaticSubs;
+    private resubscribeAll;
+    private routeRaw;
+    private handle;
+    private loadPerpMetas;
+    private onClearinghouseState;
+    private onActiveAssetData;
+    private onWebData3;
+    private onSpotState;
+    private buildBalance;
+    private buildTrackedAssetsMap;
+}
+
+type LighterAccountTrackerConfig = AccountTrackerConfig & {
+    account: TradeAccount;
+    credentials: SupportedCredentials;
+    ws: LighterWs;
+};
+declare class LighterAccountTracker extends BaseAccountTracker {
+    private readonly accountIdentifier;
+    private readonly ws;
+    private messageListenerId;
+    private openListenerId;
+    private pollTimer;
+    private assetsByAssetId;
+    private summary;
+    private hasAssets;
+    constructor(config: LighterAccountTrackerConfig);
+    start(): Promise<void>;
+    protected cleanupConnections(): Promise<void>;
+    get isConnected(): boolean;
+    protected ensureAssetTracked(_coin: string): void;
+    protected releaseAsset(_coin: string): void;
+    private sendStaticSubs;
+    private routeRaw;
+    private handle;
+    private onAccountAll;
+    private onUserStats;
+    private buildBalance;
+    private pollAccount;
+}
+
+type OkxAccountTrackerConfig = AccountTrackerConfig & {
+    credentials: SupportedCredentials;
+    ws: OkxExchangeWs;
+};
+declare class OkxAccountTracker extends BaseAccountTracker {
+    private readonly creds;
+    private readonly ws;
+    private messageListenerId;
+    private openListenerId;
+    private rawCoins;
+    private lastBalance;
+    private accountType;
+    private trackedAssetInfos;
+    constructor(config: OkxAccountTrackerConfig);
+    start(): Promise<void>;
+    protected cleanupConnections(): Promise<void>;
+    get isConnected(): boolean;
+    protected ensureAssetTracked(instId: string): void;
+    protected releaseAsset(instId: string): void;
+    private subscribe;
+    private handleInitialData;
+    private routeRaw;
+    private handleMessage;
+    private handleBalanceUpdate;
+}
+
+type CreateAccountTrackerConfig<E extends Connector> = AccountTrackerConfig & {
+    account: TradeAccount;
+    credentials: SupportedCredentials;
+    ws: ExchangeWsByConnector[E];
+};
+declare function createAccountTracker<E extends Connector>(exchange: E, config: CreateAccountTrackerConfig<E>): AccountTracker;
+
+declare class ExchangesSDK {
+    private sdk;
+    private demo;
+    private options?;
+    constructor(config: ExchangesSDKConfig);
+    connect(tradeAccountId: string): Promise<ExchangeConnection>;
+    status(connection: ExchangeConnection): Promise<AccountStatus>;
+    createTracker(connection: ExchangeConnection): AccountTracker;
+    createHelper<E extends ExchangeHelperExchange>(exchange: E): ExchangeHelperMap[E];
+    createSyncer(connection: ExchangeConnection): AccountSyncer;
+    private fetchCredentials;
+}
+
+export { ACCOUNT_TYPE_LABELS, ASSET_DECIMALS, type AccountBalance, type AccountHealthStatus, type AccountPosition, type AccountStatus, type AccountSyncer, type AccountSyncerConfig, type AccountTracker, type AccountTrackerConfig, type AccountType, type AccountWarningReason, type ApiKey, type ApproveIntegratorParams, type ApproveIntegratorResult, type AssetBalance, AssetId, type BalanceCallback, BaseAccountSyncer, BaseAccountTracker, BaseWs, BinanceAccountSyncer, BinanceAccountTracker, type BinanceAccountTrackerConfig, BinanceAccountType, BinanceExchangeWs, BinanceUserDataWs, type BinanceUserDataWsConfig, BinanceWsApi, type BinanceWsApiConfig, BybitAccountSyncer, BybitAccountTracker, type BybitAccountTrackerConfig, BybitAccountType, BybitExchangeWs, BybitWs, type BybitWsConfig, type CheckApiWalletParams, type ConnectOptions, type ConnectWalletParams, type ConnectWalletResult, type CreateAccountTrackerConfig, type CreateExchangeWsConfig, type DepositParams, type ExchangeConnection, type ExchangeHelperExchange, type ExchangeHelperMap, type ExchangeState, ExchangeWs, type ExchangeWsByConnector, ExchangesSDK, type ExchangesSDKConfig, HyperliquidAccountSyncer, HyperliquidAccountTracker, type HyperliquidAccountTrackerConfig, HyperliquidAccountType, HyperliquidExchangeWs, type HyperliquidHelper, HyperliquidWs, LighterAccountSyncer, LighterAccountTracker, type LighterAccountTrackerConfig, LighterAccountType, LighterExchangeWs, type LighterHelper, type LighterLookupResult, LighterWs, type ListExternalFillsParams, type MarginMode, type MessageListener, OkxAccountSyncer, OkxAccountTracker, type OkxAccountTrackerConfig, OkxAccountType, OkxExchangeWs, OkxWs, type OkxWsConfig, type OpenListener, type PositionsCallback, RouteType, type StateUpdate, type SupportedCredentials, type TrackedAssetCallback, type TrackedAssetInfo, type WalletClientWithAccount, type WithdrawParams, type WsMessage, createAccountSyncer, createAccountTracker, createExchangeWs, createHyperliquidHelper, createLighterHelper, getAssetDecimals };