@pear-protocol/exchanges-sdk 0.6.6 → 0.7.0

package/dist/tracker/okx/mapper.js

@@ -1,9 +1,34 @@
 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 });
+const DECIMAL_PATTERN = /^\d+(\.\d+)?$/;
+const SIGNED_DECIMAL_PATTERN = /^-?\d+(\.\d+)?$/;
+function acctLvToAccountMode(acctLv) {
+  switch (acctLv) {
+    case "1":
+      return "okx:spot";
+    case "2":
+      return "okx:futures";
+    case "3":
+      return "okx:multiCurrencyMargin";
+    case "4":
+      return "okx:portfolioMargin";
+  }
+  return null;
+}
+__name(acctLvToAccountMode, "acctLvToAccountMode");
+function toWithdrawable(rows, details) {
+  return {
+    total: withdrawableFromMaxWithdrawals(rows, details),
+    byCurrency: new Map(rows.map((row) => [
+      row.ccy,
+      row.maxWd
+    ]))
+  };
+}
+__name(toWithdrawable, "toWithdrawable");
 function mergeRawCoins(existing, incoming) {
   const merged = new Map(existing);
   for (const d of incoming) {
@@ -12,50 +37,33 @@ function mergeRawCoins(existing, incoming) {
   return merged;
 }
 __name(mergeRawCoins, "mergeRawCoins");
-function buildBalance(raw, coins, accountType) {
-  if (!accountType) return null;
-  const isSpot = accountType === OkxAccountType.SPOT;
-  const free = {};
-  const used = {};
-  const total = {};
-  const assets = [];
-  let walletBalanceSum = new BigNumber(0);
-  for (const [, d] of coins) {
-    const eq = d.eq ?? "0";
-    const eqBN = new BigNumber(eq);
-    const cashBN = new BigNumber(d.cashBal ?? "0");
-    if (eqBN.isZero() && cashBN.isZero()) continue;
-    const coinFree = isSpot ? d.availBal ?? "0" : d.availEq || d.availBal || "0";
-    const coinUsed = eqBN.minus(coinFree).toString();
-    free[d.ccy] = coinFree;
-    used[d.ccy] = coinUsed;
-    total[d.ccy] = eq;
-    walletBalanceSum = walletBalanceSum.plus(cashBN);
-    assets.push({
-      asset: d.ccy,
-      free: coinFree,
-      used: coinUsed,
-      total: eq,
-      walletBalance: d.cashBal ?? "0",
-      usdValue: d.eqUsd ?? "0"
-    });
+function buildBalance(raw, accountMode, withdrawable, timestamp) {
+  if (accountMode === null) {
+    return null;
+  }
+  const perCollateral = toCollateralRows(raw.details ?? [], withdrawable.byCurrency);
+  switch (accountMode) {
+    case "okx:spot":
+      return {
+        accountMode,
+        ...splitPoolCore(raw, withdrawable, perCollateral, timestamp)
+      };
+    case "okx:futures":
+      return {
+        accountMode,
+        ...splitPoolCore(raw, withdrawable, perCollateral, timestamp)
+      };
+    case "okx:multiCurrencyMargin":
+      return {
+        accountMode,
+        ...sharedPoolCore(raw, withdrawable, perCollateral, timestamp)
+      };
+    case "okx:portfolioMargin":
+      return {
+        accountMode,
+        ...sharedPoolCore(raw, withdrawable, perCollateral, timestamp)
+      };
   }
-  const availableToTrade = raw.availEq || raw.adjEq || "0";
-  return {
-    accountType,
-    free,
-    used,
-    total,
-    availableToTrade,
-    totalEquity: raw.totalEq ?? "0",
-    walletBalance: walletBalanceSum.toFixed(),
-    unrealizedPnl: raw.upl || "0",
-    initialMarginUsed: raw.imr || "0",
-    maintenanceMargin: raw.mmr || "0",
-    marginRatio: raw.mgnRatio || "0.0000",
-    assets,
-    timestamp: Date.now()
-  };
 }
 __name(buildBalance, "buildBalance");
 function mapSinglePosition(p) {
@@ -106,20 +114,110 @@ function mapPositionUpdates(raw) {
   return positions;
 }
 __name(mapPositionUpdates, "mapPositionUpdates");
-function acctLvToAccountType(acctLv) {
-  switch (acctLv) {
-    case "1":
-      return OkxAccountType.SPOT;
-    case "2":
-      return OkxAccountType.SINGLE_CURRENCY_MARGIN;
-    case "3":
-      return OkxAccountType.MULTI_CURRENCY_MARGIN;
-    case "4":
-      return OkxAccountType.PORTFOLIO_MARGIN;
-    default:
-      return null;
+function sharedPoolCore(raw, withdrawable, perCollateral, timestamp) {
+  return {
+    totalEquity: decimalOrNull(raw.totalEq),
+    withdrawableBalance: withdrawable.total,
+    availableMargin: availableMarginOf(raw),
+    poolsShared: true,
+    perCollateral,
+    timestamp
+  };
+}
+__name(sharedPoolCore, "sharedPoolCore");
+function splitPoolCore(raw, withdrawable, perCollateral, timestamp) {
+  const scalarsDescribeTheAccount = atMostOneFundedPool(raw.details ?? []);
+  return {
+    totalEquity: scalarsDescribeTheAccount ? decimalOrNull(raw.totalEq) : null,
+    withdrawableBalance: scalarsDescribeTheAccount ? withdrawable.total : null,
+    availableMargin: scalarsDescribeTheAccount ? availableMarginOf(raw) : null,
+    poolsShared: false,
+    perCollateral,
+    timestamp
+  };
+}
+__name(splitPoolCore, "splitPoolCore");
+function toCollateralRows(details, withdrawableByCurrency) {
+  const rows = [];
+  for (const detail of details) {
+    if (!isFunded(detail.eq)) {
+      continue;
+    }
+    rows.push({
+      asset: detail.ccy,
+      equity: detail.eq,
+      availableMargin: decimalOrNull(detail.availEq),
+      withdrawable: decimalOrNull(withdrawableByCurrency.get(detail.ccy))
+    });
+  }
+  return rows.sort(byCurrencyName);
+}
+__name(toCollateralRows, "toCollateralRows");
+function atMostOneFundedPool(details) {
+  let fundedPools = 0;
+  for (const detail of details) {
+    if (holdsAnyBalance(detail.eq)) {
+      fundedPools += 1;
+    }
+  }
+  return fundedPools <= 1;
+}
+__name(atMostOneFundedPool, "atMostOneFundedPool");
+function holdsAnyBalance(value) {
+  if (value === void 0 || !SIGNED_DECIMAL_PATTERN.test(value)) {
+    return false;
+  }
+  return !new BigNumber(value).isZero();
+}
+__name(holdsAnyBalance, "holdsAnyBalance");
+function isFunded(value) {
+  return isDecimal(value) && !new BigNumber(value).isZero();
+}
+__name(isFunded, "isFunded");
+function byCurrencyName(a, b) {
+  if (a.asset === b.asset) {
+    return 0;
   }
+  return a.asset < b.asset ? -1 : 1;
+}
+__name(byCurrencyName, "byCurrencyName");
+function decimalOrNull(value) {
+  return isDecimal(value) ? value : null;
+}
+__name(decimalOrNull, "decimalOrNull");
+function withdrawableFromMaxWithdrawals(rows, details) {
+  if (rows.length === 0) {
+    return null;
+  }
+  const withdrawable = rows.filter((row) => isFunded(row.maxWd));
+  if (withdrawable.length === 0) {
+    return "0";
+  }
+  const single = withdrawable.length === 1 ? withdrawable[0] : void 0;
+  if (single === void 0) {
+    return null;
+  }
+  return toUsd(single.maxWd, details.get(single.ccy));
+}
+__name(withdrawableFromMaxWithdrawals, "withdrawableFromMaxWithdrawals");
+function availableMarginOf(raw) {
+  return decimalOrNull(raw.availEq);
+}
+__name(availableMarginOf, "availableMarginOf");
+function toUsd(amount, detail) {
+  if (detail === void 0 || !isDecimal(detail.eq) || !isDecimal(detail.eqUsd)) {
+    return null;
+  }
+  const equity = new BigNumber(detail.eq);
+  if (equity.isZero()) {
+    return null;
+  }
+  return new BigNumber(amount).times(detail.eqUsd).div(equity).toFixed();
+}
+__name(toUsd, "toUsd");
+function isDecimal(value) {
+  return value !== void 0 && DECIMAL_PATTERN.test(value);
 }
-__name(acctLvToAccountType, "acctLvToAccountType");
+__name(isDecimal, "isDecimal");
 
-export { acctLvToAccountType, buildBalance, mapPositionUpdates, mapPositions, mapSinglePosition, mergeRawCoins };
+export { acctLvToAccountMode, buildBalance, mapPositionUpdates, mapPositions, mapSinglePosition, mergeRawCoins, toWithdrawable };

package/dist/tracker/okx/tracker.js

@@ -1,10 +1,11 @@
 import { createExchangeWs } from '../../client';
-import { fetchLeverageInfos, fetchAccountConfig, fetchBalance, fetchPositions } from '../../client/okx/rest';
+import { fetchLeverageInfos, fetchAccountConfig, fetchBalance, fetchPositions, fetchMaxWithdrawals } from '../../client/okx/rest';
 import { BaseAccountTracker } from '../base';
-import { acctLvToAccountType, mergeRawCoins, mapPositions, buildBalance, mapPositionUpdates } from './mapper';
+import { mapPositions, buildBalance, acctLvToAccountMode, mergeRawCoins, mapPositionUpdates, toWithdrawable } from './mapper';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const MIN_WITHDRAWABLE_REFRESH_MS = 2e3;
 class OkxAccountTracker extends BaseAccountTracker {
   static {
     __name(this, "OkxAccountTracker");
@@ -15,22 +16,40 @@ class OkxAccountTracker extends BaseAccountTracker {
   openListenerId = null;
   rawCoins = /* @__PURE__ */ new Map();
   lastBalance = 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 { config, balance, positions } = await this.fetchSnapshotData();
-    const accountType = acctLvToAccountType(config.acctLv);
-    const rawCoins = mergeRawCoins(/* @__PURE__ */ new Map(), balance.details ?? []);
+    const { config, balance, positions, withdrawable } = await this.fetchSnapshotData();
     return {
-      balance: buildBalance(balance, rawCoins, accountType),
+      balance: buildBalance(balance, acctLvToAccountMode(config.acctLv), withdrawable, Date.now()),
       positions: Array.from(mapPositions(positions).values())
     };
   }
   /**
+  * OKX 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
+  * `GET /api/v5/public/position-tiers` → `maxLever`/`imr` per tier, which the client does not
+  * call — and it is NOT `GET /api/v5/account/position-tiers`, a different endpoint carrying no
+  * margin or leverage data at all.
+  */
+  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 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.
@@ -53,8 +72,10 @@ class OkxAccountTracker extends BaseAccountTracker {
     return result;
   }
   async start() {
-    const { config, balance, positions } = await this.fetchSnapshotData();
-    this.accountType = acctLvToAccountType(config.acctLv);
+    const { config, balance, positions, withdrawable } = await this.fetchSnapshotData();
+    this.accountMode = acctLvToAccountMode(config.acctLv);
+    this.withdrawable = withdrawable;
+    this.lastWithdrawableReadAt = Date.now();
     this.handleInitialData(balance, positions);
     this.ws = await createExchangeWs("okx", {
       demo: this.demo,
@@ -67,6 +88,12 @@ class OkxAccountTracker 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;
@@ -82,17 +109,41 @@ class OkxAccountTracker extends BaseAccountTracker {
     return this.ws?.isConnected ?? false;
   }
   async fetchSnapshotData() {
-    const [config, balance, positions] = await Promise.all([
+    const [config, balance, positions, read] = await Promise.all([
       fetchAccountConfig(this.creds, this.demo),
       fetchBalance(this.creds, this.demo),
-      fetchPositions(this.creds, this.demo)
+      fetchPositions(this.creds, this.demo),
+      this.readMaxWithdrawals()
     ]);
+    const withdrawable = toWithdrawableOrNothing(read, mergeRawCoins(/* @__PURE__ */ new Map(), balance.details ?? []));
     return {
       config,
       balance,
-      positions
+      positions,
+      withdrawable
     };
   }
+  /**
+  * Read how much can leave the trading account, per currency, across everything it owns.
+  *
+  * Best-effort on purpose: this is a fourth 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 row set, 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 readMaxWithdrawals() {
+    return fetchMaxWithdrawals(this.creds, this.demo).then((rows) => ({
+      kind: "rows",
+      rows
+    })).catch((err) => {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+      return {
+        kind: "failed"
+      };
+    });
+  }
   ensureAssetTracked(instId) {
     if (this.trackedAssetInfos.has(instId)) return;
     fetchLeverageInfos(this.creds, [
@@ -141,10 +192,7 @@ class OkxAccountTracker extends BaseAccountTracker {
   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.emitBalance(balance);
     this.onStateUpdate({
       positions: mapPositions(positions)
     });
@@ -196,24 +244,175 @@ class OkxAccountTracker extends BaseAccountTracker {
       });
     }
   }
+  /**
+  * Fold one account push into the whole account, then publish what that whole account says.
+  *
+  * OKX pushes only what moved: an update names the currencies whose figures changed and leaves
+  * every other currency out. So the rows are taken from the per-currency merge rather than from
+  * the push, and everything read off them — the pool count above all — sees every currency the
+  * account holds. A push naming one of two funded currencies would otherwise read as a
+  * single-pool account and publish scalars that describe neither pool.
+  *
+  * 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 OKX withdrawing the figure, which it does per account mode —
+  * `availableMarginOf` records the mode that blanks `availEq`. 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.
+  */
   handleBalanceUpdate(raw) {
     this.rawCoins = mergeRawCoins(this.rawCoins, raw.details ?? []);
-    const merged = this.lastBalance ? {
-      totalEq: raw.totalEq || this.lastBalance.totalEq,
-      adjEq: raw.adjEq || this.lastBalance.adjEq,
-      availEq: raw.availEq || this.lastBalance.availEq,
-      mmr: raw.mmr || this.lastBalance.mmr,
-      imr: raw.imr || this.lastBalance.imr,
-      upl: raw.upl || this.lastBalance.upl,
-      mgnRatio: raw.mgnRatio || this.lastBalance.mgnRatio,
-      details: raw.details ?? this.lastBalance.details
-    } : raw;
+    const previous = this.lastBalance ?? nothingStated();
+    const merged = {
+      totalEq: raw.totalEq ?? previous.totalEq,
+      adjEq: raw.adjEq ?? previous.adjEq,
+      availEq: raw.availEq ?? previous.availEq,
+      mmr: raw.mmr ?? previous.mmr,
+      imr: raw.imr ?? previous.imr,
+      upl: raw.upl ?? previous.upl,
+      mgnRatio: raw.mgnRatio ?? previous.mgnRatio,
+      // The account's whole row set, which is what the pool count has to be counted over.
+      details: Array.from(this.rawCoins.values())
+    };
     this.lastBalance = merged;
-    const built = buildBalance(merged, this.rawCoins, this.accountType);
-    if (built) this.onStateUpdate({
-      balance: built
+    this.emitBalance(merged);
+    this.refreshWithdrawableSoon();
+  }
+  /** Publish the balance built from the newest account payload and the cached transferable amounts. */
+  emitBalance(balance) {
+    const built = buildBalance(balance, this.accountMode, this.withdrawable, Date.now());
+    if (built) {
+      this.onStateUpdate({
+        balance: built
+      });
+    }
+  }
+  /**
+  * Queue the next transferable-amount read, no sooner than the venue's own rate limit allows.
+  *
+  * Nothing waits on it: the account update is already published from the cached figure. One
+  * queued read covers every account 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 account 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 OKX did not answer, not
+  * that the account has nothing to transfer. The re-publish reads the newest account payload
+  * rather than the one this read started from, so an account update that landed meanwhile is not
+  * rolled back.
+  */
+  async performWithdrawableRefresh(lifecycleVersion) {
+    try {
+      const read = await this.readMaxWithdrawals();
+      if (lifecycleVersion !== this.lifecycleVersion) {
+        return;
+      }
+      if (read.kind === "failed") {
+        return;
+      }
+      const withdrawable = toWithdrawable(read.rows, this.rawCoins);
+      if (sameWithdrawable(withdrawable, this.withdrawable)) {
+        return;
+      }
+      this.withdrawable = withdrawable;
+      if (this.lastBalance) {
+        this.emitBalance(this.lastBalance);
+      }
+    } catch (err) {
+      if (lifecycleVersion === this.lifecycleVersion) {
+        this.onError(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+  }
+}
+function toWithdrawableOrNothing(read, details) {
+  switch (read.kind) {
+    case "rows":
+      return toWithdrawable(read.rows, details);
+    case "failed":
+      return emptyWithdrawable();
+  }
+}
+__name(toWithdrawableOrNothing, "toWithdrawableOrNothing");
+function nothingStated() {
+  return {
+    totalEq: "",
+    adjEq: "",
+    availEq: "",
+    mmr: "",
+    imr: "",
+    upl: "",
+    mgnRatio: "",
+    details: []
+  };
+}
+__name(nothingStated, "nothingStated");
+function emptyWithdrawable() {
+  return {
+    total: null,
+    byCurrency: /* @__PURE__ */ new Map()
+  };
+}
+__name(emptyWithdrawable, "emptyWithdrawable");
+function sameWithdrawable(left, right) {
+  if (left.total !== right.total || left.byCurrency.size !== right.byCurrency.size) {
+    return false;
+  }
+  for (const [currency, amount] of left.byCurrency) {
+    if (right.byCurrency.get(currency) !== amount) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(sameWithdrawable, "sameWithdrawable");
+function unsizedBasket() {
+  return {
+    maxNotional: null,
+    legs: [],
+    bindingConstraint: null
+  };
 }
+__name(unsizedBasket, "unsizedBasket");
 
 export { OkxAccountTracker };

package/dist/tracker/okx/types.js

@@ -1,9 +1 @@
-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;
-})({});
 
-export { OkxAccountType };

package/dist/tracker/types.js

@@ -1,25 +1 @@
-import { BinanceAccountType } from './binance/types';
-import { BybitAccountType } from './bybit/types';
-import { HyperliquidAccountType } from './hyperliquid/types';
-import { LighterAccountType } from './lighter/types';
-import { OkxAccountType } from './okx/types';
 
-const ACCOUNT_TYPE_LABELS = {
-  [BinanceAccountType.SINGLE_ASSET]: "Single-Asset Mode",
-  [BinanceAccountType.MULTI_ASSET]: "Multi-Asset Mode",
-  [BybitAccountType.ISOLATED_MARGIN]: "Isolated Margin",
-  [BybitAccountType.REGULAR_MARGIN]: "Cross Margin",
-  [BybitAccountType.PORTFOLIO_MARGIN]: "Portfolio Margin",
-  [HyperliquidAccountType.DEFAULT]: "Standard",
-  [HyperliquidAccountType.DISABLED]: "Standard",
-  [HyperliquidAccountType.PORTFOLIO_MARGIN]: "Portfolio Margin",
-  [HyperliquidAccountType.UNIFIED_ACCOUNT]: "Unified Account",
-  [LighterAccountType.CLASSIC]: "Classic",
-  [LighterAccountType.UNIFIED]: "Unified",
-  [OkxAccountType.SPOT]: "Spot Mode",
-  [OkxAccountType.SINGLE_CURRENCY_MARGIN]: "Single-Currency Margin",
-  [OkxAccountType.MULTI_CURRENCY_MARGIN]: "Multi-Currency Margin",
-  [OkxAccountType.PORTFOLIO_MARGIN]: "Portfolio Margin"
-};
-
-export { ACCOUNT_TYPE_LABELS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/exchanges-sdk",
-  "version": "0.6.6",
+  "version": "0.7.0",
   "description": "Pear Protocol Exchanges SDK",
   "private": false,
   "type": "module",
@@ -22,22 +22,20 @@
   "scripts": {
     "build": "tsup",
     "clean": "rm -rf dist .turbo",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest"
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@pear-protocol/core-sdk": "^1.17.3",
-    "@pear-protocol/types": "^1.26.0",
+    "@pear-protocol/core-sdk": "^1.17.4",
+    "@pear-protocol/types": "^1.26.1",
     "@pear-protocol/utils": "^0.5.1",
     "bignumber.js": "^11.1.1",
     "partysocket": "^1.0.3",
-    "viem": "^2.48.8"
+    "viem": "^2.48.8",
+    "zod": "4.1.12"
   },
   "devDependencies": {
     "@backend/typescript-config": "workspace:*",
     "tsup": "8.5.1",
-    "typescript": "5.9.3",
-    "vitest": "4.1.2"
+    "typescript": "5.9.3"
   }
 }