@pear-protocol/exchanges-sdk 0.0.18 → 0.1.3

package/dist/tracker/lighter/mapper.d.ts

@@ -0,0 +1,16 @@
+import { RawAsset, RawPosition } from '../../client/lighter/types.js';
+import { AccountBalance, AccountPosition, TrackedAssetInfo } from '../types.js';
+import { AggregatedLighterSummary } from './types.js';
+import '../binance/types.js';
+import '../bybit/types.js';
+import '../hyperliquid/types.js';
+import '../okx/types.js';
+
+declare function mapBalance(summary: AggregatedLighterSummary, assetsByAssetId: Map<string, RawAsset>): AccountBalance;
+declare function mapPositions(raw: Record<string, RawPosition>): {
+    positions: Map<string, AccountPosition>;
+    trackedAssets: Map<string, TrackedAssetInfo>;
+};
+declare function leverageFromImf(imfPct: string): string;
+
+export { leverageFromImf, mapBalance, mapPositions };

package/dist/tracker/lighter/mapper.js

@@ -0,0 +1,77 @@
+import BigNumber from 'bignumber.js';
+import { positionKey } from '../utils';
+import { QUOTE_ASSET } from './const';
+import { LighterAccountType } from './types';
+
+function mapBalance(summary, assetsByAssetId) {
+  const free = {};
+  const used = {};
+  const total = {};
+  const assets = [];
+  for (const a of assetsByAssetId.values()) {
+    const balBN = new BigNumber(a.balance || "0");
+    const lockedBN = new BigNumber(a.locked_balance || "0");
+    const totalAmt = balBN.plus(lockedBN).toFixed();
+    free[a.symbol] = a.balance;
+    used[a.symbol] = a.locked_balance;
+    total[a.symbol] = totalAmt;
+    assets.push({
+      asset: a.symbol,
+      free: a.balance,
+      used: a.locked_balance,
+      total: totalAmt,
+      walletBalance: totalAmt,
+      usdValue: a.symbol === QUOTE_ASSET ? totalAmt : "0"
+    });
+  }
+  const portfolioValueBN = new BigNumber(summary.portfolioValue);
+  const marginUsageFrac = new BigNumber(summary.marginUsagePct).div(100);
+  const unrealizedPnl = portfolioValueBN.minus(summary.collateral).toFixed(6);
+  const initialMarginUsed = marginUsageFrac.multipliedBy(portfolioValueBN).toFixed(6);
+  const marginRatio = marginUsageFrac.toFixed(4);
+  return {
+    accountType: LighterAccountType.BASIC,
+    free,
+    used,
+    total,
+    availableToTrade: summary.availableToTrade,
+    totalEquity: summary.portfolioValue,
+    walletBalance: summary.collateral,
+    unrealizedPnl,
+    initialMarginUsed,
+    maintenanceMargin: "0",
+    marginRatio,
+    assets,
+    timestamp: Date.now()
+  };
+}
+function mapPositions(raw) {
+  const positions = /* @__PURE__ */ new Map();
+  const trackedAssets = /* @__PURE__ */ new Map();
+  for (const p of Object.values(raw)) {
+    const sizeBN = new BigNumber(p.position || "0");
+    const side = p.sign === -1 ? "short" : "long";
+    const leverage = leverageFromImf(p.initial_margin_fraction);
+    const marginType = p.margin_mode === 1 ? "isolated" : "cross";
+    const marketId = String(p.market_id);
+    positions.set(positionKey(p.symbol, side), {
+      symbol: p.symbol,
+      side,
+      size: sizeBN.isFinite() && !sizeBN.isZero() ? sizeBN.toFixed() : "0",
+      entryPrice: p.avg_entry_price || "0",
+      unrealizedPnl: p.unrealized_pnl || "0",
+      leverage,
+      marginType,
+      liquidationPrice: p.liquidation_price && p.liquidation_price !== "0" ? p.liquidation_price : null
+    });
+    trackedAssets.set(marketId, { coin: p.symbol, leverage, marginType });
+  }
+  return { positions, trackedAssets };
+}
+function leverageFromImf(imfPct) {
+  const pct = new BigNumber(imfPct);
+  if (!pct.isFinite() || pct.lte(0)) return "1";
+  return new BigNumber(100).div(pct).integerValue(BigNumber.ROUND_FLOOR).toFixed();
+}
+
+export { leverageFromImf, mapBalance, mapPositions };

package/dist/tracker/lighter/tracker.d.ts

@@ -0,0 +1,53 @@
+import { LighterWs } from '../../client/lighter/ws.js';
+import { SupportedCredentials } from '../../types.js';
+import { BaseAccountTracker, AccountTrackerConfig } from '../base.js';
+import '../../client/base-ws.js';
+import 'partysocket';
+import '@pear-protocol/core-sdk';
+import '@pear-protocol/types';
+import '../../client/binance/exchange-ws.js';
+import '../../client/exchange-ws.js';
+import '../../client/binance/ws.js';
+import '../../client/bybit/exchange-ws.js';
+import '../../client/bybit/ws.js';
+import '../../client/hyperliquid/exchange-ws.js';
+import '../../client/hyperliquid/ws.js';
+import '../../client/lighter/exchange-ws.js';
+import '../../client/okx/exchange-ws.js';
+import '../../client/okx/ws.js';
+import '../types.js';
+import '../binance/types.js';
+import '../bybit/types.js';
+import '../hyperliquid/types.js';
+import './types.js';
+import '../okx/types.js';
+
+type LighterAccountTrackerConfig = AccountTrackerConfig & {
+    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;
+}
+
+export { LighterAccountTracker, type LighterAccountTrackerConfig };

package/dist/tracker/lighter/tracker.js

@@ -0,0 +1,150 @@
+import BigNumber from 'bignumber.js';
+import { fetchOrderBookDetails, fetchAccount } from '../../client/lighter/rest';
+import { BaseAccountTracker } from '../base';
+import { leverageFromImf, mapPositions, mapBalance } from './mapper';
+
+class LighterAccountTracker extends BaseAccountTracker {
+  accountIdentifier;
+  ws;
+  messageListenerId = null;
+  openListenerId = null;
+  pollTimer = null;
+  assetsByAssetId = /* @__PURE__ */ new Map();
+  summary = null;
+  hasAssets = false;
+  constructor(config) {
+    super(config);
+    const creds = config.credentials;
+    this.credentials = config.credentials;
+    this.accountIdentifier = creds.accountIdentifier;
+    this.ws = config.ws;
+  }
+  async start() {
+    const markets = await fetchOrderBookDetails();
+    const trackedAssets = /* @__PURE__ */ new Map();
+    for (const m of markets) {
+      trackedAssets.set(String(m.market_id), {
+        coin: m.symbol,
+        leverage: leverageFromImf(new BigNumber(m.default_initial_margin_fraction).div(100).toFixed()),
+        marginType: "cross"
+      });
+    }
+    this.onStateUpdate({ trackedAssets });
+    this.messageListenerId = this.ws.addMessageListener((raw) => this.routeRaw(raw));
+    this.openListenerId = this.ws.addOpenListener(() => this.sendStaticSubs());
+    this.sendStaticSubs();
+    this.pollAccount();
+    this.pollTimer = setInterval(() => this.pollAccount(), 2e3);
+  }
+  async cleanupConnections() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.messageListenerId) {
+      this.ws.removeMessageListener(this.messageListenerId);
+      this.messageListenerId = null;
+    }
+    if (this.openListenerId) {
+      this.ws.removeOpenListener(this.openListenerId);
+      this.openListenerId = null;
+    }
+  }
+  get isConnected() {
+    return this.ws.connected;
+  }
+  ensureAssetTracked(_coin) {
+  }
+  releaseAsset(_coin) {
+  }
+  sendStaticSubs() {
+    this.ws.send({
+      type: "subscribe",
+      channel: `account_all/${this.accountIdentifier}`
+    });
+    this.ws.send({
+      type: "subscribe",
+      channel: `user_stats/${this.accountIdentifier}`
+    });
+  }
+  routeRaw(raw) {
+    try {
+      const msg = JSON.parse(raw);
+      if (!msg.type) return;
+      if (msg.type === "subscribed/account_all" || msg.type === "update/account_all") {
+        this.handle({ kind: "account_all", data: msg });
+      } else if (msg.type === "subscribed/user_stats" || msg.type === "update/user_stats") {
+        this.handle({ kind: "user_stats", data: msg });
+      }
+    } catch (err) {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  handle(event) {
+    if (event.kind === "account_all") {
+      this.onAccountAll(event.data);
+    } else {
+      this.onUserStats(event.data);
+    }
+  }
+  onAccountAll(data) {
+    const update = {};
+    if (data.assets) {
+      for (const [id, asset] of Object.entries(data.assets)) {
+        this.assetsByAssetId.set(id, asset);
+      }
+      this.hasAssets = true;
+    }
+    if (data.positions && Object.keys(data.positions).length > 0) {
+      const { positions, trackedAssets } = mapPositions(data.positions);
+      update.positions = positions;
+      update.trackedAssets = trackedAssets;
+    }
+    const balance = this.buildBalance();
+    if (balance) update.balance = balance;
+    if (Object.keys(update).length > 0) this.onStateUpdate(update);
+  }
+  onUserStats(data) {
+    const s = data.stats;
+    this.summary = {
+      collateral: s.collateral || "0",
+      portfolioValue: s.portfolio_value || "0",
+      availableToTrade: s.available_balance || "0",
+      marginUsagePct: s.margin_usage || "0"
+    };
+    const balance = this.buildBalance();
+    if (balance) this.onStateUpdate({ balance });
+  }
+  buildBalance() {
+    if (!this.summary || !this.hasAssets) return null;
+    return mapBalance(this.summary, this.assetsByAssetId);
+  }
+  async pollAccount() {
+    try {
+      const accountIndex = Number(this.accountIdentifier);
+      const data = await fetchAccount(accountIndex);
+      const account = data.accounts[0];
+      if (!account?.positions?.length) return;
+      const posRecord = {};
+      for (const p of account.positions) {
+        posRecord[String(p.market_id)] = {
+          market_id: p.market_id,
+          symbol: p.symbol,
+          initial_margin_fraction: p.initial_margin_fraction,
+          sign: p.sign,
+          position: p.position,
+          avg_entry_price: p.avg_entry_price,
+          unrealized_pnl: p.unrealized_pnl,
+          liquidation_price: p.liquidation_price,
+          margin_mode: p.margin_mode
+        };
+      }
+      const { positions, trackedAssets } = mapPositions(posRecord);
+      this.onStateUpdate({ positions, trackedAssets });
+    } catch (err) {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+}
+
+export { LighterAccountTracker };

package/dist/tracker/lighter/types.d.ts

@@ -0,0 +1,16 @@
+declare enum LighterAccountType {
+    BASIC = "basic"
+}
+interface LighterCoinBalance {
+    symbol: string;
+    balance: string;
+    lockedBalance: string;
+}
+interface AggregatedLighterSummary {
+    collateral: string;
+    portfolioValue: string;
+    availableToTrade: string;
+    marginUsagePct: string;
+}
+
+export { type AggregatedLighterSummary, LighterAccountType, type LighterCoinBalance };

package/dist/tracker/lighter/types.js

@@ -0,0 +1,6 @@
+var LighterAccountType = /* @__PURE__ */ ((LighterAccountType2) => {
+  LighterAccountType2["BASIC"] = "basic";
+  return LighterAccountType2;
+})(LighterAccountType || {});
+
+export { LighterAccountType };

package/dist/{account/exchanges → tracker}/okx/mapper.d.ts

@@ -1,8 +1,10 @@
-import { a as AccountBalance, c as AccountPosition } from '../../../types-Caz2X4h0.js';
-import { OkxAccountType, OkxRawBalance, OkxRawBalanceDetail, OkxRawPosition } from './types.js';
-import '@pear-protocol/types';
+import { OkxRawBalance, OkxRawBalanceDetail, OkxRawPosition } from '../../client/okx/types.js';
+import { AccountBalance, AccountPosition } from '../types.js';
+import { OkxAccountType } from './types.js';
+import '../binance/types.js';
 import '../bybit/types.js';
 import '../hyperliquid/types.js';
+import '../lighter/types.js';
 
 declare function mergeRawCoins(existing: Map<string, OkxRawBalanceDetail>, incoming: OkxRawBalanceDetail[]): Map<string, OkxRawBalanceDetail>;
 declare function buildBalance(raw: OkxRawBalance, coins: Map<string, OkxRawBalanceDetail>, accountType: OkxAccountType | null): AccountBalance | null;

package/dist/{account/exchanges → tracker}/okx/mapper.js

@@ -1,4 +1,5 @@
-import { positionKey } from '../../utils';
+import BigNumber from 'bignumber.js';
+import { positionKey } from '../utils';
 import { OkxAccountType } from './types';
 
 function mergeRawCoins(existing, incoming) {
@@ -15,18 +16,18 @@ function buildBalance(raw, coins, accountType) {
   const used = {};
   const total = {};
   const assets = [];
-  let walletBalanceSum = 0;
+  let walletBalanceSum = new BigNumber(0);
   for (const [, d] of coins) {
     const eq = d.eq ?? "0";
-    const eqNum = parseFloat(eq);
-    const cashNum = parseFloat(d.cashBal ?? "0");
-    if (eqNum === 0 && cashNum === 0) continue;
+    const eqBN = new BigNumber(eq);
+    const cashBN = new BigNumber(d.cashBal ?? "0");
+    if (eqBN.isZero() && cashBN.isZero()) continue;
     const coinFree = isSpot ? d.availBal ?? "0" : d.availEq || d.availBal || "0";
-    const coinUsed = (eqNum - parseFloat(coinFree)).toString();
+    const coinUsed = eqBN.minus(coinFree).toString();
     free[d.ccy] = coinFree;
     used[d.ccy] = coinUsed;
     total[d.ccy] = eq;
-    walletBalanceSum += cashNum;
+    walletBalanceSum = walletBalanceSum.plus(cashBN);
     assets.push({
       asset: d.ccy,
       free: coinFree,
@@ -44,7 +45,7 @@ function buildBalance(raw, coins, accountType) {
     total,
     availableToTrade,
     totalEquity: raw.totalEq ?? "0",
-    walletBalance: walletBalanceSum.toString(),
+    walletBalance: walletBalanceSum.toFixed(),
     unrealizedPnl: raw.upl || "0",
     initialMarginUsed: raw.imr || "0",
     maintenanceMargin: raw.mmr || "0",
@@ -54,11 +55,11 @@ function buildBalance(raw, coins, accountType) {
   };
 }
 function mapSinglePosition(p) {
-  const posNum = parseFloat(p.pos ?? "0");
+  const posBN = new BigNumber(p.pos ?? "0");
   let side;
   if (p.posSide === "long") side = "long";
   else if (p.posSide === "short") side = "short";
-  else side = posNum < 0 ? "short" : "long";
+  else side = posBN.isNegative() ? "short" : "long";
   const rawSize = p.pos ?? "0";
   let size;
   if (rawSize === "0" || rawSize === "") {

package/dist/tracker/okx/tracker.d.ts

@@ -0,0 +1,51 @@
+import { OkxExchangeWs } from '../../client/okx/exchange-ws.js';
+import { SupportedCredentials } from '../../types.js';
+import { BaseAccountTracker, AccountTrackerConfig } from '../base.js';
+import '@pear-protocol/types';
+import '../../client/base-ws.js';
+import 'partysocket';
+import '../../client/exchange-ws.js';
+import '../../client/okx/ws.js';
+import '@pear-protocol/core-sdk';
+import '../../client/binance/exchange-ws.js';
+import '../../client/binance/ws.js';
+import '../../client/bybit/exchange-ws.js';
+import '../../client/bybit/ws.js';
+import '../../client/hyperliquid/exchange-ws.js';
+import '../../client/hyperliquid/ws.js';
+import '../../client/lighter/exchange-ws.js';
+import '../../client/lighter/ws.js';
+import '../types.js';
+import '../binance/types.js';
+import '../bybit/types.js';
+import '../hyperliquid/types.js';
+import '../lighter/types.js';
+import './types.js';
+
+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;
+}
+
+export { OkxAccountTracker, type OkxAccountTrackerConfig };

package/dist/tracker/okx/tracker.js

@@ -0,0 +1,134 @@
+import { fetchAccountConfig, fetchBalance, fetchPositions, fetchLeverageInfo } from '../../client/okx/rest';
+import { BaseAccountTracker } from '../base';
+import { acctLvToAccountType, mergeRawCoins, buildBalance, mapPositions, mapPositionUpdates } from './mapper';
+
+class OkxAccountTracker extends BaseAccountTracker {
+  creds;
+  ws;
+  messageListenerId = null;
+  openListenerId = null;
+  rawCoins = /* @__PURE__ */ new Map();
+  lastBalance = null;
+  accountType = null;
+  trackedAssetInfos = /* @__PURE__ */ new Map();
+  constructor(config) {
+    super(config);
+    this.credentials = config.credentials;
+    this.creds = config.credentials;
+    this.ws = config.ws;
+  }
+  async start() {
+    const [config, balance, positions] = await Promise.all([
+      fetchAccountConfig(this.creds, this.demo),
+      fetchBalance(this.creds, this.demo),
+      fetchPositions(this.creds, this.demo)
+    ]);
+    this.accountType = acctLvToAccountType(config.acctLv);
+    this.handleInitialData(balance, positions);
+    this.messageListenerId = this.ws.main.addMessageListener((raw) => this.routeRaw(raw));
+    this.openListenerId = this.ws.main.addOpenListener(() => {
+      this.ws.login().then(() => this.subscribe()).catch((err) => this.onError(err));
+    });
+    this.subscribe();
+  }
+  async cleanupConnections() {
+    if (this.messageListenerId) {
+      this.ws.main.removeMessageListener(this.messageListenerId);
+      this.messageListenerId = null;
+    }
+    if (this.openListenerId) {
+      this.ws.main.removeOpenListener(this.openListenerId);
+      this.openListenerId = null;
+    }
+  }
+  get isConnected() {
+    return this.ws.isConnected;
+  }
+  ensureAssetTracked(instId) {
+    if (this.trackedAssetInfos.has(instId)) return;
+    fetchLeverageInfo(this.creds, instId, this.demo).then((info) => {
+      const leverage = info?.lever || "0";
+      const marginType = info?.mgnMode;
+      const trackedAssetInfo = { coin: instId, leverage, marginType };
+      this.trackedAssetInfos.set(instId, trackedAssetInfo);
+      const trackedAssets = /* @__PURE__ */ new Map([[instId, trackedAssetInfo]]);
+      this.onStateUpdate({ trackedAssets });
+    }).catch((err) => this.onError(err instanceof Error ? err : new Error(String(err))));
+  }
+  releaseAsset(instId) {
+    this.trackedAssetInfos.delete(instId);
+    this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
+  }
+  subscribe() {
+    this.ws.main.send({
+      op: "subscribe",
+      args: [{ channel: "account" }, { channel: "positions", instType: "SWAP" }]
+    });
+  }
+  handleInitialData(balance, positions) {
+    this.lastBalance = balance;
+    this.rawCoins = mergeRawCoins(/* @__PURE__ */ new Map(), balance.details ?? []);
+    const built = buildBalance(balance, this.rawCoins, this.accountType);
+    if (built) this.onStateUpdate({ balance: built });
+    this.onStateUpdate({ positions: mapPositions(positions) });
+  }
+  routeRaw(raw) {
+    if (raw === "pong") return;
+    try {
+      const msg = JSON.parse(raw);
+      if (msg.event) return;
+      if (msg.arg && msg.data) {
+        this.handleMessage(msg);
+      }
+    } catch (err) {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  handleMessage(msg) {
+    if (msg.arg.channel === "account") {
+      const raw = msg.data[0];
+      if (raw) this.handleBalanceUpdate(raw);
+      return;
+    }
+    if (msg.arg.channel === "positions") {
+      const posMsg = msg;
+      const action = posMsg.action ?? "update";
+      const rawPositions = posMsg.data;
+      const positions = action === "snapshot" ? mapPositions(rawPositions) : mapPositionUpdates(rawPositions);
+      if (positions.size === 0 && action !== "snapshot") return;
+      const trackedAssets = /* @__PURE__ */ new Map();
+      for (const p of rawPositions) {
+        const existing = this.trackedAssetInfos.get(p.instId);
+        if (existing) {
+          const leverage = p.lever || existing.leverage;
+          const marginType = p.mgnMode;
+          const updated = { ...existing, leverage, marginType };
+          this.trackedAssetInfos.set(p.instId, updated);
+          trackedAssets.set(p.instId, updated);
+        }
+      }
+      this.onStateUpdate({
+        positions,
+        ...trackedAssets.size > 0 ? { trackedAssets } : {}
+      });
+    }
+  }
+  handleBalanceUpdate(raw) {
+    this.rawCoins = mergeRawCoins(this.rawCoins, raw.details ?? []);
+    const merged = this.lastBalance ? {
+      totalEq: raw.totalEq || this.lastBalance.totalEq,
+      adjEq: raw.adjEq || this.lastBalance.adjEq,
+      availEq: raw.availEq || this.lastBalance.availEq,
+      mmr: raw.mmr || this.lastBalance.mmr,
+      imr: raw.imr || this.lastBalance.imr,
+      upl: raw.upl || this.lastBalance.upl,
+      mgnRatio: raw.mgnRatio || this.lastBalance.mgnRatio,
+      details: raw.details ?? this.lastBalance.details
+    } : raw;
+    this.lastBalance = merged;
+    const built = buildBalance(merged, this.rawCoins, this.accountType);
+    if (built) this.onStateUpdate({ balance: built });
+  }
+}
+
+export { OkxAccountTracker };

package/dist/tracker/okx/types.d.ts

@@ -0,0 +1,8 @@
+declare enum OkxAccountType {
+    SPOT = "OKX_SPOT",
+    SINGLE_CURRENCY_MARGIN = "OKX_SINGLE",
+    MULTI_CURRENCY_MARGIN = "OKX_MULTI",
+    PORTFOLIO_MARGIN = "OKX_PORTFOLIO"
+}
+
+export { OkxAccountType };

package/dist/tracker/types.d.ts

@@ -0,0 +1,63 @@
+import { BinanceAccountType } from './binance/types.js';
+import { BybitAccountType } from './bybit/types.js';
+import { HyperliquidAccountType } from './hyperliquid/types.js';
+import { LighterAccountType } from './lighter/types.js';
+import { OkxAccountType } from './okx/types.js';
+
+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>;
+}
+
+export { ACCOUNT_TYPE_LABELS, type AccountBalance, type AccountPosition, type AccountType, type AssetBalance, type BalanceCallback, type ExchangeState, type MarginMode, type PositionsCallback, type StateUpdate, type TrackedAssetCallback, type TrackedAssetInfo };

package/dist/{account → tracker}/types.js

@@ -1,7 +1,8 @@
-import { BinanceAccountType } from './exchanges/binance/types';
-import { BybitAccountType } from './exchanges/bybit/types';
-import { HyperliquidAccountType } from './exchanges/hyperliquid/types';
-import { OkxAccountType } from './exchanges/okx/types';
+import { BinanceAccountType } from './binance/types';
+import { BybitAccountType } from './bybit/types';
+import { HyperliquidAccountType } from './hyperliquid/types';
+import { LighterAccountType } from './lighter/types';
+import { OkxAccountType } from './okx/types';
 
 const ACCOUNT_TYPE_LABELS = {
   [BinanceAccountType.SINGLE_ASSET]: "Single-Asset Mode",
@@ -14,6 +15,7 @@ const ACCOUNT_TYPE_LABELS = {
   [HyperliquidAccountType.DEX_ABSTRACTION]: "Standard (Shared HIP-3 Balance)",
   [HyperliquidAccountType.PORTFOLIO_MARGIN]: "Portfolio Margin",
   [HyperliquidAccountType.UNIFIED_ACCOUNT]: "Unified Account",
+  [LighterAccountType.BASIC]: "Standard",
   [OkxAccountType.SPOT]: "Spot Mode",
   [OkxAccountType.SINGLE_CURRENCY_MARGIN]: "Single-Currency Margin",
   [OkxAccountType.MULTI_CURRENCY_MARGIN]: "Multi-Currency Margin",