@pear-protocol/exchanges-sdk 0.0.18 → 0.1.1

package/dist/tracker/index.d.ts

@@ -0,0 +1,38 @@
+import { Connector } from '@pear-protocol/types';
+import { ExchangeWsByConnector } from '../client/index.js';
+import { SupportedCredentials } from '../types.js';
+import { AccountTrackerConfig, AccountTracker } from './base.js';
+export { BaseAccountTracker } from './base.js';
+export { BinanceAccountTracker, BinanceAccountTrackerConfig } from './binance/tracker.js';
+export { BinanceAccountType } from './binance/types.js';
+export { BybitAccountTracker, BybitAccountTrackerConfig } from './bybit/tracker.js';
+export { BybitAccountType } from './bybit/types.js';
+export { HyperliquidAccountTracker, HyperliquidAccountTrackerConfig } from './hyperliquid/tracker.js';
+export { HyperliquidAccountType } from './hyperliquid/types.js';
+export { LighterAccountTracker, LighterAccountTrackerConfig } from './lighter/tracker.js';
+export { LighterAccountType } from './lighter/types.js';
+export { OkxAccountTracker, OkxAccountTrackerConfig } from './okx/tracker.js';
+export { OkxAccountType } from './okx/types.js';
+export { ACCOUNT_TYPE_LABELS, AccountBalance, AccountPosition, AccountType, AssetBalance, BalanceCallback, ExchangeState, MarginMode, PositionsCallback, StateUpdate, TrackedAssetCallback, TrackedAssetInfo } from './types.js';
+import '../client/binance/exchange-ws.js';
+import '../client/base-ws.js';
+import 'partysocket';
+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/lighter/ws.js';
+import '../client/okx/exchange-ws.js';
+import '../client/okx/ws.js';
+import '@pear-protocol/core-sdk';
+
+type CreateAccountTrackerConfig<E extends Connector> = AccountTrackerConfig & {
+    credentials: SupportedCredentials;
+    ws: ExchangeWsByConnector[E];
+};
+declare function createAccountTracker<E extends Connector>(exchange: E, config: CreateAccountTrackerConfig<E>): AccountTracker;
+
+export { AccountTracker, AccountTrackerConfig, type CreateAccountTrackerConfig, createAccountTracker };

package/dist/tracker/index.js

@@ -0,0 +1,81 @@
+import { BinanceAccountTracker } from './binance/tracker';
+export { BinanceAccountTracker } from './binance/tracker';
+import { BybitAccountTracker } from './bybit/tracker';
+export { BybitAccountTracker } from './bybit/tracker';
+import { HyperliquidAccountTracker } from './hyperliquid/tracker';
+export { HyperliquidAccountTracker } from './hyperliquid/tracker';
+import { LighterAccountTracker } from './lighter/tracker';
+export { LighterAccountTracker } from './lighter/tracker';
+import { OkxAccountTracker } from './okx/tracker';
+export { OkxAccountTracker } from './okx/tracker';
+export { BaseAccountTracker } from './base';
+export { BinanceAccountType } from './binance/types';
+export { BybitAccountType } from './bybit/types';
+export { HyperliquidAccountType } from './hyperliquid/types';
+export { LighterAccountType } from './lighter/types';
+export { OkxAccountType } from './okx/types';
+export * from './types';
+
+function createAccountTracker(exchange, config) {
+  let tracker;
+  switch (exchange) {
+    case "binance": {
+      const ws = config.ws;
+      tracker = new BinanceAccountTracker({
+        demo: config.demo,
+        onError: config.onError,
+        credentials: config.credentials,
+        userDataWs: ws.userData,
+        wsApiWs: ws.wsApi
+      });
+      break;
+    }
+    case "bybit": {
+      const ws = config.ws;
+      tracker = new BybitAccountTracker({
+        demo: config.demo,
+        onError: config.onError,
+        credentials: config.credentials,
+        ws
+      });
+      break;
+    }
+    case "okx": {
+      const ws = config.ws;
+      tracker = new OkxAccountTracker({
+        demo: config.demo,
+        onError: config.onError,
+        credentials: config.credentials,
+        ws
+      });
+      break;
+    }
+    case "hyperliquid": {
+      const ws = config.ws;
+      tracker = new HyperliquidAccountTracker({
+        demo: config.demo,
+        onError: config.onError,
+        credentials: config.credentials,
+        ws: ws.main
+      });
+      break;
+    }
+    case "lighter": {
+      const ws = config.ws;
+      tracker = new LighterAccountTracker({
+        demo: config.demo,
+        onError: config.onError,
+        credentials: config.credentials,
+        ws: ws.main
+      });
+      break;
+    }
+    default: {
+      const _exhaustive = exchange;
+      throw new Error(`Unsupported exchange: ${String(_exhaustive)}`);
+    }
+  }
+  return tracker;
+}
+
+export { createAccountTracker };

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

@@ -0,0 +1,3 @@
+declare const QUOTE_ASSET = "USDC";
+
+export { QUOTE_ASSET };

package/dist/tracker/lighter/const.js

@@ -0,0 +1,3 @@
+const QUOTE_ASSET = "USDC";
+
+export { QUOTE_ASSET };

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 };