@pear-protocol/exchanges-sdk 0.6.4 → 0.6.6

package/dist/tracker/lighter/mapper.js

@@ -3,6 +3,8 @@ import { positionKey } from '../utils';
 import { QUOTE_ASSET } from './const';
 import { LighterAccountType, LighterAccountTier } from './types';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function buildAssetBalances(rawAssets) {
   const free = {};
   const used = {};
@@ -26,8 +28,14 @@ function buildAssetBalances(rawAssets) {
       usdValue: rawAsset.symbol === QUOTE_ASSET ? totalAmount : "0"
     });
   }
-  return { free, used, total, assets };
+  return {
+    free,
+    used,
+    total,
+    assets
+  };
 }
+__name(buildAssetBalances, "buildAssetBalances");
 function mapBalance(summary, assetsByAssetId, rawPositions, marketsByMarketId) {
   const { free, used, total, assets } = buildAssetBalances(assetsByAssetId.values());
   const portfolioValueBN = new BigNumber(summary.portfolioValue);
@@ -35,14 +43,8 @@ function mapBalance(summary, assetsByAssetId, rawPositions, marketsByMarketId) {
   const unrealizedPnl = portfolioValueBN.minus(summary.collateral).toFixed(6);
   const initialMarginUsed = marginUsageFrac.multipliedBy(portfolioValueBN).toFixed(6);
   const positionRisks = calculatePositionRisks(rawPositions, marketsByMarketId);
-  const maintenanceMargin = positionRisks.reduce(
-    (totalMaintenance, positionRisk) => totalMaintenance.plus(positionRisk.maintenance),
-    new BigNumber(0)
-  );
-  const isolatedEquity = positionRisks.reduce(
-    (totalEquity, positionRisk) => positionRisk.marginMode === "isolated" ? totalEquity.plus(positionRisk.equity) : totalEquity,
-    new BigNumber(0)
-  );
+  const maintenanceMargin = positionRisks.reduce((totalMaintenance, positionRisk) => totalMaintenance.plus(positionRisk.maintenance), new BigNumber(0));
+  const isolatedEquity = positionRisks.reduce((totalEquity, positionRisk) => positionRisk.marginMode === "isolated" ? totalEquity.plus(positionRisk.equity) : totalEquity, new BigNumber(0));
   const crossEquity = new BigNumber(summary.crossPortfolioValue ?? portfolioValueBN.minus(isolatedEquity));
   const marginRatio = maximumMarginRatio(positionRisks, crossEquity);
   return {
@@ -62,6 +64,7 @@ function mapBalance(summary, assetsByAssetId, rawPositions, marketsByMarketId) {
     timestamp: Date.now()
   };
 }
+__name(mapBalance, "mapBalance");
 function buildAccountBalance(account, marketsByMarketId, accountTier) {
   const { free, used, total, assets } = buildAssetBalances(account.assets ?? []);
   const positions = account.positions ?? [];
@@ -71,24 +74,13 @@ function buildAccountBalance(account, marketsByMarketId, accountTier) {
     if (position.margin_mode !== 1 || new BigNumber(position.position).isZero()) {
       return totalInitialMargin;
     }
-    return totalInitialMargin.plus(
-      new BigNumber(position.position_value).abs().times(position.initial_margin_fraction).div(100)
-    );
+    return totalInitialMargin.plus(new BigNumber(position.position_value).abs().times(position.initial_margin_fraction).div(100));
   }, new BigNumber(0));
   const initialMargin = new BigNumber(account.cross_initial_margin_requirement).plus(isolatedInitialMargin);
   const positionRisks = calculatePositionRisks(positions, marketsByMarketId);
-  const isolatedMaintenanceMargin = positionRisks.reduce(
-    (totalMaintenance, positionRisk) => positionRisk.marginMode === "isolated" ? totalMaintenance.plus(positionRisk.maintenance) : totalMaintenance,
-    new BigNumber(0)
-  );
-  const maintenanceMarginBN = new BigNumber(account.cross_maintenance_margin_requirement).plus(
-    isolatedMaintenanceMargin
-  );
-  const marginRatio = maximumMarginRatio(
-    positionRisks.filter((positionRisk) => positionRisk.marginMode === "isolated"),
-    new BigNumber(account.cross_asset_value),
-    new BigNumber(account.cross_maintenance_margin_requirement)
-  );
+  const isolatedMaintenanceMargin = positionRisks.reduce((totalMaintenance, positionRisk) => positionRisk.marginMode === "isolated" ? totalMaintenance.plus(positionRisk.maintenance) : totalMaintenance, new BigNumber(0));
+  const maintenanceMarginBN = new BigNumber(account.cross_maintenance_margin_requirement).plus(isolatedMaintenanceMargin);
+  const marginRatio = maximumMarginRatio(positionRisks.filter((positionRisk) => positionRisk.marginMode === "isolated"), new BigNumber(account.cross_asset_value), new BigNumber(account.cross_maintenance_margin_requirement));
   const unrealizedPnl = sumPositionField(positions, "unrealized_pnl").toFixed(6);
   return {
     accountType: toLighterAccountType(account.account_trading_mode),
@@ -107,6 +99,7 @@ function buildAccountBalance(account, marketsByMarketId, accountTier) {
     timestamp: Date.now()
   };
 }
+__name(buildAccountBalance, "buildAccountBalance");
 function mapPositions(raw, includeZeroPositions = false) {
   const positions = /* @__PURE__ */ new Map();
   const trackedAssets = /* @__PURE__ */ new Map();
@@ -117,7 +110,11 @@ function mapPositions(raw, includeZeroPositions = false) {
     const leverage = leverageFromImf(rawPosition.initial_margin_fraction);
     const marginType = rawPosition.margin_mode === 1 ? "isolated" : "cross";
     const marketId = String(rawPosition.market_id);
-    trackedAssets.set(marketId, { coin: rawPosition.symbol, leverage, marginType });
+    trackedAssets.set(marketId, {
+      coin: rawPosition.symbol,
+      leverage,
+      marginType
+    });
     if (!includeZeroPositions && unsignedSize.isZero()) continue;
     positions.set(positionKey(rawPosition.symbol, side), {
       symbol: rawPosition.symbol,
@@ -130,13 +127,18 @@ function mapPositions(raw, includeZeroPositions = false) {
       liquidationPrice: rawPosition.liquidation_price && rawPosition.liquidation_price !== "0" ? rawPosition.liquidation_price : null
     });
   }
-  return { positions, trackedAssets };
+  return {
+    positions,
+    trackedAssets
+  };
 }
+__name(mapPositions, "mapPositions");
 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();
 }
+__name(leverageFromImf, "leverageFromImf");
 function mapMarketDefaultAssetInfo(market) {
   return {
     coin: market.symbol,
@@ -144,9 +146,11 @@ function mapMarketDefaultAssetInfo(market) {
     marginType: "cross"
   };
 }
+__name(mapMarketDefaultAssetInfo, "mapMarketDefaultAssetInfo");
 function toLighterAccountType(accountTradingMode) {
   return accountTradingMode === 1 ? LighterAccountType.UNIFIED : LighterAccountType.CLASSIC;
 }
+__name(toLighterAccountType, "toLighterAccountType");
 function toLighterAccountTier(userTier) {
   switch (userTier?.trim().toLowerCase()) {
     case "std":
@@ -160,6 +164,7 @@ function toLighterAccountTier(userTier) {
       return void 0;
   }
 }
+__name(toLighterAccountTier, "toLighterAccountTier");
 function calculatePositionRisks(rawPositions, marketsByMarketId) {
   const positionRisks = [];
   for (const rawPosition of rawPositions) {
@@ -170,15 +175,17 @@ function calculatePositionRisks(rawPositions, marketsByMarketId) {
     const marginMode = rawPosition.margin_mode === 1 ? "isolated" : "cross";
     const maintenance = new BigNumber(rawPosition.position_value).abs().times(market.maintenance_margin_fraction).div(1e4);
     const equity = marginMode === "isolated" ? new BigNumber(rawPosition.allocated_margin).plus(rawPosition.unrealized_pnl) : new BigNumber(0);
-    positionRisks.push({ marginMode, maintenance, equity });
+    positionRisks.push({
+      marginMode,
+      maintenance,
+      equity
+    });
   }
   return positionRisks;
 }
+__name(calculatePositionRisks, "calculatePositionRisks");
 function maximumMarginRatio(positionRisks, crossEquity, authoritativeCrossMaintenance) {
-  const calculatedCrossMaintenance = positionRisks.reduce(
-    (totalMaintenance, positionRisk) => positionRisk.marginMode === "cross" ? totalMaintenance.plus(positionRisk.maintenance) : totalMaintenance,
-    new BigNumber(0)
-  );
+  const calculatedCrossMaintenance = positionRisks.reduce((totalMaintenance, positionRisk) => positionRisk.marginMode === "cross" ? totalMaintenance.plus(positionRisk.maintenance) : totalMaintenance, new BigNumber(0));
   const crossMaintenance = authoritativeCrossMaintenance ?? calculatedCrossMaintenance;
   let maximumRatio = maintenanceRatio(crossMaintenance, crossEquity);
   for (const positionRisk of positionRisks) {
@@ -188,12 +195,14 @@ function maximumMarginRatio(positionRisks, crossEquity, authoritativeCrossMainte
   }
   return maximumRatio.toFixed(4);
 }
+__name(maximumMarginRatio, "maximumMarginRatio");
 function maintenanceRatio(maintenance, equity) {
   if (equity.gt(0)) {
     return maintenance.div(equity);
   }
   return maintenance.gt(0) ? new BigNumber(1) : new BigNumber(0);
 }
+__name(maintenanceRatio, "maintenanceRatio");
 function sumPositionField(positions, field, include = () => true) {
   let total = new BigNumber(0);
   for (const position of positions) {
@@ -203,5 +212,6 @@ function sumPositionField(positions, field, include = () => true) {
   }
   return total;
 }
+__name(sumPositionField, "sumPositionField");
 
 export { buildAccountBalance, leverageFromImf, mapBalance, mapMarketDefaultAssetInfo, mapPositions, toLighterAccountTier, toLighterAccountType };

package/dist/tracker/lighter/tracker.js

@@ -1,10 +1,13 @@
 import BigNumber from 'bignumber.js';
 import { createExchangeWs } from '../../client';
 import { fetchOrderBookDetails, fetchAccount, fetchAccountLimits } from '../../client/lighter/rest';
+import { retrieveLighterAuthToken } from '../../helper/lighter/auth-token.helper';
 import { BaseAccountTracker } from '../base';
 import { mapPositions, buildAccountBalance, mapMarketDefaultAssetInfo, mapBalance, toLighterAccountTier } from './mapper';
 import { LighterAccountType } from './types';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const ACCOUNT_TIER_REFRESH_INTERVAL_MS = 6e4;
 function toPosRecord(positions) {
   const posRecord = {};
@@ -13,7 +16,11 @@ function toPosRecord(positions) {
   }
   return posRecord;
 }
+__name(toPosRecord, "toPosRecord");
 class LighterAccountTracker extends BaseAccountTracker {
+  static {
+    __name(this, "LighterAccountTracker");
+  }
   accountIdentifier;
   sdk;
   ws = null;
@@ -43,22 +50,31 @@ class LighterAccountTracker extends BaseAccountTracker {
       fetchOrderBookDetails(this.demo),
       this.fetchAccountTier()
     ]);
-    if (!account) return { balance: null, positions: [] };
+    if (!account) return {
+      balance: null,
+      positions: []
+    };
     const { positions } = mapPositions(toPosRecord(account.positions ?? []));
-    const marketsByMarketId = new Map(markets.map((market) => [market.market_id, market]));
+    const marketsByMarketId = new Map(markets.map((market) => [
+      market.market_id,
+      market
+    ]));
     return {
       balance: buildAccountBalance(account, marketsByMarketId, accountTier),
       positions: Array.from(positions.values())
     };
   }
   /**
-   * Stateless one-shot per-asset settings read, keyed by market id (the same identifier the live
-   * trackAsset path uses). One public `GET /api/v1/account` covers every market the account holds
-   * a position row for (custom margin included, even when its size is zero); `orderBookDetails`
-   * supplies the exchange default for markets absent from the account payload.
-   */
+  * Stateless one-shot per-asset settings read, keyed by market id (the same identifier the live
+  * trackAsset path uses). One public `GET /api/v1/account` covers every market the account holds
+  * a position row for (custom margin included, even when its size is zero); `orderBookDetails`
+  * supplies the exchange default for markets absent from the account payload.
+  */
   async fetchAssetSnapshots(marketIds) {
-    const [account, markets] = await Promise.all([this.fetchPrimaryAccount(), fetchOrderBookDetails(this.demo)]);
+    const [account, markets] = await Promise.all([
+      this.fetchPrimaryAccount(),
+      fetchOrderBookDetails(this.demo)
+    ]);
     const { trackedAssets } = mapPositions(toPosRecord(account?.positions ?? []), true);
     const defaults = /* @__PURE__ */ new Map();
     for (const m of markets) {
@@ -88,7 +104,10 @@ class LighterAccountTracker extends BaseAccountTracker {
   /** Creates one tracker lifecycle while repeated callers share the same pending start. */
   async performStart() {
     const lifecycleVersion = ++this.lifecycleVersion;
-    const [markets, accountTier] = await Promise.all([fetchOrderBookDetails(this.demo), this.fetchAccountTier()]);
+    const [markets, accountTier] = await Promise.all([
+      fetchOrderBookDetails(this.demo),
+      this.fetchAccountTier()
+    ]);
     if (lifecycleVersion !== this.lifecycleVersion) return;
     this.accountTier = accountTier;
     this.lastAccountTierFetchAt = Date.now();
@@ -97,8 +116,13 @@ class LighterAccountTracker extends BaseAccountTracker {
       this.marketsByMarketId.set(m.market_id, m);
       trackedAssets.set(String(m.market_id), mapMarketDefaultAssetInfo(m));
     }
-    this.onStateUpdate({ trackedAssets });
-    const ws = (await createExchangeWs("lighter", { demo: this.demo, credentials: this.credentials })).main;
+    this.onStateUpdate({
+      trackedAssets
+    });
+    const ws = (await createExchangeWs("lighter", {
+      demo: this.demo,
+      credentials: this.credentials
+    })).main;
     if (lifecycleVersion !== this.lifecycleVersion) {
       ws.destroy();
       return;
@@ -147,7 +171,9 @@ class LighterAccountTracker extends BaseAccountTracker {
     for (const market of this.marketsByMarketId.values()) {
       trackedAssets.set(String(market.market_id), mapMarketDefaultAssetInfo(market));
     }
-    this.onStateUpdate({ trackedAssets });
+    this.onStateUpdate({
+      trackedAssets
+    });
     this.sendStaticSubs();
   }
   sendStaticSubs() {
@@ -165,9 +191,15 @@ class LighterAccountTracker extends BaseAccountTracker {
       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 });
+        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 });
+        this.handle({
+          kind: "user_stats",
+          data: msg
+        });
       }
     } catch (err) {
       this.onError(err instanceof Error ? err : new Error(String(err)));
@@ -194,7 +226,9 @@ class LighterAccountTracker extends BaseAccountTracker {
       this.hasAssets = true;
     }
     if (data.positions) {
-      const positionsForMapping = { ...data.positions };
+      const positionsForMapping = {
+        ...data.positions
+      };
       if (isSnapshot) {
         this.rawPositionsByMarketId.clear();
       }
@@ -202,7 +236,10 @@ class LighterAccountTracker extends BaseAccountTracker {
         if (new BigNumber(position.position).isZero()) {
           const previousPosition = this.rawPositionsByMarketId.get(marketId);
           if (previousPosition) {
-            positionsForMapping[marketId] = { ...position, sign: previousPosition.sign };
+            positionsForMapping[marketId] = {
+              ...position,
+              sign: previousPosition.sign
+            };
           }
           this.rawPositionsByMarketId.delete(marketId);
         } else {
@@ -231,31 +268,33 @@ class LighterAccountTracker extends BaseAccountTracker {
       accountTier: this.accountTier
     };
     const balance = this.buildBalance();
-    if (balance) this.onStateUpdate({ balance });
+    if (balance) this.onStateUpdate({
+      balance
+    });
   }
   buildBalance() {
     if (!this.summary || !this.hasAssets) return null;
-    return mapBalance(
-      { ...this.summary, accountTier: this.accountTier },
-      this.assetsByAssetId,
-      this.rawPositionsByMarketId.values(),
-      this.marketsByMarketId
-    );
+    return mapBalance({
+      ...this.summary,
+      accountTier: this.accountTier
+    }, this.assetsByAssetId, this.rawPositionsByMarketId.values(), this.marketsByMarketId);
   }
   async fetchPrimaryAccount() {
     const data = await fetchAccount(Number(this.accountIdentifier), this.demo);
     return data.accounts[0];
   }
   async fetchAccountTier() {
-    if (!this.sdk || this.demo) return void 0;
+    if (!this.sdk || this.demo) {
+      return void 0;
+    }
     try {
       const credentials = this.credentials;
       const accountIndex = Number(this.accountIdentifier);
-      const { token } = await this.sdk.core.misc.lighter.createAuthToken({
+      const token = await retrieveLighterAuthToken(this.sdk, {
         accountIndex,
         apiKeyIndex: credentials.api_key_index,
         apiPrivateKey: credentials.api_private_key
-      });
+      }, this.demo);
       const limits = await fetchAccountLimits(accountIndex, token, this.demo);
       return toLighterAccountTier(limits.user_tier);
     } catch (err) {
@@ -290,7 +329,9 @@ class LighterAccountTracker extends BaseAccountTracker {
         this.accountTier = refreshedAccountTier;
         const balance = this.buildBalance();
         if (balance) {
-          this.onStateUpdate({ balance });
+          this.onStateUpdate({
+            balance
+          });
         }
       }
       if (!account || stateVersion !== this.stateVersion) return;

package/dist/tracker/lighter/types.js

@@ -1,14 +1,14 @@
-var LighterAccountType = /* @__PURE__ */ ((LighterAccountType2) => {
+var LighterAccountType = /* @__PURE__ */ (function(LighterAccountType2) {
   LighterAccountType2["BASIC"] = "classic";
   LighterAccountType2["CLASSIC"] = "classic";
   LighterAccountType2["UNIFIED"] = "unified";
   return LighterAccountType2;
-})(LighterAccountType || {});
-var LighterAccountTier = /* @__PURE__ */ ((LighterAccountTier2) => {
+})({});
+var LighterAccountTier = /* @__PURE__ */ (function(LighterAccountTier2) {
   LighterAccountTier2["STANDARD"] = "standard";
   LighterAccountTier2["PREMIUM"] = "premium";
   LighterAccountTier2["PLUS"] = "plus";
   return LighterAccountTier2;
-})(LighterAccountTier || {});
+})({});
 
 export { LighterAccountTier, LighterAccountType };

package/dist/tracker/okx/mapper.js

@@ -2,6 +2,8 @@ import BigNumber from 'bignumber.js';
 import { positionKey } from '../utils';
 import { OkxAccountType } from './types';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function mergeRawCoins(existing, incoming) {
   const merged = new Map(existing);
   for (const d of incoming) {
@@ -9,6 +11,7 @@ function mergeRawCoins(existing, incoming) {
   }
   return merged;
 }
+__name(mergeRawCoins, "mergeRawCoins");
 function buildBalance(raw, coins, accountType) {
   if (!accountType) return null;
   const isSpot = accountType === OkxAccountType.SPOT;
@@ -54,6 +57,7 @@ function buildBalance(raw, coins, accountType) {
     timestamp: Date.now()
   };
 }
+__name(buildBalance, "buildBalance");
 function mapSinglePosition(p) {
   const posBN = new BigNumber(p.pos ?? "0");
   let side;
@@ -81,6 +85,7 @@ function mapSinglePosition(p) {
     liquidationPrice: p.liqPx || null
   };
 }
+__name(mapSinglePosition, "mapSinglePosition");
 function mapPositions(raw) {
   const positions = /* @__PURE__ */ new Map();
   for (const p of raw) {
@@ -91,6 +96,7 @@ function mapPositions(raw) {
   }
   return positions;
 }
+__name(mapPositions, "mapPositions");
 function mapPositionUpdates(raw) {
   const positions = /* @__PURE__ */ new Map();
   for (const p of raw) {
@@ -99,6 +105,7 @@ function mapPositionUpdates(raw) {
   }
   return positions;
 }
+__name(mapPositionUpdates, "mapPositionUpdates");
 function acctLvToAccountType(acctLv) {
   switch (acctLv) {
     case "1":
@@ -113,5 +120,6 @@ function acctLvToAccountType(acctLv) {
       return null;
   }
 }
+__name(acctLvToAccountType, "acctLvToAccountType");
 
 export { acctLvToAccountType, buildBalance, mapPositionUpdates, mapPositions, mapSinglePosition, mergeRawCoins };

package/dist/tracker/okx/tracker.js

@@ -3,7 +3,12 @@ import { fetchLeverageInfos, fetchAccountConfig, fetchBalance, fetchPositions }
 import { BaseAccountTracker } from '../base';
 import { acctLvToAccountType, mergeRawCoins, mapPositions, buildBalance, mapPositionUpdates } from './mapper';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class OkxAccountTracker extends BaseAccountTracker {
+  static {
+    __name(this, "OkxAccountTracker");
+  }
   creds;
   ws = null;
   messageListenerId = null;
@@ -26,10 +31,10 @@ class OkxAccountTracker extends BaseAccountTracker {
     };
   }
   /**
-   * Stateless one-shot per-asset leverage read via `leverage-info`, which accepts up to 20 instIds
-   * per request (chunked in the client), so N assets cost ceil(N/20) calls. Cross margin only,
-   * matching the account-level assumption used everywhere else in this connector.
-   */
+  * Stateless one-shot per-asset leverage read via `leverage-info`, which accepts up to 20 instIds
+  * per request (chunked in the client), so N assets cost ceil(N/20) calls. Cross margin only,
+  * matching the account-level assumption used everywhere else in this connector.
+  */
   async fetchAssetSnapshots(instIds) {
     const infos = await fetchLeverageInfos(this.creds, instIds, this.demo);
     const byInstId = /* @__PURE__ */ new Map();
@@ -39,7 +44,11 @@ class OkxAccountTracker extends BaseAccountTracker {
     const result = {};
     for (const instId of instIds) {
       const info = byInstId.get(instId);
-      result[instId] = info ? { coin: instId, leverage: info.lever || "0", marginType: info.mgnMode } : null;
+      result[instId] = info ? {
+        coin: instId,
+        leverage: info.lever || "0",
+        marginType: info.mgnMode
+      } : null;
     }
     return result;
   }
@@ -47,7 +56,10 @@ class OkxAccountTracker extends BaseAccountTracker {
     const { config, balance, positions } = await this.fetchSnapshotData();
     this.accountType = acctLvToAccountType(config.acctLv);
     this.handleInitialData(balance, positions);
-    this.ws = await createExchangeWs("okx", { demo: this.demo, credentials: this.credentials });
+    this.ws = await createExchangeWs("okx", {
+      demo: this.demo,
+      credentials: this.credentials
+    });
     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));
@@ -75,36 +87,67 @@ class OkxAccountTracker extends BaseAccountTracker {
       fetchBalance(this.creds, this.demo),
       fetchPositions(this.creds, this.demo)
     ]);
-    return { config, balance, positions };
+    return {
+      config,
+      balance,
+      positions
+    };
   }
   ensureAssetTracked(instId) {
     if (this.trackedAssetInfos.has(instId)) return;
-    fetchLeverageInfos(this.creds, [instId], this.demo).catch(() => []).then((infos) => {
+    fetchLeverageInfos(this.creds, [
+      instId
+    ], this.demo).catch(() => []).then((infos) => {
       const info = infos[0];
       const leverage = info?.lever || "0";
       const marginType = info?.mgnMode;
-      const trackedAssetInfo = { coin: instId, leverage, marginType };
+      const trackedAssetInfo = {
+        coin: instId,
+        leverage,
+        marginType
+      };
       this.trackedAssetInfos.set(instId, trackedAssetInfo);
-      const trackedAssets = /* @__PURE__ */ new Map([[instId, trackedAssetInfo]]);
-      this.onStateUpdate({ trackedAssets });
+      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) });
+    this.onStateUpdate({
+      trackedAssets: new Map(this.trackedAssetInfos)
+    });
   }
   subscribe() {
     this.ws?.main.send({
       op: "subscribe",
-      args: [{ channel: "account" }, { channel: "positions", instType: "SWAP" }]
+      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) });
+    if (built) this.onStateUpdate({
+      balance: built
+    });
+    this.onStateUpdate({
+      positions: mapPositions(positions)
+    });
   }
   routeRaw(raw) {
     if (raw === "pong") return;
@@ -136,14 +179,20 @@ class OkxAccountTracker extends BaseAccountTracker {
         if (existing) {
           const leverage = p.lever || existing.leverage;
           const marginType = p.mgnMode;
-          const updated = { ...existing, leverage, marginType };
+          const updated = {
+            ...existing,
+            leverage,
+            marginType
+          };
           this.trackedAssetInfos.set(p.instId, updated);
           trackedAssets.set(p.instId, updated);
         }
       }
       this.onStateUpdate({
         positions,
-        ...trackedAssets.size > 0 ? { trackedAssets } : {}
+        ...trackedAssets.size > 0 ? {
+          trackedAssets
+        } : {}
       });
     }
   }
@@ -161,7 +210,9 @@ class OkxAccountTracker extends BaseAccountTracker {
     } : raw;
     this.lastBalance = merged;
     const built = buildBalance(merged, this.rawCoins, this.accountType);
-    if (built) this.onStateUpdate({ balance: built });
+    if (built) this.onStateUpdate({
+      balance: built
+    });
   }
 }
 

package/dist/tracker/okx/types.js

@@ -1,9 +1,9 @@
-var OkxAccountType = /* @__PURE__ */ ((OkxAccountType2) => {
+var OkxAccountType = /* @__PURE__ */ (function(OkxAccountType2) {
   OkxAccountType2["SPOT"] = "OKX_SPOT";
   OkxAccountType2["SINGLE_CURRENCY_MARGIN"] = "OKX_SINGLE";
   OkxAccountType2["MULTI_CURRENCY_MARGIN"] = "OKX_MULTI";
   OkxAccountType2["PORTFOLIO_MARGIN"] = "OKX_PORTFOLIO";
   return OkxAccountType2;
-})(OkxAccountType || {});
+})({});
 
 export { OkxAccountType };

package/dist/tracker/utils.js

@@ -1,3 +1,5 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function createEmptyState() {
   return {
     balance: null,
@@ -6,8 +8,10 @@ function createEmptyState() {
     initialized: false
   };
 }
+__name(createEmptyState, "createEmptyState");
 function positionKey(symbol, side) {
   return `${symbol}:${side}`;
 }
+__name(positionKey, "positionKey");
 
 export { createEmptyState, positionKey };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/exchanges-sdk",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "Pear Protocol Exchanges SDK",
   "private": false,
   "type": "module",
@@ -27,9 +27,9 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@pear-protocol/core-sdk": "^1.12.2",
-    "@pear-protocol/types": "^1.17.0",
-    "@pear-protocol/utils": "^0.5.0",
+    "@pear-protocol/core-sdk": "^1.17.3",
+    "@pear-protocol/types": "^1.26.0",
+    "@pear-protocol/utils": "^0.5.1",
     "bignumber.js": "^11.1.1",
     "partysocket": "^1.0.3",
     "viem": "^2.48.8"