@pear-protocol/exchanges-sdk 0.6.4 → 0.6.6

package/dist/syncer/lighter/syncer.js

@@ -1,10 +1,16 @@
 import BigNumber from 'bignumber.js';
 import { fetchAccount, fetchTradesSince, fetchPositionFundingSince } from '../../client/lighter/rest';
+import { retrieveLighterAuthToken } from '../../helper/lighter/auth-token.helper';
 import { BaseAccountSyncer } from '../base';
 import { toFundingPaymentEntries } from './funding';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const LIGHTER_FEE_TICK_DENOMINATOR = new BigNumber(1e6);
 class LighterAccountSyncer extends BaseAccountSyncer {
+  static {
+    __name(this, "LighterAccountSyncer");
+  }
   accountIndex;
   apiKeyIndex;
   apiPrivateKey;
@@ -15,12 +21,19 @@ class LighterAccountSyncer extends BaseAccountSyncer {
     this.apiKeyIndex = credentials.api_key_index;
     this.apiPrivateKey = credentials.api_private_key;
   }
-  async listExternalPositions({
-    instruments
-  }) {
-    const contractSizeByInstrumentId = new Map(
-      instruments.map((instrument) => [instrument.id, instrument.precision.quantity.contractSize])
-    );
+  /** Returns this account's shared Lighter auth token. */
+  async retrieveAuthToken() {
+    return retrieveLighterAuthToken(this.sdk, {
+      accountIndex: this.accountIndex,
+      apiKeyIndex: this.apiKeyIndex,
+      apiPrivateKey: this.apiPrivateKey
+    }, this.demo);
+  }
+  async listExternalPositions({ instruments }) {
+    const contractSizeByInstrumentId = new Map(instruments.map((instrument) => [
+      instrument.id,
+      instrument.precision.quantity.contractSize
+    ]));
     const response = await fetchAccount(this.accountIndex, this.demo);
     const rawPositions = response.accounts?.[0]?.positions ?? [];
     return rawPositions.reduce((positions, rawPosition) => {
@@ -41,16 +54,9 @@ class LighterAccountSyncer extends BaseAccountSyncer {
       return positions;
     }, []);
   }
-  async listExternalFills({
-    since,
-    instruments
-  }) {
+  async listExternalFills({ since, instruments }) {
     this.assertAuthenticatedSyncAvailable();
-    const { token } = await this.sdk.core.misc.lighter.createAuthToken({
-      accountIndex: this.accountIndex,
-      apiKeyIndex: this.apiKeyIndex,
-      apiPrivateKey: this.apiPrivateKey
-    });
+    const token = await this.retrieveAuthToken();
     const trades = await fetchTradesSince(this.accountIndex, token, since, this.demo);
     const instrumentIds = new Set(instruments.map((instrument) => instrument.id));
     return trades.toSorted((a, b) => a.timestamp - b.timestamp).reduce((fills, rawFill) => {
@@ -74,21 +80,16 @@ class LighterAccountSyncer extends BaseAccountSyncer {
         timestamp: rawFill.timestamp,
         tradeFee: this.getTradeFee(rawFill, accountSide),
         builderFee: this.getIntegratorFee(rawFill, accountSide),
-        liquidation: rawFill.type === "liquidation" ? { mark: rawFill.price } : null
+        liquidation: rawFill.type === "liquidation" ? {
+          mark: rawFill.price
+        } : null
       });
       return fills;
     }, []);
   }
-  async listExternalFunding({
-    since,
-    instruments
-  }) {
+  async listExternalFunding({ since, instruments }) {
     this.assertAuthenticatedSyncAvailable();
-    const { token } = await this.sdk.core.misc.lighter.createAuthToken({
-      accountIndex: this.accountIndex,
-      apiKeyIndex: this.apiKeyIndex,
-      apiPrivateKey: this.apiPrivateKey
-    });
+    const token = await this.retrieveAuthToken();
     const fundingEvents = await fetchPositionFundingSince(this.accountIndex, token, since, this.demo);
     const instrumentIds = new Set(instruments.map((instrument) => instrument.id));
     return toFundingPaymentEntries(fundingEvents, instrumentIds);

package/dist/syncer/okx/syncer.js

@@ -2,19 +2,23 @@ import BigNumber from 'bignumber.js';
 import { fetchPositions, fetchFillsHistorySince } from '../../client/okx/rest';
 import { BaseAccountSyncer } from '../base';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class OkxAccountSyncer extends BaseAccountSyncer {
+  static {
+    __name(this, "OkxAccountSyncer");
+  }
   creds;
   constructor(config) {
     super(config);
     this.creds = config.credentials;
   }
-  async listExternalPositions({
-    instruments
-  }) {
+  async listExternalPositions({ instruments }) {
     const rawPositions = await fetchPositions(this.creds, this.demo);
-    const contractSizeByInstrumentId = new Map(
-      instruments.map((instrument) => [instrument.id, instrument.precision.quantity.contractSize])
-    );
+    const contractSizeByInstrumentId = new Map(instruments.map((instrument) => [
+      instrument.id,
+      instrument.precision.quantity.contractSize
+    ]));
     return rawPositions.reduce((positions, rawPosition) => {
       if (!rawPosition.pos || rawPosition.pos === "0") return positions;
       const contractSize = contractSizeByInstrumentId.get(rawPosition.instId) ?? 1;
@@ -29,14 +33,12 @@ class OkxAccountSyncer extends BaseAccountSyncer {
       return positions;
     }, []);
   }
-  async listExternalFills({
-    since,
-    instruments
-  }) {
+  async listExternalFills({ since, instruments }) {
     const fills = await fetchFillsHistorySince(this.creds, since, this.demo);
-    const contractSizeByInstrumentId = new Map(
-      instruments.map((instrument) => [instrument.id, instrument.precision.quantity.contractSize])
-    );
+    const contractSizeByInstrumentId = new Map(instruments.map((instrument) => [
+      instrument.id,
+      instrument.precision.quantity.contractSize
+    ]));
     return fills.reduce((result, rawFill) => {
       const contractSize = contractSizeByInstrumentId.get(rawFill.instId) ?? 1;
       result.push({

package/dist/tracker/base.js

@@ -1,4 +1,9 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class BaseAccountTracker {
+  static {
+    __name(this, "BaseAccountTracker");
+  }
   onError;
   demo;
   credentials;
@@ -18,7 +23,9 @@ class BaseAccountTracker {
     };
   }
   async snapshotAssets(coins) {
-    const unique = [...new Set(coins)];
+    const unique = [
+      ...new Set(coins)
+    ];
     if (unique.length === 0) return {};
     return this.fetchAssetSnapshots(unique);
   }
@@ -64,9 +71,9 @@ class BaseAccountTracker {
     }
   }
   get trackedCoins() {
-    return new Set(
-      [...this.assetEntries.entries()].filter(([, entry]) => entry.listeners.size > 0).map(([coin]) => coin)
-    );
+    return new Set([
+      ...this.assetEntries.entries()
+    ].filter(([, entry]) => entry.listeners.size > 0).map(([coin]) => coin));
   }
   getBalance() {
     return this.balance;
@@ -114,7 +121,10 @@ class BaseAccountTracker {
   getOrCreateAssetEntry(coin) {
     let entry = this.assetEntries.get(coin);
     if (!entry) {
-      entry = { info: null, listeners: /* @__PURE__ */ new Set() };
+      entry = {
+        info: null,
+        listeners: /* @__PURE__ */ new Set()
+      };
       this.assetEntries.set(coin, entry);
     }
     return entry;

package/dist/tracker/binance/mapper.js

@@ -1,7 +1,8 @@
 import BigNumber from 'bignumber.js';
-import '../types';
 import { positionKey } from '../utils';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function mapBalance(raw) {
   const free = {};
   const used = {};
@@ -45,6 +46,7 @@ function mapBalance(raw) {
     timestamp: Date.now()
   };
 }
+__name(mapBalance, "mapBalance");
 function mapPositions(raw) {
   const positions = /* @__PURE__ */ new Map();
   for (const p of raw) {
@@ -65,6 +67,7 @@ function mapPositions(raw) {
   }
   return positions;
 }
+__name(mapPositions, "mapPositions");
 function mergePositions(incoming, existing) {
   const merged = /* @__PURE__ */ new Map();
   for (const [key, pos] of incoming) {
@@ -82,5 +85,6 @@ function mergePositions(incoming, existing) {
   }
   return merged;
 }
+__name(mergePositions, "mergePositions");
 
 export { mapBalance, mapPositions, mergePositions };

package/dist/tracker/binance/tracker.js

@@ -6,7 +6,12 @@ import { DEFAULT_LISTEN_KEY_REFRESH_MS, DEFAULT_ACCOUNT_POLL_MS } from './const'
 import { mapBalance, mapPositions, mergePositions } from './mapper';
 import { BinanceAccountType } from './types';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class BinanceAccountTracker extends BaseAccountTracker {
+  static {
+    __name(this, "BinanceAccountTracker");
+  }
   creds;
   userDataWs = null;
   wsApiWs = null;
@@ -28,16 +33,25 @@ class BinanceAccountTracker extends BaseAccountTracker {
   async snapshot() {
     const { snapshot, positionRisk, multiAssetsMargin } = await this.fetchSnapshotData();
     const accountType = multiAssetsMargin ? BinanceAccountType.MULTI_ASSET : BinanceAccountType.SINGLE_ASSET;
-    const balance = { ...mapBalance(snapshot), accountType };
-    return { balance, positions: Array.from(mapPositions(positionRisk).values()) };
+    const balance = {
+      ...mapBalance(snapshot),
+      accountType
+    };
+    return {
+      balance,
+      positions: Array.from(mapPositions(positionRisk).values())
+    };
   }
   /**
-   * Stateless one-shot per-asset settings read: `positionRisk` with no symbol returns leverage +
-   * margin type for every symbol (positioned or not), so any number of assets costs one call.
-   */
+  * Stateless one-shot per-asset settings read: `positionRisk` with no symbol returns leverage +
+  * margin type for every symbol (positioned or not), so any number of assets costs one call.
+  */
   async fetchAssetSnapshots(coins) {
     const risks = await fetchAllPositionRisk(this.creds, this.demo);
-    const bySymbol = new Map(risks.map((risk) => [risk.symbol, risk]));
+    const bySymbol = new Map(risks.map((risk) => [
+      risk.symbol,
+      risk
+    ]));
     const result = {};
     for (const coin of coins) {
       const risk = bySymbol.get(coin);
@@ -50,15 +64,16 @@ class BinanceAccountTracker extends BaseAccountTracker {
     this.accountType = multiAssetsMargin ? BinanceAccountType.MULTI_ASSET : BinanceAccountType.SINGLE_ASSET;
     this.handleAccountStatus(snapshot);
     this.handlePositionRisk(positionRisk, false);
-    const ws = await createExchangeWs("binance", { demo: this.demo, credentials: this.credentials });
+    const ws = await createExchangeWs("binance", {
+      demo: this.demo,
+      credentials: this.credentials
+    });
     this.userDataWs = ws.userData;
     this.wsApiWs = ws.wsApi;
     this.userDataListenerId = this.userDataWs.addMessageListener((raw) => this.routeUserData(raw));
     this.wsApiListenerId = this.wsApiWs.addMessageListener((raw) => this.routeWsApi(raw));
     this.listenKeyTimer = setInterval(() => {
-      keepAliveListenKey(this.creds.read.api_key, this.demo).catch(
-        (err) => this.onError(err instanceof Error ? err : new Error(String(err)))
-      );
+      keepAliveListenKey(this.creds.read.api_key, this.demo).catch((err) => this.onError(err instanceof Error ? err : new Error(String(err))));
     }, this.listenKeyRefreshMs);
     this.pollAccountStatus();
     this.pollTimer = setInterval(() => this.pollAccountStatus(), this.accountPollMs);
@@ -90,7 +105,11 @@ class BinanceAccountTracker extends BaseAccountTracker {
       fetchAllPositionRisk(this.creds, this.demo),
       fetchMultiAssetsMargin(this.creds, this.demo)
     ]);
-    return { snapshot, positionRisk, multiAssetsMargin };
+    return {
+      snapshot,
+      positionRisk,
+      multiAssetsMargin
+    };
   }
   ensureAssetTracked(coin) {
     if (this.trackedAssetInfos.has(coin)) return;
@@ -100,14 +119,18 @@ class BinanceAccountTracker extends BaseAccountTracker {
       this.trackedAssetInfos.set(coin, info);
       const trackedAssets = /* @__PURE__ */ new Map();
       trackedAssets.set(coin, info);
-      this.onStateUpdate({ trackedAssets });
+      this.onStateUpdate({
+        trackedAssets
+      });
     }).catch((err) => {
       this.onError(err instanceof Error ? err : new Error(String(err)));
     });
   }
   releaseAsset(coin) {
     this.trackedAssetInfos.delete(coin);
-    this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
+    this.onStateUpdate({
+      trackedAssets: new Map(this.trackedAssetInfos)
+    });
   }
   pollAccountStatus() {
     if (!this.wsApiWs?.connected) return;
@@ -134,8 +157,13 @@ class BinanceAccountTracker extends BaseAccountTracker {
     }
   }
   handleAccountStatus(result) {
-    const balance = { ...mapBalance(result), accountType: this.accountType };
-    this.onStateUpdate({ balance });
+    const balance = {
+      ...mapBalance(result),
+      accountType: this.accountType
+    };
+    this.onStateUpdate({
+      balance
+    });
   }
   handlePositionRisk(risk, merge) {
     let positions = mapPositions(risk);
@@ -143,7 +171,9 @@ class BinanceAccountTracker extends BaseAccountTracker {
       positions = mergePositions(positions, this.currentPositions);
     }
     this.currentPositions = positions;
-    this.onStateUpdate({ positions });
+    this.onStateUpdate({
+      positions
+    });
   }
   handleUserDataEvent(event) {
     if (event.e === "ACCOUNT_CONFIG_UPDATE" && event.ac) {
@@ -152,11 +182,16 @@ class BinanceAccountTracker extends BaseAccountTracker {
       if (symbol && leverage !== "0") {
         const existing = this.trackedAssetInfos.get(symbol);
         if (existing) {
-          const updated = { ...existing, leverage };
+          const updated = {
+            ...existing,
+            leverage
+          };
           this.trackedAssetInfos.set(symbol, updated);
           const trackedAssets = /* @__PURE__ */ new Map();
           trackedAssets.set(symbol, updated);
-          this.onStateUpdate({ trackedAssets });
+          this.onStateUpdate({
+            trackedAssets
+          });
         }
       }
       this.refreshAllPositions();
@@ -170,9 +205,7 @@ class BinanceAccountTracker extends BaseAccountTracker {
     for (const pos of this.currentPositions.values()) symbols.add(pos.symbol);
     for (const coin of this.trackedCoins) symbols.add(coin);
     if (symbols.size === 0) return;
-    const promises = Array.from(symbols).map(
-      (symbol) => fetchPositionRisk(this.creds, symbol, this.demo).catch(() => void 0)
-    );
+    const promises = Array.from(symbols).map((symbol) => fetchPositionRisk(this.creds, symbol, this.demo).catch(() => void 0));
     Promise.all(promises).then((results) => {
       const freshPositions = /* @__PURE__ */ new Map();
       for (const risk of results) {
@@ -198,14 +231,21 @@ class BinanceAccountTracker extends BaseAccountTracker {
         }
       }
       this.currentPositions = freshPositions;
-      this.onStateUpdate({ positions: freshPositions });
+      this.onStateUpdate({
+        positions: freshPositions
+      });
     }).catch((err) => {
       this.onError(err instanceof Error ? err : new Error(String(err)));
     });
   }
 }
 function toTrackedAssetInfo(coin, risk) {
-  return { coin, leverage: risk.leverage, marginType: risk.marginType };
+  return {
+    coin,
+    leverage: risk.leverage,
+    marginType: risk.marginType
+  };
 }
+__name(toTrackedAssetInfo, "toTrackedAssetInfo");
 
 export { BinanceAccountTracker };

package/dist/tracker/binance/types.js

@@ -1,7 +1,7 @@
-var BinanceAccountType = /* @__PURE__ */ ((BinanceAccountType2) => {
+var BinanceAccountType = /* @__PURE__ */ (function(BinanceAccountType2) {
   BinanceAccountType2["MULTI_ASSET"] = "MULTI_ASSET";
   BinanceAccountType2["SINGLE_ASSET"] = "SINGLE_ASSET";
   return BinanceAccountType2;
-})(BinanceAccountType || {});
+})({});
 
 export { BinanceAccountType };

package/dist/tracker/bybit/mapper.js

@@ -1,8 +1,9 @@
 import BigNumber from 'bignumber.js';
-import '../types';
 import { positionKey } from '../utils';
 import { BybitAccountType } from './types';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function buildBalance(raw, coins, accountType) {
   if (!accountType) return null;
   const free = {};
@@ -57,6 +58,7 @@ function buildBalance(raw, coins, accountType) {
     timestamp: Date.now()
   };
 }
+__name(buildBalance, "buildBalance");
 function mergeRawCoins(existing, incoming) {
   const merged = new Map(existing);
   for (const c of incoming) {
@@ -64,6 +66,7 @@ function mergeRawCoins(existing, incoming) {
   }
   return merged;
 }
+__name(mergeRawCoins, "mergeRawCoins");
 function mapSinglePosition(p, size) {
   const side = p.side === "Buy" ? "long" : p.side === "Sell" ? "short" : "both";
   return {
@@ -77,6 +80,7 @@ function mapSinglePosition(p, size) {
     liquidationPrice: p.liqPrice || null
   };
 }
+__name(mapSinglePosition, "mapSinglePosition");
 function mapPositions(raw) {
   const positions = /* @__PURE__ */ new Map();
   for (const p of raw) {
@@ -87,6 +91,7 @@ function mapPositions(raw) {
   }
   return positions;
 }
+__name(mapPositions, "mapPositions");
 function mapPositionUpdates(raw) {
   const positions = /* @__PURE__ */ new Map();
   for (const p of raw) {
@@ -96,5 +101,6 @@ function mapPositionUpdates(raw) {
   }
   return positions;
 }
+__name(mapPositionUpdates, "mapPositionUpdates");
 
 export { buildBalance, mapPositionUpdates, mapPositions, mapSinglePosition, mergeRawCoins };

package/dist/tracker/bybit/tracker.js

@@ -2,9 +2,13 @@ import { createExchangeWs } from '../../client';
 import { fetchPositions, fetchPositionLeverage, fetchWalletBalance, fetchAccountInfo } from '../../client/bybit/rest';
 import { BaseAccountTracker } from '../base';
 import { mergeRawCoins, buildBalance, mapPositions, mapPositionUpdates } from './mapper';
-import './types';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class BybitAccountTracker extends BaseAccountTracker {
+  static {
+    __name(this, "BybitAccountTracker");
+  }
   creds;
   ws = null;
   messageListenerId = null;
@@ -25,16 +29,19 @@ class BybitAccountTracker extends BaseAccountTracker {
       const rawCoins = mergeRawCoins(/* @__PURE__ */ new Map(), wallet.coin ?? []);
       balance = buildBalance(wallet, rawCoins, accountType);
     }
-    return { balance, positions: Array.from(mapPositions(positions).values()) };
+    return {
+      balance,
+      positions: Array.from(mapPositions(positions).values())
+    };
   }
   /**
-   * Stateless one-shot per-asset settings read. Bybit has no batch leverage endpoint, but
-   * `position/list` by settleCoin returns every open position (with leverage) in one call, so
-   * only requested symbols without an open position need a per-symbol fill-in read (`?symbol=`
-   * returns the leverage setting even at size 0). For ≤2 symbols the per-symbol reads alone are
-   * cheaper than the two settleCoin reads, so the batch step is skipped. A failed fill-in maps
-   * to `null`; the read only throws when no underlying read succeeded.
-   */
+  * Stateless one-shot per-asset settings read. Bybit has no batch leverage endpoint, but
+  * `position/list` by settleCoin returns every open position (with leverage) in one call, so
+  * only requested symbols without an open position need a per-symbol fill-in read (`?symbol=`
+  * returns the leverage setting even at size 0). For ≤2 symbols the per-symbol reads alone are
+  * cheaper than the two settleCoin reads, so the batch step is skipped. A failed fill-in maps
+  * to `null`; the read only throws when no underlying read succeeded.
+  */
   async fetchAssetSnapshots(coins) {
     const bySymbol = /* @__PURE__ */ new Map();
     const useBatch = coins.length > 2;
@@ -43,14 +50,15 @@ class BybitAccountTracker extends BaseAccountTracker {
         fetchPositions(this.creds, "USDT", this.demo),
         fetchPositions(this.creds, "USDC", this.demo)
       ]);
-      for (const pos of [positionsUsd, positionsUsdc].flat()) {
+      for (const pos of [
+        positionsUsd,
+        positionsUsdc
+      ].flat()) {
         if (pos.symbol) bySymbol.set(pos.symbol, pos);
       }
     }
     const missing = coins.filter((coin) => !bySymbol.has(coin));
-    const fillIns = await Promise.allSettled(
-      missing.map((symbol) => fetchPositionLeverage(this.creds, symbol, this.demo))
-    );
+    const fillIns = await Promise.allSettled(missing.map((symbol) => fetchPositionLeverage(this.creds, symbol, this.demo)));
     missing.forEach((symbol, i) => {
       const res = fillIns[i];
       if (res?.status === "fulfilled" && res.value) bySymbol.set(symbol, res.value);
@@ -68,7 +76,10 @@ class BybitAccountTracker extends BaseAccountTracker {
   async start() {
     const { wallet, positions, accountInfo } = await this.fetchSnapshotData();
     this.handleInitialData(wallet ?? null, positions, accountInfo?.marginMode ?? null);
-    this.ws = await createExchangeWs("bybit", { demo: this.demo, credentials: this.credentials });
+    this.ws = await createExchangeWs("bybit", {
+      demo: this.demo,
+      credentials: this.credentials
+    });
     this.messageListenerId = this.ws.main.addMessageListener((raw) => this.routeRaw(raw));
     this.openListenerId = this.ws.main.addOpenListener(() => {
       this.ws?.authenticate().then(() => this.subscribe()).catch((err) => this.onError(err));
@@ -97,7 +108,14 @@ class BybitAccountTracker extends BaseAccountTracker {
       fetchPositions(this.creds, "USDC", this.demo),
       fetchAccountInfo(this.creds, this.demo)
     ]);
-    return { wallet, positions: [positionsUsd, positionsUsdc].flat(), accountInfo };
+    return {
+      wallet,
+      positions: [
+        positionsUsd,
+        positionsUsdc
+      ].flat(),
+      accountInfo
+    };
   }
   ensureAssetTracked(coin) {
     if (this.trackedAssetInfos.has(coin)) return;
@@ -106,17 +124,27 @@ class BybitAccountTracker extends BaseAccountTracker {
       this.trackedAssetInfos.set(coin, info);
       const trackedAssets = /* @__PURE__ */ new Map();
       trackedAssets.set(coin, info);
-      this.onStateUpdate({ trackedAssets });
+      this.onStateUpdate({
+        trackedAssets
+      });
     }).catch((err) => {
       this.onError(err instanceof Error ? err : new Error(String(err)));
     });
   }
   releaseAsset(coin) {
     this.trackedAssetInfos.delete(coin);
-    this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
+    this.onStateUpdate({
+      trackedAssets: new Map(this.trackedAssetInfos)
+    });
   }
   subscribe() {
-    this.ws?.main.send({ op: "subscribe", args: ["wallet", "position"] });
+    this.ws?.main.send({
+      op: "subscribe",
+      args: [
+        "wallet",
+        "position"
+      ]
+    });
   }
   handleInitialData(wallet, positions, accountType) {
     this.accountType = accountType;
@@ -124,15 +152,22 @@ class BybitAccountTracker extends BaseAccountTracker {
       this.lastWallet = wallet;
       this.rawCoins = mergeRawCoins(/* @__PURE__ */ new Map(), wallet.coin ?? []);
       const balance = buildBalance(wallet, this.rawCoins, this.accountType);
-      if (balance) this.onStateUpdate({ balance });
+      if (balance) this.onStateUpdate({
+        balance
+      });
     }
-    this.onStateUpdate({ positions: mapPositions(positions) });
+    this.onStateUpdate({
+      positions: mapPositions(positions)
+    });
   }
   routeRaw(raw) {
     try {
       const msg = JSON.parse(raw);
       if (msg.topic && msg.data) {
-        this.handleMessage({ topic: msg.topic, data: msg.data });
+        this.handleMessage({
+          topic: msg.topic,
+          data: msg.data
+        });
       }
     } catch (err) {
       this.onError(err instanceof Error ? err : new Error(String(err)));
@@ -152,14 +187,20 @@ class BybitAccountTracker extends BaseAccountTracker {
           if (existing) {
             const leverage = pos.leverage || existing.leverage;
             const marginType = pos.tradeMode === "1" ? "isolated" : "cross";
-            const updated = { ...existing, leverage, marginType };
+            const updated = {
+              ...existing,
+              leverage,
+              marginType
+            };
             this.trackedAssetInfos.set(pos.symbol, updated);
             trackedAssets.set(pos.symbol, updated);
           }
         }
         this.onStateUpdate({
           positions,
-          ...trackedAssets.size > 0 ? { trackedAssets } : {}
+          ...trackedAssets.size > 0 ? {
+            trackedAssets
+          } : {}
         });
       }
     }
@@ -179,7 +220,9 @@ class BybitAccountTracker extends BaseAccountTracker {
     } : raw;
     this.lastWallet = merged;
     const balance = buildBalance(merged, this.rawCoins, this.accountType);
-    if (balance) this.onStateUpdate({ balance });
+    if (balance) this.onStateUpdate({
+      balance
+    });
   }
 }
 function toTrackedAssetInfo(coin, pos) {
@@ -189,5 +232,6 @@ function toTrackedAssetInfo(coin, pos) {
     marginType: pos?.tradeMode === "1" ? "isolated" : "cross"
   };
 }
+__name(toTrackedAssetInfo, "toTrackedAssetInfo");
 
 export { BybitAccountTracker };

package/dist/tracker/bybit/types.js

@@ -1,8 +1,8 @@
-var BybitAccountType = /* @__PURE__ */ ((BybitAccountType2) => {
+var BybitAccountType = /* @__PURE__ */ (function(BybitAccountType2) {
   BybitAccountType2["ISOLATED_MARGIN"] = "ISOLATED_MARGIN";
   BybitAccountType2["REGULAR_MARGIN"] = "REGULAR_MARGIN";
   BybitAccountType2["PORTFOLIO_MARGIN"] = "PORTFOLIO_MARGIN";
   return BybitAccountType2;
-})(BybitAccountType || {});
+})({});
 
 export { BybitAccountType };

package/dist/tracker/hyperliquid/const.js

@@ -1,3 +1,5 @@
-const LOCKED_TRACKED_COINS = ["BTC"];
+const LOCKED_TRACKED_COINS = [
+  "BTC"
+];
 
 export { LOCKED_TRACKED_COINS };