@pear-protocol/exchanges-sdk 0.14.1 → 0.16.0

package/dist/tracker/hyperliquid/mapper.js

@@ -232,6 +232,9 @@ function mapPortfolioMarginBalance(context) {
     portfolioMarginRatio: wireMarginRatio(context),
     portfolioAccountLeverage: portfolioAccountLeverage(context),
     borrowCapUsed: worstBorrowCapUsed(context),
+    borrowedValue: borrowedValueOf(context),
+    healthFactor: wireHealthFactor(context),
+    borrowLendReserves: borrowLendReserveRows(context),
     perDexState: context.summary.perDexState,
     timestamp: context.timestamp
   };
@@ -256,7 +259,8 @@ function portfolioMarginCollateralRows(context) {
       availableMargin: context.availableMarginByToken.get(balance.token) ?? null,
       withdrawable: signed(total.minus(toDecimal(balance.hold)).toFixed()),
       ltv: balance.ltv === null ? null : toDecimal(balance.ltv).toFixed(),
-      borrowCapUsed: borrowCapUsedFor(context, balance.token)
+      borrowCapUsed: borrowCapUsedFor(context, balance.token),
+      borrowed: toDecimal(balance.borrowed).toFixed()
     });
   }
   rows.sort(byRowAsset);
@@ -283,6 +287,22 @@ function worstBorrowCapUsed(context) {
   return worst.isZero() ? null : worst.toFixed(RATIO_DECIMALS);
 }
 __name(worstBorrowCapUsed, "worstBorrowCapUsed");
+function borrowedValueOf(context) {
+  let borrowed = ZERO;
+  for (const balance of context.spotBalances.values()) {
+    const debt = toDecimal(balance.borrowed);
+    if (debt.isZero()) {
+      continue;
+    }
+    const mid = context.prices.midForToken(balance.token);
+    if (mid === null) {
+      return null;
+    }
+    borrowed = borrowed.plus(debt.times(toDecimal(mid)));
+  }
+  return borrowed.toFixed();
+}
+__name(borrowedValueOf, "borrowedValueOf");
 function wireMarginRatio(context) {
   if (context.portfolioMarginRatio === null) {
     return null;
@@ -290,6 +310,38 @@ function wireMarginRatio(context) {
   return toDecimal(context.portfolioMarginRatio).toFixed(RATIO_DECIMALS);
 }
 __name(wireMarginRatio, "wireMarginRatio");
+function wireHealthFactor(context) {
+  const healthFactor = context.borrowLend.healthFactor;
+  if (healthFactor === null) {
+    return null;
+  }
+  return toDecimal(healthFactor).toFixed(RATIO_DECIMALS);
+}
+__name(wireHealthFactor, "wireHealthFactor");
+function borrowLendReserveRows(context) {
+  const rows = [];
+  for (const [token, rates] of context.borrowLend.ratesByToken) {
+    const asset = context.collateralTokenNames.get(token);
+    if (asset === void 0) {
+      continue;
+    }
+    rows.push({
+      asset,
+      borrowYearlyRate: toDecimal(rates.borrowYearlyRate).toFixed(),
+      supplyYearlyRate: toDecimal(rates.supplyYearlyRate).toFixed()
+    });
+  }
+  rows.sort(byReserveAsset);
+  return rows;
+}
+__name(borrowLendReserveRows, "borrowLendReserveRows");
+function byReserveAsset(left, right) {
+  if (left.asset === right.asset) {
+    return 0;
+  }
+  return left.asset < right.asset ? -1 : 1;
+}
+__name(byReserveAsset, "byReserveAsset");
 function portfolioAccountLeverage(context) {
   const collateral = haircutCollateral(context);
   if (collateral === null) {

package/dist/tracker/hyperliquid/tracker.js

@@ -2,6 +2,7 @@ import { createExchangeWs } from '../../client';
 import { fetchPerpDexs, fetchInfo, fetchAllMids, fetchUserAbstraction, fetchSpotClearinghouseState, fetchDelegatorSummary, fetchUserVaultEquities, fetchClearinghouseState, fetchActiveAssetData } from '../../client/hyperliquid/rest';
 import { BaseAccountTracker } from '../base';
 import { resolveHyperliquidAccountType } from './account-mode';
+import { EMPTY_BORROW_LEND_STATE, fetchBorrowLendState } from './borrow-lend';
 import { buildAvailableMarginByToken, buildCollateralTokenNames, minimumAvailableToTrade } from './collateral';
 import { LOCKED_TRACKED_COINS } from './const';
 import { toDecimal, ZERO } from './decimal';
@@ -15,6 +16,7 @@ const EMPTY_SPOT_META = {
   tokens: [],
   universe: []
 };
+const BORROW_LEND_POLL_INTERVAL_MS = 3e4;
 class HyperliquidAccountTracker extends BaseAccountTracker {
   static {
     __name(this, "HyperliquidAccountTracker");
@@ -30,6 +32,11 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
   /** Portfolio Margin's own risk scalars, which ride the same `spotState` frame the balances do. */
   portfolioMarginRatio = null;
   borrowRatioByToken = /* @__PURE__ */ new Map();
+  /** Portfolio Margin's REST-only figures, and the timer that keeps them fresh while in that mode. */
+  borrowLend = EMPTY_BORROW_LEND_STATE;
+  borrowLendPollTimer = null;
+  /** Advances on every stop, so a read fired in an earlier poll period is recognised and dropped. */
+  borrowLendPollGeneration = 0;
   hasSpotState = false;
   hasClearinghouseState = false;
   accountType = null;
@@ -74,8 +81,10 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     })));
     const assetData = await this.fetchActiveAssetEvents(this.coinsForAvailableMargin());
     const { summary, assetPositions } = aggregateClearinghouseStates(clearinghouseStates);
+    const accountType = resolveHyperliquidAccountType(abstraction);
+    const borrowLend = accountType === HyperliquidAccountType.PORTFOLIO_MARGIN ? await fetchBorrowLendState(user, this.demo) : EMPTY_BORROW_LEND_STATE;
     const balance = mapBalance({
-      accountType: resolveHyperliquidAccountType(abstraction),
+      accountType,
       summary,
       spotBalances: mapSpotBalances(spotState),
       prices: SpotPrices.from(spotMeta, mids),
@@ -86,6 +95,7 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       availableMarginByToken: buildAvailableMarginByToken(summary.perDexState, assetData.values()),
       portfolioMarginRatio: spotState.portfolioMarginRatio ?? null,
       borrowRatioByToken: mapBorrowRatios(spotState),
+      borrowLend,
       timestamp: Date.now()
     });
     const positions = Array.from(mapPositions(assetPositions).values());
@@ -116,6 +126,7 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     const lifecycleVersion = ++this.lifecycleVersion;
     const user = this.addrLower();
     this.destroyCurrentSocket();
+    this.stopBorrowLendPoll();
     this.subscribedCoins.clear();
     this.resetLiveAccountState();
     this.dexToMeta.clear();
@@ -148,6 +159,7 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     this.messageListenerId = this.ws.addMessageListener((raw) => this.routeRaw(raw));
     this.openListenerId = this.ws.addOpenListener(() => this.resubscribeAll());
     this.sendStaticSubs();
+    this.syncBorrowLendPoll();
     const coinsToTrack = /* @__PURE__ */ new Set([
       ...LOCKED_TRACKED_COINS,
       ...this.trackedCoins
@@ -159,6 +171,7 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
   async cleanupConnections() {
     this.lifecycleVersion += 1;
     this.destroyCurrentSocket();
+    this.stopBorrowLendPoll();
     this.subscribedCoins.clear();
   }
   /** Detaches and destroys the active socket without changing the current lifecycle generation. */
@@ -422,6 +435,7 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       this.resetLiveAccountState();
     }
     this.accountType = nextAccountType;
+    this.syncBorrowLendPoll();
     this.vaultEquity = sumLiveVaultEquity(data.perpDexStates ?? []);
     this.hasWebData3 = true;
     if (!nextAccountType) {
@@ -475,9 +489,68 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       availableMarginByToken: buildAvailableMarginByToken(this.lastSummary.perDexState, this.trackedAssetData.values()),
       portfolioMarginRatio: this.portfolioMarginRatio,
       borrowRatioByToken: this.borrowRatioByToken,
+      borrowLend: this.borrowLend,
       timestamp: Date.now()
     });
   }
+  /**
+  * Runs the borrow/lend poll exactly while the account is in Portfolio Margin.
+  *
+  * Safe to call on every mode read: a poll already in the state the mode asks for is left alone,
+  * so a steady stream of `webData3` frames neither restarts the timer nor refires a read.
+  */
+  syncBorrowLendPoll() {
+    const wantsPoll = this.accountType === HyperliquidAccountType.PORTFOLIO_MARGIN;
+    if (wantsPoll === (this.borrowLendPollTimer !== null)) {
+      return;
+    }
+    if (!wantsPoll) {
+      this.stopBorrowLendPoll();
+      return;
+    }
+    void this.refreshBorrowLendState();
+    this.borrowLendPollTimer = setInterval(() => void this.refreshBorrowLendState(), BORROW_LEND_POLL_INTERVAL_MS);
+  }
+  /**
+  * Stops the borrow/lend poll and drops its figures, so no later mode or session inherits them.
+  *
+  * Every stop opens a new generation — a session ending, a restart, or the account leaving
+  * Portfolio Margin — so a read still in flight from the period just ended can never land.
+  */
+  stopBorrowLendPoll() {
+    if (this.borrowLendPollTimer !== null) {
+      clearInterval(this.borrowLendPollTimer);
+      this.borrowLendPollTimer = null;
+    }
+    this.borrowLendPollGeneration += 1;
+    this.borrowLend = EMPTY_BORROW_LEND_STATE;
+  }
+  /**
+  * Reads the health factor and reserve rates once, then republishes the balance with them.
+  *
+  * A failed read is reported and left for the next tick: the previous figures stay in place, since
+  * one missed read says nothing about the account that the last good one did not.
+  */
+  async refreshBorrowLendState() {
+    const generation = this.borrowLendPollGeneration;
+    let borrowLend;
+    try {
+      borrowLend = await fetchBorrowLendState(this.addrLower(), this.demo);
+    } catch (err) {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    if (generation !== this.borrowLendPollGeneration) {
+      return;
+    }
+    this.borrowLend = borrowLend;
+    const balance = this.buildBalance();
+    if (balance !== void 0) {
+      this.onStateUpdate({
+        balance
+      });
+    }
+  }
   /** The floor of `availableToTrade` over the tracked set; `null` when nothing is tracked. */
   availableMargin() {
     return minimumAvailableToTrade(this.trackedAssetData.values());
@@ -540,7 +613,9 @@ function mapSpotBalances(spotState) {
       hold: balance.hold,
       // An absent `ltv` means "not collateral", which weighs zero — never a zero weight, which is
       // a stablecoin at full value. The two states stay apart from the wire onward.
-      ltv: balance.ltv ?? null
+      ltv: balance.ltv ?? null,
+      // An absent `borrowed` means the coin was never borrowed; the key rides only a borrowed coin.
+      borrowed: balance.borrowed ?? null
     });
   }
   return balances;

package/dist/tracker/index.js

@@ -13,8 +13,9 @@ export { ACCOUNT_MODE_LABELS, AccountBalanceCore, AccountMode, CollateralBalance
 export { BaseAccountTracker } from './base';
 export { BinanceMultiAssetBalance, BinanceSingleAssetBalance } from './binance/balance';
 export { BybitIsolatedMarginBalance, BybitPortfolioMarginBalance, BybitRegularMarginBalance } from './bybit/balance';
-export { HyperliquidDexState, HyperliquidPortfolioMarginBalance, HyperliquidPortfolioMarginCollateral, HyperliquidStandardBalance, HyperliquidUnifiedBalance } from './hyperliquid/balance';
+export { HyperliquidBorrowLendReserve, HyperliquidDexState, HyperliquidPortfolioMarginBalance, HyperliquidPortfolioMarginCollateral, HyperliquidStandardBalance, HyperliquidUnifiedBalance } from './hyperliquid/balance';
 export { LighterClassicBalance, LighterUnifiedBalance } from './lighter/balance';
+export { LIGHTER_QUOTE_ASSETS } from './lighter/const';
 export { OkxFuturesBalance, OkxMultiCurrencyMarginBalance, OkxPortfolioMarginBalance, OkxSpotBalance } from './okx/balance';
 export * from './types';
 
@@ -48,8 +49,10 @@ function createAccountTracker(exchange, config) {
         credentials: config.credentials
       });
     case "lighter":
+    case "lighter_rhc":
       return new LighterAccountTracker({
         sdk: config.sdk,
+        connector: exchange,
         demo: config.demo,
         onError: config.onError,
         account: config.account,

package/dist/tracker/lighter/const.js

@@ -1,3 +1,6 @@
-const QUOTE_ASSET = "USDC";
+const LIGHTER_QUOTE_ASSETS = {
+  lighter: "USDC",
+  lighter_rhc: "USDG"
+};
 
-export { QUOTE_ASSET };
+export { LIGHTER_QUOTE_ASSETS };

package/dist/tracker/lighter/mapper.js

@@ -1,6 +1,5 @@
 import BigNumber from 'bignumber.js';
 import { positionKey } from '../utils';
-import { QUOTE_ASSET } from './const';
 import { LighterAccountType } from './types';
 
 var __defProp = Object.defineProperty;
@@ -19,8 +18,8 @@ function mapLiveBalance(stats, assets, positions, markets, timestamp) {
   const heldAssets = Array.from(assets);
   const risks = toPositionRisks(openPositions, markets.perpByMarketId);
   const crossEquity = toDecimal(stats.cross.portfolio_value);
-  const equity = toEquitySplit(heldAssets, markets.spotPriceBySymbol);
-  const perCollateral = toCollateralRows(heldAssets, stats.total.available_balance);
+  const equity = toEquitySplit(heldAssets, markets.spotPriceBySymbol, markets.quoteAsset);
+  const perCollateral = toCollateralRows(heldAssets, stats.total.available_balance, markets.quoteAsset);
   const crossMaintenance = asMarginRequirement(sumMaintenance(risks, "cross"));
   const isolatedMaintenance = asMarginRequirement(sumMaintenance(risks, "isolated"));
   return toLighterBalance({
@@ -51,8 +50,8 @@ function mapRestBalance(account, markets, timestamp) {
   const crossEquity = toDecimal(account.cross_asset_value);
   const crossMaintenance = toDecimal(account.cross_maintenance_margin_requirement);
   const isolatedMaintenance = asMarginRequirement(sumMaintenance(risks, "isolated"));
-  const equity = toEquitySplit(assets, markets.spotPriceBySymbol);
-  const perCollateral = toCollateralRows(assets, account.available_balance);
+  const equity = toEquitySplit(assets, markets.spotPriceBySymbol, markets.quoteAsset);
+  const perCollateral = toCollateralRows(assets, account.available_balance, markets.quoteAsset);
   return toLighterBalance({
     accountMode: ACCOUNT_MODE_BY_TYPE[toLighterAccountType(account.account_trading_mode)],
     equity,
@@ -119,10 +118,10 @@ function mapMarketDefaultAssetInfo(market) {
   };
 }
 __name(mapMarketDefaultAssetInfo, "mapMarketDefaultAssetInfo");
-function buildSpotPriceIndex(spotMarkets) {
+function buildSpotPriceIndex(spotMarkets, quoteAsset) {
   const priceBySymbol = /* @__PURE__ */ new Map([
     [
-      QUOTE_ASSET,
+      quoteAsset,
       "1"
     ]
   ]);
@@ -206,11 +205,11 @@ function toLighterBalance(figures) {
   }
 }
 __name(toLighterBalance, "toLighterBalance");
-function toEquitySplit(assets, priceBySymbol) {
+function toEquitySplit(assets, priceBySymbol, quoteAsset) {
   let perpetuals = new BigNumber(0);
   let spot = new BigNumber(0);
   for (const asset of assets) {
-    if (asset.symbol === QUOTE_ASSET) {
+    if (asset.symbol === quoteAsset) {
       perpetuals = sumOf([
         perpetuals,
         toDecimal(asset.margin_balance)
@@ -240,14 +239,14 @@ function toEquitySplit(assets, priceBySymbol) {
   };
 }
 __name(toEquitySplit, "toEquitySplit");
-function toCollateralRows(assets, availableBalance) {
+function toCollateralRows(assets, availableBalance, quoteAsset) {
   const rows = [];
   for (const asset of assets) {
     const held = heldAmount(asset);
     if (held === null || held.isZero()) {
       continue;
     }
-    rows.push(toCollateralRow(asset.symbol, held, availableBalance));
+    rows.push(toCollateralRow(asset.symbol, held, availableBalance, quoteAsset));
   }
   rows.sort(byAssetName);
   return rows;
@@ -260,8 +259,8 @@ function heldAmount(asset) {
   ]);
 }
 __name(heldAmount, "heldAmount");
-function toCollateralRow(asset, held, availableBalance) {
-  if (asset !== QUOTE_ASSET) {
+function toCollateralRow(asset, held, availableBalance, quoteAsset) {
+  if (asset !== quoteAsset) {
     return {
       asset,
       equity: held.toFixed(),

package/dist/tracker/lighter/tracker.js

@@ -3,6 +3,7 @@ import { createExchangeWs } from '../../client';
 import { fetchAccount, fetchPublicAccount, fetchOrderBookDetails, fetchPublicOrderBookDetails, fetchAccountLimits } from '../../client/lighter/rest';
 import { retrieveLighterAuthToken } from '../../helper/lighter/auth-token.helper';
 import { BaseAccountTracker } from '../base';
+import { LIGHTER_QUOTE_ASSETS } from './const';
 import { buildSpotPriceIndex, mapPositions, mapRestBalance, mapMarketDefaultAssetInfo, toLighterAccountType, mapLiveBalance, toLighterAccountTier } from './mapper';
 
 var __defProp = Object.defineProperty;
@@ -32,6 +33,8 @@ class LighterAccountTracker extends BaseAccountTracker {
     __name(this, "LighterAccountTracker");
   }
   sdk;
+  connector;
+  quoteAsset;
   accountIdentifier;
   apiKeyIndex;
   apiPrivateKey;
@@ -55,9 +58,7 @@ class LighterAccountTracker extends BaseAccountTracker {
   positionsByMarketId = /* @__PURE__ */ new Map();
   marketsByMarketId = /* @__PURE__ */ new Map();
   marketsBySymbol = /* @__PURE__ */ new Map();
-  // Seeded empty, which still prices the quote asset — spot dollars are dollars before any
-  // market data arrives, and a balance the index cannot price would otherwise read as unknown.
-  spotPriceBySymbol = buildSpotPriceIndex([]);
+  spotPriceBySymbol;
   stats = null;
   // Null until the authenticated read lands, and null for good where nothing can authenticate it.
   accountTier = null;
@@ -68,6 +69,9 @@ class LighterAccountTracker extends BaseAccountTracker {
     super(config);
     const credentials = config.credentials;
     this.sdk = config.sdk;
+    this.connector = config.connector;
+    this.quoteAsset = LIGHTER_QUOTE_ASSETS[config.connector];
+    this.spotPriceBySymbol = buildSpotPriceIndex([], this.quoteAsset);
     this.accountIdentifier = config.account.exchangeIdentifier;
     this.apiKeyIndex = credentials.api_key_index;
     this.apiPrivateKey = credentials.api_private_key;
@@ -119,7 +123,7 @@ class LighterAccountTracker extends BaseAccountTracker {
     };
     const { positions } = mapPositions(toPosRecord(account.positions ?? []));
     return {
-      balance: mapRestBalance(account, toMarketContext(markets.perp, markets.spot), Date.now()),
+      balance: mapRestBalance(account, toMarketContext(markets.perp, markets.spot, this.quoteAsset), Date.now()),
       positions: Array.from(positions.values())
     };
   }
@@ -161,7 +165,7 @@ class LighterAccountTracker extends BaseAccountTracker {
     const lifecycleVersion = ++this.lifecycleVersion;
     const markets = await this.fetchMarkets();
     if (lifecycleVersion !== this.lifecycleVersion) return;
-    this.spotPriceBySymbol = buildSpotPriceIndex(markets.spot);
+    this.spotPriceBySymbol = buildSpotPriceIndex(markets.spot, this.quoteAsset);
     const trackedAssets = /* @__PURE__ */ new Map();
     for (const m of markets.perp) {
       this.marketsByMarketId.set(m.market_id, m);
@@ -171,7 +175,7 @@ class LighterAccountTracker extends BaseAccountTracker {
     this.onStateUpdate({
       trackedAssets
     });
-    const ws = (await createExchangeWs("lighter", {
+    const ws = (await createExchangeWs(this.connector, {
       demo: this.demo,
       credentials: this.credentials
     })).main;
@@ -382,20 +386,21 @@ class LighterAccountTracker extends BaseAccountTracker {
   marketContext() {
     return {
       perpByMarketId: this.marketsByMarketId,
-      spotPriceBySymbol: this.spotPriceBySymbol
+      spotPriceBySymbol: this.spotPriceBySymbol,
+      quoteAsset: this.quoteAsset
     };
   }
   /** Reads the account with credentials when present, or explicitly uses the read-only verifier path. */
   async fetchPrimaryAccount() {
     const authToken = await this.retrieveAuthToken();
     const accountIndex = Number(this.accountIdentifier);
-    const data = authToken ? await fetchAccount(accountIndex, authToken, this.demo) : await fetchPublicAccount(accountIndex, this.demo);
+    const data = authToken ? await fetchAccount(accountIndex, authToken, this.connector, this.demo) : await fetchPublicAccount(accountIndex, this.connector, this.demo);
     return data.accounts[0];
   }
   /** Reads market context under the same account identity as the snapshot that consumes it. */
   async fetchMarkets() {
     const authToken = await this.retrieveAuthToken();
-    return authToken ? fetchOrderBookDetails(authToken, this.demo) : fetchPublicOrderBookDetails(this.demo);
+    return authToken ? fetchOrderBookDetails(authToken, this.connector, this.demo) : fetchPublicOrderBookDetails(this.connector, this.demo);
   }
   /** Returns this account's cached auth token, or no token for the explicit empty-key verifier. */
   async retrieveAuthToken() {
@@ -405,7 +410,7 @@ class LighterAccountTracker extends BaseAccountTracker {
     if (!this.sdk) {
       throw new Error("Lighter authenticated account reads require a Pear SDK client");
     }
-    return retrieveLighterAuthToken(this.sdk, {
+    return retrieveLighterAuthToken(this.sdk, this.connector, {
       accountIndex: Number(this.accountIdentifier),
       apiKeyIndex: this.apiKeyIndex,
       apiPrivateKey: this.apiPrivateKey
@@ -499,12 +504,12 @@ class LighterAccountTracker extends BaseAccountTracker {
     try {
       const credentials = this.credentials;
       const accountIndex = Number(this.accountIdentifier);
-      const authToken = await retrieveLighterAuthToken(this.sdk, {
+      const authToken = await retrieveLighterAuthToken(this.sdk, this.connector, {
         accountIndex,
         apiKeyIndex: credentials.api_key_index,
         apiPrivateKey: credentials.api_private_key
       }, this.demo);
-      const limits = await fetchAccountLimits(accountIndex, authToken, this.demo);
+      const limits = await fetchAccountLimits(accountIndex, authToken, this.connector, this.demo);
       const accountTier = toLighterAccountTier(limits.user_tier);
       if (lifecycleVersion !== this.lifecycleVersion) {
         return;
@@ -565,7 +570,7 @@ class LighterAccountTracker extends BaseAccountTracker {
         this.marketsBySymbol.set(market.symbol, market);
       }
       if (markets.spot.length > 0) {
-        this.spotPriceBySymbol = buildSpotPriceIndex(markets.spot);
+        this.spotPriceBySymbol = buildSpotPriceIndex(markets.spot, this.quoteAsset);
       }
       const balance = this.buildBalance();
       if (balance) this.onStateUpdate({
@@ -578,13 +583,14 @@ class LighterAccountTracker extends BaseAccountTracker {
     }
   }
 }
-function toMarketContext(perpMarkets, spotMarkets) {
+function toMarketContext(perpMarkets, spotMarkets, quoteAsset) {
   return {
     perpByMarketId: new Map(perpMarkets.map((market) => [
       market.market_id,
       market
     ])),
-    spotPriceBySymbol: buildSpotPriceIndex(spotMarkets)
+    spotPriceBySymbol: buildSpotPriceIndex(spotMarkets, quoteAsset),
+    quoteAsset
   };
 }
 __name(toMarketContext, "toMarketContext");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/exchanges-sdk",
-  "version": "0.14.1",
+  "version": "0.16.0",
   "description": "Pear Protocol Exchanges SDK",
   "private": false,
   "type": "module",
@@ -27,9 +27,9 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@pear-protocol/core-sdk": "^2.0.0",
-    "@pear-protocol/types": "^2.0.0",
-    "@pear-protocol/utils": "^1.0.0",
+    "@pear-protocol/core-sdk": "^2.2.0",
+    "@pear-protocol/types": "^2.2.0",
+    "@pear-protocol/utils": "^1.1.0",
     "bignumber.js": "^11.1.1",
     "partysocket": "^1.0.3",
     "viem": "^2.48.8",