@pear-protocol/exchanges-sdk 0.17.1 → 0.19.0

package/dist/syncer/hyperliquid/syncer.js

@@ -129,7 +129,8 @@ class HyperliquidAccountSyncer extends BaseAccountSyncer {
         timestamp: rawFill.time,
         tradeFee: tradeFee.toFixed(),
         builderFee: new BigNumber(rawFill.builderFee ?? "0").abs().toFixed(),
-        liquidation: rawFill.liquidation ? {
+        // Preserve the existing marker when attribution is absent; reject explicitly named counterparties.
+        liquidation: rawFill.liquidation && (!rawFill.liquidation.liquidatedUser || rawFill.liquidation.liquidatedUser.toLowerCase() === this.address.toLowerCase()) ? {
           mark: rawFill.liquidation.markPx
         } : null
       });

package/dist/syncer/lighter/syncer.js

@@ -82,7 +82,7 @@ class LighterAccountSyncer extends BaseAccountSyncer {
         timestamp: rawFill.timestamp,
         tradeFee: this.getTradeFee(rawFill, accountSide),
         builderFee: this.getIntegratorFee(rawFill, accountSide),
-        liquidation: rawFill.type === "liquidation" ? {
+        liquidation: rawFill.type === "liquidation" && !this.isMaker(rawFill, accountSide) ? {
           mark: rawFill.price
         } : null
       });
@@ -97,13 +97,13 @@ class LighterAccountSyncer extends BaseAccountSyncer {
     return toFundingPaymentEntries(fundingEvents, instrumentIds, this.connector);
   }
   isReduceOnly(rawFill) {
-    if (rawFill.type === "liquidation" || rawFill.type === "deleverage" || rawFill.type === "market-settlement") {
-      return true;
-    }
     const accountSide = this.getAccountSide(rawFill);
     if (!accountSide) {
       return false;
     }
+    if (rawFill.type === "liquidation" && !this.isMaker(rawFill, accountSide) || rawFill.type === "deleverage" || rawFill.type === "market-settlement") {
+      return true;
+    }
     const positionSignChanged = this.isMaker(rawFill, accountSide) ? rawFill.maker_position_sign_changed : rawFill.taker_position_sign_changed;
     if (positionSignChanged) {
       return false;

package/dist/tracker/base.js

@@ -20,6 +20,10 @@ class BaseAccountTracker {
       config.onError?.(error);
     };
   }
+  /** Only public account venues implement credential-free trading equity. */
+  async tradingEquity() {
+    throw new Error("Public trading equity is unavailable for this exchange");
+  }
   async snapshotAssets(coins) {
     const unique = [
       ...new Set(coins)

package/dist/tracker/equity.js

@@ -0,0 +1,13 @@
+import { Connector } from '@pear-protocol/types';
+import { z } from 'zod';
+
+const PublicExchangeAccount = z.object({
+  connector: Connector.describe("Exchange connector type"),
+  exchangeIdentifier: z.string().describe("User identifier on the exchange")
+});
+const TradingEquity = z.object({
+  tradingEquityUsd: z.string().regex(/^-?\d+(\.\d+)?$/),
+  timestamp: z.number().int()
+});
+
+export { PublicExchangeAccount, TradingEquity };

package/dist/tracker/hyperliquid/balance.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { DecimalString, AccountBalanceCore, SignedDecimalString } from '../balance-core';
+import { DecimalString, SignedDecimalString, AccountBalanceCore } from '../balance-core';
 
 const HyperliquidDexState = z.object({
   dex: z.string(),
@@ -9,6 +9,24 @@ const HyperliquidDexState = z.object({
   crossMaintenanceMargin: DecimalString,
   withdrawable: DecimalString
 });
+const HyperliquidSpotHolding = z.object({
+  /** The coin's wire name, as every other Hyperliquid row names it — `UBTC`, never the `BTC` alias. */
+  asset: z.string(),
+  /** The spot token index, the id `perDexState[].collateralToken` joins on. */
+  token: z.number().int(),
+  /** The venue's `total`, signed: a Portfolio Margin borrow holds a NEGATIVE total. */
+  total: SignedDecimalString,
+  /**
+  * The venue's `hold`, signed and unfloored, exactly as sent. A borrowed coin can report a NEGATIVE
+  * hold — borrowing headroom, not a lock — so a reader that wants only the lock floors it itself.
+  */
+  hold: SignedDecimalString,
+  /**
+  * The venue's `entryNtl`: what the holding COST in USDC, never what it is worth now. `null` where
+  * the wire publishes no key or an unreadable one, which is not a cost basis of zero.
+  */
+  entryNotional: SignedDecimalString.nullable()
+});
 const HyperliquidStandardBalance = AccountBalanceCore.extend({
   accountMode: z.literal("hyperliquid:standard"),
   /**
@@ -76,7 +94,9 @@ const HyperliquidStandardBalance = AccountBalanceCore.extend({
   crossMarginRatio: DecimalString,
   crossAccountLeverage: DecimalString,
   /** Kept per dex — the aggregate hides HIP-3 positions entirely. */
-  perDexState: z.array(HyperliquidDexState)
+  perDexState: z.array(HyperliquidDexState),
+  /** The whole spot wallet, one row per coin — a separate wallet from the perps side in this mode. */
+  spotHoldings: z.array(HyperliquidSpotHolding)
 });
 const HyperliquidUnifiedBalance = AccountBalanceCore.extend({
   accountMode: z.literal("hyperliquid:unified"),
@@ -117,7 +137,9 @@ const HyperliquidUnifiedBalance = AccountBalanceCore.extend({
   * leaves the quotient unknown, where a zero would claim the account carries no leverage at all.
   */
   unifiedAccountLeverage: DecimalString.nullable(),
-  perDexState: z.array(HyperliquidDexState)
+  perDexState: z.array(HyperliquidDexState),
+  /** The whole spot wallet, one row per coin — `perCollateral` lists only the dex collateral tokens. */
+  spotHoldings: z.array(HyperliquidSpotHolding)
 });
 const HyperliquidPortfolioMarginCollateral = z.object({
   asset: z.string(),
@@ -229,7 +251,9 @@ const HyperliquidPortfolioMarginBalance = AccountBalanceCore.extend({
   * shows before the first one happens. Empty until the first read lands.
   */
   borrowLendReserves: z.array(HyperliquidBorrowLendReserve),
-  perDexState: z.array(HyperliquidDexState)
+  perDexState: z.array(HyperliquidDexState),
+  /** The whole spot wallet, one row per coin, in the same shape the other two modes publish. */
+  spotHoldings: z.array(HyperliquidSpotHolding)
 });
 
-export { HyperliquidBorrowLendReserve, HyperliquidDexState, HyperliquidPortfolioMarginBalance, HyperliquidPortfolioMarginCollateral, HyperliquidStandardBalance, HyperliquidUnifiedBalance };
+export { HyperliquidBorrowLendReserve, HyperliquidDexState, HyperliquidPortfolioMarginBalance, HyperliquidPortfolioMarginCollateral, HyperliquidSpotHolding, HyperliquidStandardBalance, HyperliquidUnifiedBalance };

package/dist/tracker/hyperliquid/decimal.js

@@ -13,6 +13,10 @@ function toPrice(value) {
   return price;
 }
 __name(toPrice, "toPrice");
+function isWireDecimal(value) {
+  return value !== null && value !== void 0 && WIRE_DECIMAL.test(value.trim());
+}
+__name(isWireDecimal, "isWireDecimal");
 function toDecimal(value) {
   if (value === null || value === void 0) {
     return ZERO;
@@ -25,4 +29,4 @@ function toDecimal(value) {
 }
 __name(toDecimal, "toDecimal");
 
-export { ONE, ZERO, toDecimal, toPrice };
+export { ONE, ZERO, isWireDecimal, toDecimal, toPrice };

package/dist/tracker/hyperliquid/mapper.js

@@ -1,4 +1,7 @@
+import { parse, add as add$1, multiply } from '@pear-protocol/utils';
 import BigNumber from 'bignumber.js';
+import { z } from 'zod';
+import { TradingEquity } from '../equity';
 import { positionKey } from '../utils';
 import { toDecimal, ZERO } from './decimal';
 import { HyperliquidAccountType } from './types';
@@ -100,6 +103,43 @@ function mapBalance(context) {
   }
 }
 __name(mapBalance, "mapBalance");
+function mapTradingEquity(mode, spot, prices, states, timestamp) {
+  z.array(z.object({
+    total: TradingEquity.shape.tradingEquityUsd
+  })).parse(spot.balances);
+  const valuation = prices.valueBalances(spot.balances);
+  if (valuation.unpricedCoins.length > 0) {
+    throw new Error(`Cannot price Hyperliquid holdings: ${valuation.unpricedCoins.join(", ")}`);
+  }
+  if (mode === null) {
+    throw new Error("Unsupported Hyperliquid account mode");
+  }
+  let equity = parse(valuation.equity);
+  switch (mode) {
+    case HyperliquidAccountType.UNIFIED_ACCOUNT:
+    case HyperliquidAccountType.PORTFOLIO_MARGIN:
+      break;
+    case HyperliquidAccountType.DEFAULT:
+    case HyperliquidAccountType.DISABLED:
+      for (const { dex, collateralToken, state } of states) {
+        const value = parse(TradingEquity.shape.tradingEquityUsd.parse(state.marginSummary.accountValue));
+        if (value.isZero()) {
+          continue;
+        }
+        const price = collateralToken === null ? null : prices.midForToken(collateralToken);
+        if (price === null) {
+          throw new Error(`Cannot price Hyperliquid collateral for ${dex || "main dex"}`);
+        }
+        equity = add$1(equity, multiply(value, price));
+      }
+      break;
+  }
+  return TradingEquity.parse({
+    tradingEquityUsd: equity.toFixed(),
+    timestamp
+  });
+}
+__name(mapTradingEquity, "mapTradingEquity");
 function mapPositions(raw) {
   const positions = /* @__PURE__ */ new Map();
   for (const assetPosition of [
@@ -168,6 +208,8 @@ function mapStandardBalance(context) {
     crossMarginRatio: ratio(context.summary.crossMaintenanceMarginUsed, context.summary.crossAccountValue),
     crossAccountLeverage: accountLeverage(context.summary.crossNotional, context.summary.crossAccountValue),
     perDexState: context.summary.perDexState,
+    // The whole spot wallet in every mode, so a reader never has to know which mode lists which coins.
+    spotHoldings: spotHoldingRows(context),
     timestamp: context.timestamp
   };
 }
@@ -201,6 +243,8 @@ function mapUnifiedBalance(context) {
     unifiedAccountRatio: crossRatioAgainstFreeSpot(context),
     unifiedAccountLeverage: unifiedAccountLeverage(context),
     perDexState: context.summary.perDexState,
+    // The whole spot wallet in every mode, so a reader never has to know which mode lists which coins.
+    spotHoldings: spotHoldingRows(context),
     timestamp: context.timestamp
   };
 }
@@ -236,6 +280,8 @@ function mapPortfolioMarginBalance(context) {
     healthFactor: wireHealthFactor(context),
     borrowLendReserves: borrowLendReserveRows(context),
     perDexState: context.summary.perDexState,
+    // The whole spot wallet in every mode, so a reader never has to know which mode lists which coins.
+    spotHoldings: spotHoldingRows(context),
     timestamp: context.timestamp
   };
 }
@@ -267,6 +313,28 @@ function portfolioMarginCollateralRows(context) {
   return rows;
 }
 __name(portfolioMarginCollateralRows, "portfolioMarginCollateralRows");
+function spotHoldingRows(context) {
+  const rows = [];
+  for (const balance of context.spotBalances.values()) {
+    rows.push({
+      asset: balance.coin,
+      token: balance.token,
+      total: signed(balance.total),
+      hold: signed(balance.hold),
+      entryNotional: balance.entryNtl === null ? null : signed(balance.entryNtl)
+    });
+  }
+  rows.sort(byHoldingAsset);
+  return rows;
+}
+__name(spotHoldingRows, "spotHoldingRows");
+function byHoldingAsset(left, right) {
+  if (left.asset === right.asset) {
+    return 0;
+  }
+  return left.asset < right.asset ? -1 : 1;
+}
+__name(byHoldingAsset, "byHoldingAsset");
 function byRowAsset(left, right) {
   if (left.asset === right.asset) {
     return 0;
@@ -568,4 +636,4 @@ function ratio(numerator, denominator) {
 }
 __name(ratio, "ratio");
 
-export { aggregateClearinghouseStates, emptyClearinghouseSummary, mapBalance, mapPositions };
+export { aggregateClearinghouseStates, emptyClearinghouseSummary, mapBalance, mapPositions, mapTradingEquity };

package/dist/tracker/hyperliquid/tracker.js

@@ -1,12 +1,13 @@
+import { EthereumAddress } from '@pear-protocol/types';
 import { createExchangeWs } from '../../client';
-import { fetchPerpDexs, fetchInfo, fetchAllMids, fetchUserAbstraction, fetchSpotClearinghouseState, fetchDelegatorSummary, fetchUserVaultEquities, fetchClearinghouseState, fetchActiveAssetData } from '../../client/hyperliquid/rest';
+import { fetchDelegatorSummary, fetchUserVaultEquities, fetchInfo, fetchPerpDexs, fetchUserAbstraction, fetchSpotClearinghouseState, fetchAllMids, 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';
-import { emptyClearinghouseSummary, aggregateClearinghouseStates, mapBalance, mapPositions } from './mapper';
+import { toDecimal, isWireDecimal, ZERO } from './decimal';
+import { emptyClearinghouseSummary, aggregateClearinghouseStates, mapBalance, mapPositions, mapTradingEquity } from './mapper';
 import { SpotPrices } from './spot-pricing';
 import { HyperliquidAccountType } from './types';
 
@@ -67,7 +68,7 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
   trackedAssetData = /* @__PURE__ */ new Map();
   constructor(config) {
     super(config);
-    this.address = config.address;
+    this.address = "address" in config ? config.address : EthereumAddress.parse(config.account.exchangeIdentifier);
   }
   /**
   * Reads account mode, spot prices, collateral balances, per-DEX state, staking, vaults and
@@ -75,36 +76,21 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
   */
   async snapshot() {
     const user = this.addrLower();
-    const [perpDexs, allMetas, spotMeta, mids, abstraction, spotState, delegator, vaults] = await Promise.all([
-      fetchPerpDexs(this.demo),
-      fetchInfo({
-        type: "allPerpMetas"
-      }, this.demo),
-      fetchInfo({
-        type: "spotMeta"
-      }, this.demo),
-      fetchAllMids(this.demo),
-      fetchUserAbstraction(user, this.demo),
-      fetchSpotClearinghouseState(user, this.demo),
+    const [state, clearinghouseStates, delegator, vaults] = await Promise.all([
+      this.fetchAccountState(),
+      this.fetchPerpStates(),
       fetchDelegatorSummary(user, this.demo),
       fetchUserVaultEquities(user, this.demo)
     ]);
-    const descriptors = uniqueDexDescriptors(perpDexs, allMetas);
-    const clearinghouseStates = await Promise.all(descriptors.map(async ({ dex, meta }) => ({
-      dex,
-      collateralToken: meta?.collateralToken ?? null,
-      meta,
-      state: await fetchClearinghouseState(user, dex, this.demo)
-    })));
+    const { spotState, spotMeta, prices, accountType } = state;
     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,
       summary,
       spotBalances: mapSpotBalances(spotState),
-      prices: SpotPrices.from(spotMeta, mids),
+      prices,
       vaultEquity: sumRestVaultEquity(vaults),
       stakedHype: _stakingAccountHype(delegator),
       availableMargin: minimumAvailableToTrade(assetData.values()),
@@ -121,6 +107,13 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       positions
     };
   }
+  /** Value trading holdings with the same account reads and pricing used by snapshots. */
+  async tradingEquity() {
+    const state = await this.fetchAccountState();
+    const standard = state.accountType === HyperliquidAccountType.DEFAULT || state.accountType === HyperliquidAccountType.DISABLED;
+    const clearinghouseStates = standard ? await this.fetchPerpStates() : [];
+    return mapTradingEquity(state.accountType, state.spotState, state.prices, clearinghouseStates, Date.now());
+  }
   /**
   * Stateless one-shot per-asset settings read via the `activeAssetData` info request (the REST
   * twin of the live WS subscription), one request per coin fired in parallel — the info endpoint
@@ -384,6 +377,39 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
         break;
     }
   }
+  /** Share the public account-mode and spot valuation inputs across one-shot reads. */
+  async fetchAccountState() {
+    const user = this.addrLower();
+    const [abstraction, spotState, spotMeta, mids] = await Promise.all([
+      fetchUserAbstraction(user, this.demo),
+      fetchSpotClearinghouseState(user, this.demo),
+      fetchInfo({
+        type: "spotMeta"
+      }, this.demo),
+      fetchAllMids(this.demo)
+    ]);
+    return {
+      accountType: resolveHyperliquidAccountType(abstraction),
+      spotState,
+      spotMeta,
+      prices: SpotPrices.from(spotMeta, mids)
+    };
+  }
+  /** Retain each DEX's collateral identity when reading separate perpetual wallets. */
+  async fetchPerpStates() {
+    const [dexes, metas] = await Promise.all([
+      fetchPerpDexs(this.demo),
+      fetchInfo({
+        type: "allPerpMetas"
+      }, this.demo)
+    ]);
+    return await Promise.all(uniqueDexDescriptors(dexes, metas).map(async ({ dex, meta }) => ({
+      dex,
+      collateralToken: meta?.collateralToken ?? null,
+      meta,
+      state: await fetchClearinghouseState(this.addrLower(), dex, this.demo)
+    })));
+  }
   loadPerpMetas(allMetas, perpDexs) {
     allMetas.forEach((dexMeta, index) => {
       const dex = perpDexs[index]?.name ?? "";
@@ -774,6 +800,8 @@ function mapSpotBalances(spotState) {
       token: balance.token,
       total: balance.total,
       hold: balance.hold,
+      // An absent or unreadable `entryNtl` states no cost basis, which is not a cost basis of zero.
+      entryNtl: isWireDecimal(balance.entryNtl) ? balance.entryNtl : null,
       // 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,

package/dist/tracker/index.js

@@ -2,6 +2,8 @@ import { BinanceAccountTracker } from './binance/tracker';
 export { BinanceAccountTracker } from './binance/tracker';
 import { BybitAccountTracker } from './bybit/tracker';
 export { BybitAccountTracker } from './bybit/tracker';
+import { PublicExchangeAccount } from './equity';
+export { PublicExchangeAccount, TradingEquity } from './equity';
 import { HyperliquidAccountTracker } from './hyperliquid/tracker';
 export { HyperliquidAccountTracker } from './hyperliquid/tracker';
 import { LighterAccountTracker } from './lighter/tracker';
@@ -13,7 +15,7 @@ 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 { HyperliquidBorrowLendReserve, HyperliquidDexState, HyperliquidPortfolioMarginBalance, HyperliquidPortfolioMarginCollateral, HyperliquidStandardBalance, HyperliquidUnifiedBalance } from './hyperliquid/balance';
+export { HyperliquidBorrowLendReserve, HyperliquidDexState, HyperliquidPortfolioMarginBalance, HyperliquidPortfolioMarginCollateral, HyperliquidSpotHolding, 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';
@@ -22,6 +24,27 @@ export * from './types';
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function createAccountTracker(exchange, config) {
+  if (config.access === "public") {
+    const account = PublicExchangeAccount.parse(config.account);
+    switch (exchange) {
+      case "hyperliquid":
+        return new HyperliquidAccountTracker({
+          ...config,
+          account
+        });
+      case "lighter":
+      case "lighter_rhc":
+        return new LighterAccountTracker({
+          ...config,
+          connector: exchange,
+          account
+        });
+      case "binance":
+      case "bybit":
+      case "okx":
+        throw new Error(`Public account reads are unavailable for ${exchange}`);
+    }
+  }
   switch (exchange) {
     case "binance":
       return new BinanceAccountTracker({

package/dist/tracker/lighter/mapper.js

@@ -1,4 +1,7 @@
+import { add } from '@pear-protocol/utils';
 import BigNumber from 'bignumber.js';
+import { z } from 'zod';
+import { TradingEquity } from '../equity';
 import { positionKey } from '../utils';
 import { LighterAccountType } from './types';
 
@@ -70,6 +73,22 @@ function mapRestBalance(account, markets, timestamp) {
   });
 }
 __name(mapRestBalance, "mapRestBalance");
+function mapTradingEquity(account, markets, timestamp) {
+  const accountValue = TradingEquity.shape.tradingEquityUsd.parse(account.total_asset_value);
+  z.array(z.object({
+    symbol: z.string(),
+    balance: TradingEquity.shape.tradingEquityUsd
+  })).parse(account.assets);
+  const spotEquity = toEquitySplit(account.assets ?? [], markets.spotPriceBySymbol, markets.quoteAsset).spot;
+  if (spotEquity === null) {
+    throw new Error("Cannot price Lighter spot holdings");
+  }
+  return TradingEquity.parse({
+    tradingEquityUsd: add(accountValue, spotEquity.toFixed()).toFixed(),
+    timestamp
+  });
+}
+__name(mapTradingEquity, "mapTradingEquity");
 function mapPositions(raw, includeZeroPositions = false) {
   const positions = /* @__PURE__ */ new Map();
   const trackedAssets = /* @__PURE__ */ new Map();
@@ -429,4 +448,4 @@ function signed(value) {
 }
 __name(signed, "signed");
 
-export { buildSpotPriceIndex, leverageFromImf, mapLiveBalance, mapMarketDefaultAssetInfo, mapPositions, mapRestBalance, toLighterAccountTier, toLighterAccountType };
+export { buildSpotPriceIndex, leverageFromImf, mapLiveBalance, mapMarketDefaultAssetInfo, mapPositions, mapRestBalance, mapTradingEquity, toLighterAccountTier, toLighterAccountType };

package/dist/tracker/lighter/tracker.js

@@ -1,10 +1,11 @@
 import BigNumber from 'bignumber.js';
+import { z } from 'zod';
 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';
+import { buildSpotPriceIndex, mapPositions, mapRestBalance, mapTradingEquity, mapMarketDefaultAssetInfo, toLighterAccountType, mapLiveBalance, toLighterAccountTier } from './mapper';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -36,8 +37,6 @@ class LighterAccountTracker extends BaseAccountTracker {
   connector;
   quoteAsset;
   accountIdentifier;
-  apiKeyIndex;
-  apiPrivateKey;
   creds;
   ws = null;
   messageListenerId = null;
@@ -68,15 +67,12 @@ class LighterAccountTracker extends BaseAccountTracker {
   hasAssets = false;
   constructor(config) {
     super(config);
-    const credentials = config.credentials;
-    this.sdk = config.sdk;
+    this.creds = config.access === "public" ? null : config.credentials;
+    this.sdk = config.access === "public" ? null : 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;
-    this.creds = credentials;
+    this.accountIdentifier = z.string().regex(/^\d+$/).transform(Number).pipe(z.number().int().nonnegative().safe()).parse(config.account.exchangeIdentifier).toString();
   }
   /**
   * The tier Lighter has the account on, and every later change to it.
@@ -129,6 +125,17 @@ class LighterAccountTracker extends BaseAccountTracker {
       positions: Array.from(positions.values())
     };
   }
+  /** Reuse the snapshot read path and let the mapper include open PnL exactly once. */
+  async tradingEquity() {
+    const [account, markets] = await Promise.all([
+      this.fetchPrimaryAccount(),
+      this.fetchMarkets()
+    ]);
+    if (!account) {
+      throw new Error("Lighter account not found");
+    }
+    return mapTradingEquity(account, toMarketContext(markets.perp, markets.spot, this.quoteAsset), Date.now());
+  }
   /**
   * 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
@@ -164,6 +171,9 @@ class LighterAccountTracker extends BaseAccountTracker {
   }
   /** Creates one tracker lifecycle while repeated callers share the same pending start. */
   async performStart() {
+    if (!this.creds) {
+      throw new Error("Public Lighter trackers support REST snapshots only");
+    }
     const lifecycleVersion = ++this.lifecycleVersion;
     const markets = await this.fetchMarkets();
     if (lifecycleVersion !== this.lifecycleVersion) return;
@@ -397,6 +407,11 @@ class LighterAccountTracker extends BaseAccountTracker {
     const authToken = await this.retrieveAuthToken();
     const accountIndex = Number(this.accountIdentifier);
     const data = authToken ? await fetchAccount(accountIndex, authToken, this.connector, this.demo) : await fetchPublicAccount(accountIndex, this.connector, this.demo);
+    if (!this.creds) {
+      z.array(z.object({
+        account_index: z.literal(accountIndex)
+      })).length(1).parse(data.accounts);
+    }
     return data.accounts[0];
   }
   /** Reads market context under the same account identity as the snapshot that consumes it. */
@@ -404,9 +419,9 @@ class LighterAccountTracker extends BaseAccountTracker {
     const authToken = await this.retrieveAuthToken();
     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. */
+  /** Public access has no credentials; connected accounts reuse their cached auth token. */
   async retrieveAuthToken() {
-    if (!this.apiPrivateKey) {
+    if (!this.creds?.api_private_key) {
       return void 0;
     }
     if (!this.sdk) {
@@ -414,8 +429,8 @@ class LighterAccountTracker extends BaseAccountTracker {
     }
     return retrieveLighterAuthToken(this.sdk, this.connector, {
       accountIndex: Number(this.accountIdentifier),
-      apiKeyIndex: this.apiKeyIndex,
-      apiPrivateKey: this.apiPrivateKey
+      apiKeyIndex: this.creds.api_key_index,
+      apiPrivateKey: this.creds.api_private_key
     }, this.demo);
   }
   /** Requires credentials for private WebSocket channels even when REST is in verifier mode. */
@@ -500,7 +515,7 @@ class LighterAccountTracker extends BaseAccountTracker {
   * its tier, and blanking it would announce a change nobody made.
   */
   async performAccountTierRead(lifecycleVersion) {
-    if (!this.sdk || this.demo) {
+    if (!this.sdk || this.demo || !this.creds) {
       return;
     }
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/exchanges-sdk",
-  "version": "0.17.1",
+  "version": "0.19.0",
   "description": "Pear Protocol Exchanges SDK",
   "private": false,
   "type": "module",
@@ -27,9 +27,10 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@pear-protocol/core-sdk": "^2.3.0",
-    "@pear-protocol/types": "^2.10.0",
-    "@pear-protocol/utils": "^1.2.0",
+    "@nktkas/hyperliquid": "0.33.2",
+    "@pear-protocol/core-sdk": "^2.8.0",
+    "@pear-protocol/types": "^2.15.0",
+    "@pear-protocol/utils": "^1.3.0",
     "bignumber.js": "^11.1.1",
     "partysocket": "^1.0.3",
     "viem": "^2.48.8",