@pear-protocol/exchanges-sdk 0.6.6 → 0.7.0

package/dist/tracker/bybit/mapper.js

@@ -1,62 +1,58 @@
 import BigNumber from 'bignumber.js';
 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 = {};
-  const used = {};
-  const total = {};
-  const assets = [];
-  const isPortfolio = accountType === BybitAccountType.PORTFOLIO_MARGIN;
-  for (const [, c] of coins) {
-    const equity = c.equity ?? "0";
-    const positionInitialMargin = c.totalPositionIM === "" ? "0" : c.totalPositionIM ?? "0";
-    const orderInitialMargin = c.totalOrderIM === "" ? "0" : c.totalOrderIM ?? "0";
-    const locked = c.locked ?? "0";
-    const equityBN = new BigNumber(equity);
-    const positionInitialMarginBN = new BigNumber(positionInitialMargin);
-    const orderInitialMarginBN = new BigNumber(orderInitialMargin);
-    const lockedBN = new BigNumber(locked);
-    if (equityBN.isZero() && new BigNumber(c.walletBalance ?? "0").isZero()) continue;
-    let coinFree;
-    let coinUsed;
-    if (isPortfolio) {
-      coinFree = equityBN.minus(lockedBN).toFixed();
-      coinUsed = "0";
-    } else {
-      coinFree = equityBN.minus(positionInitialMarginBN).minus(orderInitialMarginBN).minus(lockedBN).toFixed();
-      coinUsed = positionInitialMarginBN.plus(orderInitialMarginBN).toFixed();
-    }
-    free[c.coin] = coinFree;
-    used[c.coin] = coinUsed;
-    total[c.coin] = equity;
-    assets.push({
-      asset: c.coin,
-      free: coinFree,
-      used: coinUsed,
-      total: equity,
-      walletBalance: c.walletBalance ?? "0",
-      usdValue: c.usdValue ?? "0"
-    });
+const DECIMAL_PATTERN = /^\d+(\.\d+)?$/;
+function toBybitAccountMode(marginMode) {
+  switch (marginMode) {
+    case "ISOLATED_MARGIN":
+      return "bybit:isolatedMargin";
+    case "REGULAR_MARGIN":
+      return "bybit:regularMargin";
+    case "PORTFOLIO_MARGIN":
+      return "bybit:portfolioMargin";
   }
+  return null;
+}
+__name(toBybitAccountMode, "toBybitAccountMode");
+function toWithdrawable(raw, coins) {
+  const byCoin = new Map(Object.entries(raw?.availableWithdrawalMap ?? {}));
   return {
-    accountType,
-    free,
-    used,
-    total,
-    availableToTrade: raw.totalAvailableBalance ?? "0",
-    totalEquity: raw.totalEquity ?? "0",
-    walletBalance: raw.totalWalletBalance ?? "0",
-    unrealizedPnl: raw.totalPerpUPL ?? "0",
-    initialMarginUsed: raw.totalInitialMargin ?? "0",
-    maintenanceMargin: raw.totalMaintenanceMargin ?? "0",
-    marginRatio: raw.accountMMRate ?? "0.0000",
-    assets,
-    timestamp: Date.now()
+    total: withdrawableTotal(byCoin, coins),
+    byCoin
+  };
+}
+__name(toWithdrawable, "toWithdrawable");
+function buildBalance(raw, accountMode, withdrawable, timestamp) {
+  if (accountMode === null) {
+    return null;
+  }
+  const core = {
+    totalEquity: decimalOrNull(raw.totalEquity),
+    withdrawableBalance: withdrawable.total,
+    availableMargin: decimalOrNull(raw.totalAvailableBalance),
+    poolsShared: true,
+    perCollateral: toCollateralRows(raw.coin ?? [], withdrawable.byCoin),
+    timestamp
   };
+  switch (accountMode) {
+    case "bybit:isolatedMargin":
+      return {
+        accountMode,
+        ...core
+      };
+    case "bybit:regularMargin":
+      return {
+        accountMode,
+        ...core
+      };
+    case "bybit:portfolioMargin":
+      return {
+        accountMode,
+        ...core
+      };
+  }
 }
 __name(buildBalance, "buildBalance");
 function mergeRawCoins(existing, incoming) {
@@ -102,5 +98,66 @@ function mapPositionUpdates(raw) {
   return positions;
 }
 __name(mapPositionUpdates, "mapPositionUpdates");
+function toCollateralRows(coins, withdrawableByCoin) {
+  const rows = [];
+  for (const coin of coins) {
+    if (!isFunded(coin.equity)) {
+      continue;
+    }
+    rows.push({
+      asset: coin.coin,
+      equity: coin.equity,
+      availableMargin: null,
+      withdrawable: decimalOrNull(withdrawableByCoin.get(coin.coin))
+    });
+  }
+  return rows.sort(byCoinName);
+}
+__name(toCollateralRows, "toCollateralRows");
+function withdrawableTotal(byCoin, coins) {
+  if (byCoin.size === 0) {
+    return null;
+  }
+  const withdrawable = Array.from(byCoin).filter(([, amount]) => isFunded(amount));
+  if (withdrawable.length === 0) {
+    return "0";
+  }
+  const single = withdrawable.length === 1 ? withdrawable[0] : void 0;
+  if (single === void 0) {
+    return null;
+  }
+  return toUsd(single[1], coins.find((coin) => coin.coin === single[0]));
+}
+__name(withdrawableTotal, "withdrawableTotal");
+function toUsd(amount, coin) {
+  if (coin === void 0 || !isDecimal(coin.equity) || !isDecimal(coin.usdValue)) {
+    return null;
+  }
+  const equity = new BigNumber(coin.equity);
+  if (equity.isZero()) {
+    return null;
+  }
+  return new BigNumber(amount).times(coin.usdValue).div(equity).toFixed();
+}
+__name(toUsd, "toUsd");
+function isFunded(value) {
+  return isDecimal(value) && !new BigNumber(value).isZero();
+}
+__name(isFunded, "isFunded");
+function isDecimal(value) {
+  return value !== void 0 && DECIMAL_PATTERN.test(value);
+}
+__name(isDecimal, "isDecimal");
+function byCoinName(a, b) {
+  if (a.asset === b.asset) {
+    return 0;
+  }
+  return a.asset < b.asset ? -1 : 1;
+}
+__name(byCoinName, "byCoinName");
+function decimalOrNull(value) {
+  return isDecimal(value) ? value : null;
+}
+__name(decimalOrNull, "decimalOrNull");
 
-export { buildBalance, mapPositionUpdates, mapPositions, mapSinglePosition, mergeRawCoins };
+export { buildBalance, mapPositionUpdates, mapPositions, mapSinglePosition, mergeRawCoins, toBybitAccountMode, toWithdrawable };

package/dist/tracker/bybit/tracker.js

@@ -1,10 +1,11 @@
 import { createExchangeWs } from '../../client';
-import { fetchPositions, fetchPositionLeverage, fetchWalletBalance, fetchAccountInfo } from '../../client/bybit/rest';
+import { fetchPositions, fetchPositionLeverage, fetchWalletBalance, fetchAccountInfo, fetchTransferableAmount } from '../../client/bybit/rest';
 import { BaseAccountTracker } from '../base';
-import { mergeRawCoins, buildBalance, mapPositions, mapPositionUpdates } from './mapper';
+import { buildBalance, toBybitAccountMode, mapPositions, toWithdrawable, mergeRawCoins, mapPositionUpdates } from './mapper';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const MIN_WITHDRAWABLE_REFRESH_MS = 2e3;
 class BybitAccountTracker extends BaseAccountTracker {
   static {
     __name(this, "BybitAccountTracker");
@@ -15,26 +16,40 @@ class BybitAccountTracker extends BaseAccountTracker {
   openListenerId = null;
   rawCoins = /* @__PURE__ */ new Map();
   lastWallet = null;
-  accountType = null;
+  accountMode = null;
+  withdrawable = emptyWithdrawable();
+  lastWithdrawableReadAt = 0;
+  withdrawableRefreshTimer = null;
+  withdrawableReadInFlight = null;
+  withdrawableReadPending = false;
+  lifecycleVersion = 0;
   trackedAssetInfos = /* @__PURE__ */ new Map();
   constructor(config) {
     super(config);
     this.creds = config.credentials;
   }
   async snapshot() {
-    const { wallet, positions, accountInfo } = await this.fetchSnapshotData();
-    const accountType = accountInfo?.marginMode ?? null;
-    let balance = null;
-    if (wallet) {
-      const rawCoins = mergeRawCoins(/* @__PURE__ */ new Map(), wallet.coin ?? []);
-      balance = buildBalance(wallet, rawCoins, accountType);
-    }
+    const { wallet, positions, accountInfo, withdrawable } = await this.fetchSnapshotData();
+    const balance = wallet ? buildBalance(wallet, toBybitAccountMode(accountInfo.marginMode), withdrawable, Date.now()) : null;
     return {
       balance,
       positions: Array.from(mapPositions(positions).values())
     };
   }
   /**
+  * Bybit sizes no basket in v1: the SDK reads no per-asset max leverage from it, and sizing off
+  * `availableMargin` alone would ship a number no venue field backs. The missing input is
+  * `/v5/position/list` → `leverage` (the account's own per-symbol setting), with
+  * `/v5/market/risk-limit` → `maxLeverage` behind it for the tier a larger size would fall into.
+  */
+  async maxBasketSize(_input) {
+    return unsizedBasket();
+  }
+  /** The REST path answers the same way — there is no size either way, not a slower one. */
+  async snapshotMaxBasketSize(_input) {
+    return unsizedBasket();
+  }
+  /**
   * 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=`
@@ -74,8 +89,10 @@ class BybitAccountTracker extends BaseAccountTracker {
     return result;
   }
   async start() {
-    const { wallet, positions, accountInfo } = await this.fetchSnapshotData();
-    this.handleInitialData(wallet ?? null, positions, accountInfo?.marginMode ?? null);
+    const { wallet, positions, accountInfo, withdrawable } = await this.fetchSnapshotData();
+    this.withdrawable = withdrawable;
+    this.lastWithdrawableReadAt = Date.now();
+    this.handleInitialData(wallet ?? null, positions, toBybitAccountMode(accountInfo.marginMode));
     this.ws = await createExchangeWs("bybit", {
       demo: this.demo,
       credentials: this.credentials
@@ -87,6 +104,12 @@ class BybitAccountTracker extends BaseAccountTracker {
     this.subscribe();
   }
   async cleanupConnections() {
+    this.lifecycleVersion += 1;
+    this.withdrawableReadPending = false;
+    if (this.withdrawableRefreshTimer) {
+      clearTimeout(this.withdrawableRefreshTimer);
+      this.withdrawableRefreshTimer = null;
+    }
     if (this.messageListenerId) {
       this.ws?.main.removeMessageListener(this.messageListenerId);
       this.messageListenerId = null;
@@ -108,13 +131,47 @@ class BybitAccountTracker extends BaseAccountTracker {
       fetchPositions(this.creds, "USDC", this.demo),
       fetchAccountInfo(this.creds, this.demo)
     ]);
+    const withdrawable = toWithdrawableOrNothing(await this.readWithdrawable(wallet));
     return {
       wallet,
       positions: [
         positionsUsd,
         positionsUsdc
       ].flat(),
-      accountInfo
+      accountInfo,
+      withdrawable
+    };
+  }
+  /**
+  * Read how much can leave the trading account, for the coins the wallet payload lists.
+  *
+  * Best-effort on purpose: this is a second signed call that a read-only key may be refused, and
+  * a refusal must cost the caller a `null` field rather than the whole balance.
+  *
+  * A refusal is reported as `failed` rather than as an empty answer, because only the caller knows
+  * what to do with it: the snapshot path has no earlier figure and reports nothing known, while
+  * the live path keeps the figure its last successful read published.
+  */
+  async readWithdrawable(wallet) {
+    const coins = wallet?.coin ?? [];
+    if (coins.length === 0) {
+      return {
+        kind: "amounts",
+        withdrawable: emptyWithdrawable()
+      };
+    }
+    const withdrawal = await fetchTransferableAmount(this.creds, coins.map((entry) => entry.coin), this.demo).catch((err) => {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+      return void 0;
+    });
+    if (withdrawal === void 0) {
+      return {
+        kind: "failed"
+      };
+    }
+    return {
+      kind: "amounts",
+      withdrawable: toWithdrawable(withdrawal, coins)
     };
   }
   ensureAssetTracked(coin) {
@@ -146,15 +203,12 @@ class BybitAccountTracker extends BaseAccountTracker {
       ]
     });
   }
-  handleInitialData(wallet, positions, accountType) {
-    this.accountType = accountType;
+  handleInitialData(wallet, positions, accountMode) {
+    this.accountMode = accountMode;
     if (wallet) {
       this.lastWallet = wallet;
       this.rawCoins = mergeRawCoins(/* @__PURE__ */ new Map(), wallet.coin ?? []);
-      const balance = buildBalance(wallet, this.rawCoins, this.accountType);
-      if (balance) this.onStateUpdate({
-        balance
-      });
+      this.emitBalance(wallet);
     }
     this.onStateUpdate({
       positions: mapPositions(positions)
@@ -205,26 +259,181 @@ class BybitAccountTracker extends BaseAccountTracker {
       }
     }
   }
+  /**
+  * Fold one wallet push into the whole account, then publish what that whole account says.
+  *
+  * Bybit pushes only what moved: an update names the coins whose figures changed and leaves every
+  * other coin out. So the coin list is taken from the per-coin merge rather than from the push,
+  * and everything read off it sees every coin the account holds — the published rows, and the
+  * coin list the next transferable-amount read asks about. A push naming one of two funded coins
+  * would otherwise drop the other's row and let its per-coin maximum answer for the account.
+  *
+  * The account-level figures inherit on `??`, never on `||`, because ABSENT and BLANK say
+  * opposite things here. A field this push left out was not restated and its previous value still
+  * stands; a field present as `''` is Bybit withdrawing the figure, which it does for
+  * `totalAvailableBalance` among others. Inheriting a blank would republish a number the venue no
+  * longer states, and it would do it BEHIND `decimalOrNull`, whose whole job is to publish a blank
+  * as `null`: overwriting the blank here means that guard never sees it.
+  */
   handleWalletUpdate(raw) {
     this.rawCoins = mergeRawCoins(this.rawCoins, raw.coin ?? []);
-    const merged = this.lastWallet ? {
-      totalEquity: raw.totalEquity || this.lastWallet.totalEquity,
-      totalWalletBalance: raw.totalWalletBalance || this.lastWallet.totalWalletBalance,
-      totalMarginBalance: raw.totalMarginBalance || this.lastWallet.totalMarginBalance,
-      totalAvailableBalance: raw.totalAvailableBalance || this.lastWallet.totalAvailableBalance,
-      totalPerpUPL: raw.totalPerpUPL || this.lastWallet.totalPerpUPL,
-      totalInitialMargin: raw.totalInitialMargin || this.lastWallet.totalInitialMargin,
-      totalMaintenanceMargin: raw.totalMaintenanceMargin || this.lastWallet.totalMaintenanceMargin,
-      accountMMRate: raw.accountMMRate || this.lastWallet.accountMMRate,
-      coin: raw.coin ?? this.lastWallet.coin
-    } : raw;
+    const previous = this.lastWallet ?? nothingStated();
+    const merged = {
+      totalEquity: raw.totalEquity ?? previous.totalEquity,
+      totalWalletBalance: raw.totalWalletBalance ?? previous.totalWalletBalance,
+      totalMarginBalance: raw.totalMarginBalance ?? previous.totalMarginBalance,
+      totalAvailableBalance: raw.totalAvailableBalance ?? previous.totalAvailableBalance,
+      totalPerpUPL: raw.totalPerpUPL ?? previous.totalPerpUPL,
+      totalInitialMargin: raw.totalInitialMargin ?? previous.totalInitialMargin,
+      totalMaintenanceMargin: raw.totalMaintenanceMargin ?? previous.totalMaintenanceMargin,
+      accountMMRate: raw.accountMMRate ?? previous.accountMMRate,
+      // The account's whole coin list, which is what the rows and the next read both have to see.
+      coin: Array.from(this.rawCoins.values())
+    };
     this.lastWallet = merged;
-    const balance = buildBalance(merged, this.rawCoins, this.accountType);
-    if (balance) this.onStateUpdate({
-      balance
+    this.emitBalance(merged);
+    this.refreshWithdrawableSoon();
+  }
+  /** Publish the balance built from the newest wallet payload and the cached transferable amounts. */
+  emitBalance(wallet) {
+    const balance = buildBalance(wallet, this.accountMode, this.withdrawable, Date.now());
+    if (balance) {
+      this.onStateUpdate({
+        balance
+      });
+    }
+  }
+  /**
+  * Queue the next transferable-amount read, no sooner than the venue's own rate limit allows.
+  *
+  * Nothing waits on it: the wallet update is already published from the cached figure. One queued
+  * read covers every wallet tick that lands before it runs, which is what stops a burst of ticks
+  * becoming a burst of signed calls — and because a tick always leaves a read queued or marked
+  * pending, a moved figure is still picked up within one interval rather than dropped.
+  */
+  refreshWithdrawableSoon() {
+    if (this.withdrawableReadInFlight !== null) {
+      this.withdrawableReadPending = true;
+      return;
+    }
+    if (this.withdrawableRefreshTimer !== null) {
+      return;
+    }
+    const waitMs = Math.max(0, MIN_WITHDRAWABLE_REFRESH_MS - (Date.now() - this.lastWithdrawableReadAt));
+    this.withdrawableRefreshTimer = setTimeout(() => {
+      this.withdrawableRefreshTimer = null;
+      this.lastWithdrawableReadAt = Date.now();
+      void this.refreshWithdrawableBalance();
+    }, waitMs);
+  }
+  /**
+  * Hold one transferable-amount read open at a time, and queue the ticks that arrive during it.
+  *
+  * Serialising the reads is what keeps the published figure the newest one: two overlapping reads
+  * can come back in either order, and the older answer landing last would publish an amount the
+  * venue has already moved past.
+  */
+  refreshWithdrawableBalance() {
+    const lifecycleVersion = this.lifecycleVersion;
+    const read = this.performWithdrawableRefresh(lifecycleVersion).finally(() => {
+      if (this.withdrawableReadInFlight === read) {
+        this.withdrawableReadInFlight = null;
+      }
+      if (this.withdrawableReadPending && lifecycleVersion === this.lifecycleVersion) {
+        this.withdrawableReadPending = false;
+        this.refreshWithdrawableSoon();
+      }
     });
+    this.withdrawableReadInFlight = read;
+    return read;
+  }
+  /**
+  * Re-read the transferable amount behind the live path, then re-publish only if it moved.
+  *
+  * Fire-and-forget: the wallet update is already published with the previous figure, so a slow
+  * read delays the correction instead of blocking the balance. A read that FAILS changes nothing
+  * at all — the last good figure stays published, because a refusal says Bybit did not answer,
+  * not that the account has nothing to transfer. Both the read and the re-publish take the NEWEST
+  * wallet rather than the one that queued them, so a wallet update that landed meanwhile is
+  * neither missed nor rolled back.
+  */
+  async performWithdrawableRefresh(lifecycleVersion) {
+    try {
+      const wallet = this.lastWallet;
+      if (wallet === null) {
+        return;
+      }
+      const read = await this.readWithdrawable(wallet);
+      if (lifecycleVersion !== this.lifecycleVersion) {
+        return;
+      }
+      if (read.kind === "failed") {
+        return;
+      }
+      if (sameWithdrawable(read.withdrawable, this.withdrawable)) {
+        return;
+      }
+      this.withdrawable = read.withdrawable;
+      if (this.lastWallet) {
+        this.emitBalance(this.lastWallet);
+      }
+    } catch (err) {
+      if (lifecycleVersion === this.lifecycleVersion) {
+        this.onError(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
   }
 }
+function toWithdrawableOrNothing(read) {
+  switch (read.kind) {
+    case "amounts":
+      return read.withdrawable;
+    case "failed":
+      return emptyWithdrawable();
+  }
+}
+__name(toWithdrawableOrNothing, "toWithdrawableOrNothing");
+function nothingStated() {
+  return {
+    totalEquity: "",
+    totalWalletBalance: "",
+    totalMarginBalance: "",
+    totalAvailableBalance: "",
+    totalPerpUPL: "",
+    totalInitialMargin: "",
+    totalMaintenanceMargin: "",
+    accountMMRate: "",
+    coin: []
+  };
+}
+__name(nothingStated, "nothingStated");
+function emptyWithdrawable() {
+  return {
+    total: null,
+    byCoin: /* @__PURE__ */ new Map()
+  };
+}
+__name(emptyWithdrawable, "emptyWithdrawable");
+function sameWithdrawable(left, right) {
+  if (left.total !== right.total || left.byCoin.size !== right.byCoin.size) {
+    return false;
+  }
+  for (const [coin, amount] of left.byCoin) {
+    if (right.byCoin.get(coin) !== amount) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(sameWithdrawable, "sameWithdrawable");
+function unsizedBasket() {
+  return {
+    maxNotional: null,
+    legs: [],
+    bindingConstraint: null
+  };
+}
+__name(unsizedBasket, "unsizedBasket");
 function toTrackedAssetInfo(coin, pos) {
   return {
     coin,

package/dist/tracker/bybit/types.js

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

package/dist/tracker/hyperliquid/account-mode.js

@@ -0,0 +1,14 @@
+import { HyperliquidAccountType } from './types';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const HYPERLIQUID_ACCOUNT_TYPES = Object.values(HyperliquidAccountType);
+function resolveHyperliquidAccountType(abstraction) {
+  if (!abstraction) {
+    return null;
+  }
+  return HYPERLIQUID_ACCOUNT_TYPES.includes(abstraction) ? abstraction : null;
+}
+__name(resolveHyperliquidAccountType, "resolveHyperliquidAccountType");
+
+export { resolveHyperliquidAccountType };