@pear-protocol/exchanges-sdk 0.0.6 → 0.0.7

package/README.md

@@ -8,6 +8,7 @@ Unified SDK for connecting to cryptocurrency derivative exchanges. Provides real
 |----------|---------------|-------------|
 | Binance | `binanceusdm` | USDM Futures |
 | Bybit | `bybit` | Linear Perpetuals |
+| Hyperliquid | `hyperliquid` | Perpetuals |
 
 ## Installation
 
@@ -67,6 +68,7 @@ Credentials are fetched automatically from the backend when you call `connect`.
 ```typescript
 await exchanges.account.connect(tradeAccountId, 'binanceusdm');
 await exchanges.account.connect(tradeAccountId, 'bybit');
+await exchanges.account.connect(tradeAccountId, 'hyperliquid');
 ```
 
 Check connection status:
@@ -91,8 +93,11 @@ const tracker = exchanges.account.trackBalance((balance) => {
   // Per-asset breakdown
   for (const asset of balance.assets) {
     asset.asset;          // "USDT", "BTC", etc.
+    asset.free;           // available amount
+    asset.used;           // amount in use
+    asset.total;          // total amount
+    asset.walletBalance;  // wallet balance
     asset.usdValue;       // USD equivalent
-    asset.isCollateral;   // whether the asset is used as collateral
   }
 });
 
@@ -134,9 +139,6 @@ const tracker = exchanges.account.trackAsset('ETH', (info) => {
   info.coin;             // "ETH"
   info.leverage;         // "20"
   info.marginType;       // "cross" | "isolated"
-  info.availableToTrade; // [min, max] or null
-  info.maxTradeSzs;      // [min, max] or null
-  info.collateralToken;  // "USDT" or null
 });
 
 const current = tracker.get();

package/dist/account/account-manager.d.ts

@@ -1,10 +1,11 @@
+import PearSDK from '@pear-protocol/core-sdk';
 import { Connector } from '@pear-protocol/types';
 import { Credentials } from '../credentials.js';
 import { BalanceCallback, Tracker, AccountBalance, PositionsCallback, AccountPosition, TrackedAssetCallback, TrackedAssetInfo, ExchangeState } from './types.js';
-import '@pear-protocol/core-sdk';
 
 declare class AccountManager {
     private credentials;
+    private sdk;
     private demo;
     private activeAccount;
     private pendingExchange;
@@ -12,7 +13,7 @@ declare class AccountManager {
     private balanceListeners;
     private positionListeners;
     private assetListeners;
-    constructor(credentials: Credentials, demo?: boolean);
+    constructor(credentials: Credentials, sdk: PearSDK, demo?: boolean);
     connect(tradeAccountId: string, exchange: Connector): Promise<void>;
     trackBalance(cb: BalanceCallback): Tracker<AccountBalance | null>;
     trackPositions(cb: PositionsCallback): Tracker<AccountPosition[]>;
@@ -28,6 +29,7 @@ declare class AccountManager {
     private disconnectWs;
     private maybeDisconnectWs;
     private ensureWsStarted;
+    private resolveCredentials;
     private startWs;
 }
 

package/dist/account/account-manager.js

@@ -2,6 +2,7 @@ import { ExchangeAccount } from './exchange-account';
 
 class AccountManager {
   credentials;
+  sdk;
   demo;
   activeAccount = null;
   pendingExchange = null;
@@ -9,12 +10,13 @@ class AccountManager {
   balanceListeners = /* @__PURE__ */ new Map();
   positionListeners = /* @__PURE__ */ new Map();
   assetListeners = /* @__PURE__ */ new Map();
-  constructor(credentials, demo = false) {
+  constructor(credentials, sdk, demo = false) {
     this.credentials = credentials;
+    this.sdk = sdk;
     this.demo = demo;
   }
   async connect(tradeAccountId, exchange) {
-    const creds = await this.credentials.getOrFetch(tradeAccountId);
+    const creds = await this.resolveCredentials(tradeAccountId, exchange);
     this.disconnectWs();
     this.pendingTradeAccountId = tradeAccountId;
     this.pendingExchange = exchange;
@@ -119,7 +121,22 @@ class AccountManager {
     if (this.activeAccount || !this.pendingExchange || !this.pendingTradeAccountId) return;
     const exchange = this.pendingExchange;
     const tradeAccountId = this.pendingTradeAccountId;
-    this.credentials.getOrFetch(tradeAccountId).then((creds) => this.startWs(exchange, creds)).catch((err) => console.warn("[AccountManager] Failed to start WS:", err));
+    this.resolveCredentials(tradeAccountId, exchange).then((creds) => this.startWs(exchange, creds)).catch((err) => console.warn("[AccountManager] Failed to start WS:", err));
+  }
+  async resolveCredentials(tradeAccountId, exchange) {
+    const creds = await this.credentials.getOrFetch(tradeAccountId);
+    if (exchange === "hyperliquid") {
+      const { accounts } = await this.sdk.info.accounts.list();
+      const account = accounts.find((a) => a.id === tradeAccountId);
+      if (!account) {
+        throw new Error(`Trade account ${tradeAccountId} not found`);
+      }
+      if (!account.exchangeIdentifier) {
+        throw new Error(`Trade account ${tradeAccountId} has no Hyperliquid address`);
+      }
+      return { ...creds, address: account.exchangeIdentifier };
+    }
+    return creds;
   }
   async startWs(exchange, creds) {
     const account = new ExchangeAccount({ exchange, demo: this.demo });

package/dist/account/exchanges/binance/mapper.d.ts

@@ -2,7 +2,7 @@ import { AccountBalance, AccountPosition } from '../../types.js';
 import { BinanceRawAccountStatus, BinanceRawPositionRisk } from './types.js';
 import '@pear-protocol/types';
 
-declare function mapBalance(raw: BinanceRawAccountStatus, collateralRatios: Map<string, string>): AccountBalance;
+declare function mapBalance(raw: BinanceRawAccountStatus): AccountBalance;
 declare function mapPositions(raw: BinanceRawPositionRisk[]): Map<string, AccountPosition>;
 declare function mergePositions(incoming: Map<string, AccountPosition>, existing: Map<string, AccountPosition>): Map<string, AccountPosition>;
 

package/dist/account/exchanges/binance/mapper.js

@@ -1,7 +1,7 @@
 import '../../types';
 import { positionKey } from '../../utils';
 
-function mapBalance(raw, collateralRatios) {
+function mapBalance(raw) {
   const free = {};
   const used = {};
   const total = {};
@@ -11,8 +11,6 @@ function mapBalance(raw, collateralRatios) {
     const ab = a.availableBalance ?? "0";
     const mb = a.marginBalance ?? "0";
     const im = a.initialMargin ?? "0";
-    const mm = a.maintMargin ?? "0";
-    const up = a.unrealizedProfit ?? "0";
     if (parseFloat(wb) === 0 && parseFloat(ab) === 0 && parseFloat(mb) === 0) continue;
     free[a.asset] = ab;
     used[a.asset] = im;
@@ -23,13 +21,7 @@ function mapBalance(raw, collateralRatios) {
       used: im,
       total: mb,
       walletBalance: wb,
-      unrealizedPnl: up,
-      usdValue: mb,
-      initialMargin: im,
-      maintenanceMargin: mm,
-      isCollateral: a.marginAvailable ?? false,
-      collateralRatio: collateralRatios.get(a.asset) ?? "1.0000",
-      borrowedAmount: "0"
+      usdValue: mb
     });
   }
   const totalMarginBalance = raw.totalMarginBalance ?? "0";
@@ -38,9 +30,7 @@ function mapBalance(raw, collateralRatios) {
   const maintMargin = parseFloat(totalMaintMargin);
   const marginRatio = marginBalance > 0 ? (maintMargin / marginBalance).toFixed(4) : "0.0000";
   return {
-    exchange: "binance",
     accountType: raw.multiAssetsMargin ? "multi-asset" : "single-asset",
-    marginMode: "cross",
     free,
     used,
     total,

package/dist/account/exchanges/binance/orchestrator.d.ts

@@ -13,8 +13,6 @@ declare class BinanceOrchestrator extends BaseOrchestrator {
     private creds;
     private trackedAssetInfos;
     private currentPositions;
-    private collateralRatios;
-    private multiAssetsMargin;
     private readonly listenKeyRefreshMs;
     private readonly accountPollMs;
     constructor(config: BinanceOrchestratorConfig);

package/dist/account/exchanges/binance/orchestrator.js

@@ -2,7 +2,7 @@ import { positionKey } from '../../utils';
 import { BaseOrchestrator } from '../base';
 import { DEFAULT_LISTEN_KEY_REFRESH_MS, DEFAULT_ACCOUNT_POLL_MS } from './const';
 import { mapBalance, mapPositions, mergePositions } from './mapper';
-import { fetchAccountStatus, fetchAllPositionRisk, fetchAssetIndex, createListenKey, keepAliveListenKey, fetchPositionRisk, setLeverage } from './rest';
+import { fetchAccountStatus, fetchAllPositionRisk, createListenKey, keepAliveListenKey, fetchPositionRisk, setLeverage } from './rest';
 import { BinanceWs } from './ws';
 
 class BinanceOrchestrator extends BaseOrchestrator {
@@ -12,8 +12,6 @@ class BinanceOrchestrator extends BaseOrchestrator {
   creds = null;
   trackedAssetInfos = /* @__PURE__ */ new Map();
   currentPositions = /* @__PURE__ */ new Map();
-  collateralRatios = /* @__PURE__ */ new Map();
-  multiAssetsMargin = false;
   listenKeyRefreshMs;
   accountPollMs;
   constructor(config) {
@@ -33,18 +31,6 @@ class BinanceOrchestrator extends BaseOrchestrator {
         fetchAllPositionRisk(this.creds, this.demo)
       ]);
       if (gen !== this.startGeneration) return;
-      this.multiAssetsMargin = snapshot.multiAssetsMargin ?? false;
-      if (this.multiAssetsMargin) {
-        const indexData = await fetchAssetIndex(this.demo);
-        if (gen !== this.startGeneration) return;
-        this.collateralRatios.clear();
-        for (const item of indexData) {
-          const asset = item.symbol.replace(/USD$/, "");
-          if (item.bidRate && parseFloat(item.bidRate) > 0) {
-            this.collateralRatios.set(asset, item.bidRate);
-          }
-        }
-      }
       this.handleAccountStatus(snapshot);
       this.handlePositionRisk(positionRisk, false);
       const listenKey = await createListenKey(this.creds.api_key, this.demo);
@@ -87,8 +73,6 @@ class BinanceOrchestrator extends BaseOrchestrator {
     this.creds = null;
     this.trackedAssetInfos.clear();
     this.currentPositions.clear();
-    this.collateralRatios.clear();
-    this.multiAssetsMargin = false;
   }
   get isConnected() {
     return this.ws?.isConnected ?? false;
@@ -102,10 +86,7 @@ class BinanceOrchestrator extends BaseOrchestrator {
       const info = {
         coin,
         leverage,
-        marginType,
-        availableToTrade: null,
-        maxTradeSzs: null,
-        collateralToken: null
+        marginType
       };
       this.trackedAssetInfos.set(coin, info);
       const trackedAssets = /* @__PURE__ */ new Map();
@@ -166,7 +147,7 @@ class BinanceOrchestrator extends BaseOrchestrator {
     }
   }
   handleAccountStatus(result) {
-    const balance = mapBalance(result, this.collateralRatios);
+    const balance = mapBalance(result);
     this.onStateUpdate({ balance });
   }
   handlePositionRisk(risk, merge) {

package/dist/account/exchanges/bybit/mapper.d.ts

@@ -2,7 +2,7 @@ import { AccountBalance, AccountPosition } from '../../types.js';
 import { BybitRawWallet, BybitRawCoin, BybitRawPosition } from './types.js';
 import '@pear-protocol/types';
 
-declare function buildBalance(raw: BybitRawWallet, coins: Map<string, BybitRawCoin>, marginMode: string, collateralRatios: Map<string, string>): AccountBalance;
+declare function buildBalance(raw: BybitRawWallet, coins: Map<string, BybitRawCoin>, marginMode: string): AccountBalance;
 declare function mergeRawCoins(existing: Map<string, BybitRawCoin>, incoming: BybitRawCoin[]): Map<string, BybitRawCoin>;
 declare function mapSinglePosition(p: BybitRawPosition, size: string): AccountPosition;
 declare function mapPositions(raw: BybitRawPosition[]): Map<string, AccountPosition>;

package/dist/account/exchanges/bybit/mapper.js

@@ -1,7 +1,7 @@
 import '../../types';
 import { positionKey } from '../../utils';
 
-function buildBalance(raw, coins, marginMode, collateralRatios) {
+function buildBalance(raw, coins, marginMode) {
   const free = {};
   const used = {};
   const total = {};
@@ -11,7 +11,6 @@ function buildBalance(raw, coins, marginMode, collateralRatios) {
     const equity = c.equity ?? "0";
     const positionInitialMargin = c.totalPositionIM === "" ? "0" : c.totalPositionIM ?? "0";
     const orderInitialMargin = c.totalOrderIM === "" ? "0" : c.totalOrderIM ?? "0";
-    const positionMaintenanceMargin = c.totalPositionMM === "" ? "0" : c.totalPositionMM ?? "0";
     const locked = c.locked ?? "0";
     const equityNum = parseFloat(equity);
     const positionInitialMarginNum = parseFloat(positionInitialMargin);
@@ -36,19 +35,11 @@ function buildBalance(raw, coins, marginMode, collateralRatios) {
       used: coinUsed,
       total: equity,
       walletBalance: c.walletBalance ?? "0",
-      unrealizedPnl: c.unrealisedPnl ?? "0",
-      usdValue: c.usdValue ?? "0",
-      initialMargin: isPortfolio ? "0" : (positionInitialMarginNum + orderInitialMarginNum).toString(),
-      maintenanceMargin: positionMaintenanceMargin,
-      isCollateral: (c.marginCollateral ?? false) && (c.collateralSwitch ?? false),
-      collateralRatio: collateralRatios.get(c.coin) ?? "1.0000",
-      borrowedAmount: c.borrowAmount ?? "0"
+      usdValue: c.usdValue ?? "0"
     });
   }
   return {
-    exchange: "bybit",
     accountType: "UNIFIED",
-    marginMode,
     free,
     used,
     total,

package/dist/account/exchanges/bybit/orchestrator.d.ts

@@ -8,7 +8,6 @@ declare class BybitOrchestrator extends BaseOrchestrator {
     private lastWallet;
     private trackedAssetInfos;
     private marginMode;
-    private collateralRatios;
     start(credentials: SupportedCredentials): Promise<void>;
     stop(): void;
     get isConnected(): boolean;

package/dist/account/exchanges/bybit/orchestrator.js

@@ -1,6 +1,6 @@
 import { BaseOrchestrator } from '../base';
 import { mergeRawCoins, buildBalance, mapPositions, mapPositionUpdates } from './mapper';
-import { fetchWalletBalance, fetchPositions, fetchAccountInfo, fetchCollateralRatios, fetchPositionLeverage, setLeverage } from './rest';
+import { fetchWalletBalance, fetchPositions, fetchAccountInfo, fetchPositionLeverage, setLeverage } from './rest';
 import { BybitWs } from './ws';
 
 class BybitOrchestrator extends BaseOrchestrator {
@@ -9,7 +9,6 @@ class BybitOrchestrator extends BaseOrchestrator {
   lastWallet = null;
   trackedAssetInfos = /* @__PURE__ */ new Map();
   marginMode = "cross";
-  collateralRatios = /* @__PURE__ */ new Map();
   async start(credentials) {
     const gen = ++this.startGeneration;
     this.manualClose = false;
@@ -17,11 +16,10 @@ class BybitOrchestrator extends BaseOrchestrator {
     const creds = credentials;
     this.stopAll();
     try {
-      const [wallet, positions, accountInfo, ratios] = await Promise.all([
+      const [wallet, positions, accountInfo] = await Promise.all([
         fetchWalletBalance(creds, this.demo),
         fetchPositions(creds, this.demo),
-        fetchAccountInfo(creds, this.demo),
-        fetchCollateralRatios(creds, this.demo)
+        fetchAccountInfo(creds, this.demo)
       ]);
       if (gen !== this.startGeneration) return;
       const MARGIN_MODE_MAP = {
@@ -31,12 +29,11 @@ class BybitOrchestrator extends BaseOrchestrator {
       };
       const rawMode = accountInfo?.marginMode ?? "REGULAR_MARGIN";
       this.marginMode = MARGIN_MODE_MAP[rawMode] ?? "cross";
-      this.collateralRatios = ratios;
       if (wallet) {
         this.lastWallet = wallet;
         this.rawCoins = mergeRawCoins(/* @__PURE__ */ new Map(), wallet.coin ?? []);
         this.onStateUpdate({
-          balance: buildBalance(wallet, this.rawCoins, this.marginMode, this.collateralRatios)
+          balance: buildBalance(wallet, this.rawCoins, this.marginMode)
         });
       }
       this.onStateUpdate({ positions: mapPositions(positions) });
@@ -67,7 +64,6 @@ class BybitOrchestrator extends BaseOrchestrator {
     this.rawCoins.clear();
     this.lastWallet = null;
     this.trackedAssetInfos.clear();
-    this.collateralRatios.clear();
     this.marginMode = "cross";
     this.credentials = null;
   }
@@ -83,10 +79,7 @@ class BybitOrchestrator extends BaseOrchestrator {
       const info = {
         coin,
         leverage,
-        marginType,
-        availableToTrade: null,
-        maxTradeSzs: null,
-        collateralToken: null
+        marginType
       };
       this.trackedAssetInfos.set(coin, info);
       const trackedAssets = /* @__PURE__ */ new Map();
@@ -151,7 +144,7 @@ class BybitOrchestrator extends BaseOrchestrator {
     } : raw;
     this.lastWallet = merged;
     this.onStateUpdate({
-      balance: buildBalance(merged, this.rawCoins, this.marginMode, this.collateralRatios)
+      balance: buildBalance(merged, this.rawCoins, this.marginMode)
     });
   }
 }

package/dist/account/exchanges/hyperliquid/const.d.ts

@@ -0,0 +1,3 @@
+declare const LOCKED_TRACKED_COINS: readonly ["BTC"];
+
+export { LOCKED_TRACKED_COINS };

package/dist/account/exchanges/hyperliquid/const.js

@@ -0,0 +1,3 @@
+const LOCKED_TRACKED_COINS = ["BTC"];
+
+export { LOCKED_TRACKED_COINS };

package/dist/account/exchanges/hyperliquid/mapper.d.ts

@@ -0,0 +1,9 @@
+import { AccountBalance, AccountPosition } from '../../types.js';
+import { AggregatedClearinghouseSummary, HyperliquidCoinBalance, AssetPosition } from './types.js';
+import '@pear-protocol/types';
+import '@nktkas/hyperliquid/api/subscription';
+
+declare function mapBalance(summary: AggregatedClearinghouseSummary, spotCoinBalances: Map<string, HyperliquidCoinBalance>, accountType: string, availableToTradeByCollateral: Map<string, number>): AccountBalance;
+declare function mapPositions(raw: AssetPosition[]): Map<string, AccountPosition>;
+
+export { mapBalance, mapPositions };

package/dist/account/exchanges/hyperliquid/mapper.js

@@ -0,0 +1,68 @@
+import { positionKey } from '../../utils';
+import { COLLATERAL_TOKEN_MAP } from './types';
+
+const COLLATERAL_COINS = new Set(Object.values(COLLATERAL_TOKEN_MAP));
+function mapBalance(summary, spotCoinBalances, accountType, availableToTradeByCollateral) {
+  const free = {};
+  const used = {};
+  const total = {};
+  const assets = [];
+  for (const [, coin] of spotCoinBalances) {
+    if (!COLLATERAL_COINS.has(coin.coin)) continue;
+    const availableOverride = availableToTradeByCollateral.get(coin.coin);
+    const coinFree = availableOverride !== void 0 ? availableOverride.toString() : (coin.total - coin.hold).toString();
+    const coinUsed = coin.hold.toString();
+    const coinTotal = coin.total.toString();
+    free[coin.coin] = coinFree;
+    used[coin.coin] = coinUsed;
+    total[coin.coin] = coinTotal;
+    assets.push({
+      asset: coin.coin,
+      free: coinFree,
+      used: coinUsed,
+      total: coinTotal,
+      walletBalance: coinTotal,
+      usdValue: coinTotal
+    });
+  }
+  const walletBalance = summary.accountValue - summary.totalUnrealizedPnl;
+  const marginRatio = summary.accountValue > 0 ? (summary.crossMaintenanceMarginUsed / summary.accountValue).toFixed(4) : "0.0000";
+  return {
+    accountType,
+    free,
+    used,
+    total,
+    availableToTrade: summary.withdrawable.toString(),
+    totalEquity: summary.accountValue.toString(),
+    walletBalance: walletBalance.toString(),
+    unrealizedPnl: summary.totalUnrealizedPnl.toString(),
+    initialMarginUsed: summary.totalMarginUsed.toString(),
+    maintenanceMargin: summary.crossMaintenanceMarginUsed.toString(),
+    marginRatio,
+    assets,
+    timestamp: Date.now()
+  };
+}
+function mapPositions(raw) {
+  const positions = /* @__PURE__ */ new Map();
+  for (const ap of raw) {
+    const pos = ap.position;
+    const szi = Number.parseFloat(pos.szi || "0");
+    if (szi === 0) continue;
+    const coin = pos.coin || "";
+    const side = szi > 0 ? "long" : "short";
+    positions.set(positionKey(coin, side), {
+      symbol: coin,
+      side,
+      size: szi.toString(),
+      entryPrice: pos.entryPx || "0",
+      unrealizedPnl: pos.unrealizedPnl || "0",
+      leverage: pos.leverage.value.toString(),
+      marginType: pos.leverage.type,
+      liquidationPrice: pos.liquidationPx || null
+    });
+  }
+  return positions;
+}
+
+export { mapBalance, mapPositions };

package/dist/account/exchanges/hyperliquid/orchestrator.d.ts

@@ -0,0 +1,38 @@
+import { InstrumentId } from '@pear-protocol/types';
+import { SupportedCredentials } from '../../types.js';
+import { BaseOrchestrator } from '../base.js';
+
+declare class HyperliquidOrchestrator extends BaseOrchestrator {
+    private static httpTransport;
+    private static wsTransport;
+    private infoClient;
+    private subsClient;
+    private subscriptions;
+    private address;
+    private activeAssetSubscriptions;
+    private trackedAssetData;
+    private spotCoinBalances;
+    private accountType;
+    private symbolToCollateralToken;
+    private availableToTradeByCollateral;
+    private lastSummary;
+    start(credentials: SupportedCredentials): Promise<void>;
+    stop(): void;
+    get isConnected(): boolean;
+    onAssetTracked(coin: string): void;
+    onAssetUntracked(coin: string): void;
+    setLeverage(id: InstrumentId, leverage: string): Promise<void>;
+    protected canUntrackAsset(coin: string): boolean;
+    private fetchPerpMetas;
+    private subscribeActiveAssetData;
+    private stopAll;
+    private handleClearinghouseState;
+    private handleActiveAssetData;
+    private buildTrackedAssetInfo;
+    private buildTrackedAssetsMap;
+    private buildBalance;
+    private handleWebData3;
+    private handleSpotState;
+}
+
+export { HyperliquidOrchestrator };

package/dist/account/exchanges/hyperliquid/orchestrator.js

@@ -0,0 +1,239 @@
+import { HttpTransport, WebSocketTransport, InfoClient, SubscriptionClient } from '@nktkas/hyperliquid';
+import { BaseOrchestrator } from '../base';
+import { LOCKED_TRACKED_COINS } from './const';
+import { mapPositions, mapBalance } from './mapper';
+import { setLeverage } from './rest';
+import { COLLATERAL_TOKEN_MAP } from './types';
+
+class HyperliquidOrchestrator extends BaseOrchestrator {
+  static httpTransport = new HttpTransport();
+  static wsTransport = new WebSocketTransport({
+    reconnect: {
+      maxRetries: Number.MAX_SAFE_INTEGER
+    }
+  });
+  infoClient = null;
+  subsClient = null;
+  subscriptions = [];
+  address = null;
+  activeAssetSubscriptions = /* @__PURE__ */ new Map();
+  trackedAssetData = /* @__PURE__ */ new Map();
+  spotCoinBalances = /* @__PURE__ */ new Map();
+  accountType = "disabled";
+  symbolToCollateralToken = /* @__PURE__ */ new Map();
+  availableToTradeByCollateral = /* @__PURE__ */ new Map();
+  lastSummary = {
+    accountValue: 0,
+    totalMarginUsed: 0,
+    totalRawUsd: 0,
+    crossMaintenanceMarginUsed: 0,
+    withdrawable: 0,
+    totalUnrealizedPnl: 0
+  };
+  async start(credentials) {
+    const gen = ++this.startGeneration;
+    this.manualClose = false;
+    this.credentials = credentials;
+    const creds = credentials;
+    this.address = creds.address;
+    await this.stopAll();
+    this.trackedAssetData.clear();
+    this.spotCoinBalances.clear();
+    this.symbolToCollateralToken.clear();
+    this.availableToTradeByCollateral.clear();
+    try {
+      this.infoClient = new InfoClient({ transport: HyperliquidOrchestrator.httpTransport });
+      await this.fetchPerpMetas();
+      if (gen !== this.startGeneration) return;
+      this.subsClient = new SubscriptionClient({ transport: HyperliquidOrchestrator.wsTransport });
+      const subs = [];
+      subs.push(
+        this.subsClient.allDexsClearinghouseState(
+          { user: this.address },
+          (data) => this.handleClearinghouseState(data)
+        )
+      );
+      subs.push(this.subsClient.spotState({ user: this.address }, (data) => this.handleSpotState(data)));
+      subs.push(this.subsClient.webData3({ user: this.address }, (data) => this.handleWebData3(data)));
+      this.subscriptions = await Promise.all(subs);
+      if (gen !== this.startGeneration) return;
+      for (const sub of this.subscriptions) {
+        sub.failureSignal.addEventListener("abort", () => {
+          if (!this.manualClose) {
+            this.onError(new Error("Hyperliquid subscription failed after reconnect"));
+          }
+        });
+      }
+      for (const coin of LOCKED_TRACKED_COINS) {
+        this.trackAsset(coin);
+      }
+      for (const coin of this.trackedCoins) {
+        if (!LOCKED_TRACKED_COINS.includes(coin)) {
+          await this.subscribeActiveAssetData(coin);
+        }
+      }
+      this.reconnectAttempts = 0;
+    } catch (err) {
+      if (gen !== this.startGeneration) return;
+      await this.stopAll();
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+      this.scheduleReconnect();
+    }
+  }
+  stop() {
+    this.manualClose = true;
+    this.stopAll();
+    this.credentials = null;
+    this.address = null;
+  }
+  get isConnected() {
+    return this.subsClient !== null && !this.manualClose;
+  }
+  onAssetTracked(coin) {
+    this.subscribeActiveAssetData(coin).catch((err) => {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    });
+  }
+  onAssetUntracked(coin) {
+    const sub = this.activeAssetSubscriptions.get(coin);
+    if (sub) {
+      sub.unsubscribe().catch(() => {
+      });
+      this.activeAssetSubscriptions.delete(coin);
+    }
+    this.trackedAssetData.delete(coin);
+    const trackedAssets = this.buildTrackedAssetsMap();
+    this.onStateUpdate({ trackedAssets });
+  }
+  async setLeverage(id, leverage) {
+    const creds = this.credentials;
+    if (!creds) throw new Error("Not connected");
+    const asset = Number.parseInt(id, 10);
+    if (Number.isNaN(asset)) throw new Error(`Invalid Hyperliquid asset index: ${id}`);
+    const tracked = this.trackedAssetData.get(id);
+    const isCross = tracked?.leverage?.type === "cross";
+    await setLeverage(creds, asset, Number.parseFloat(leverage), isCross);
+  }
+  canUntrackAsset(coin) {
+    return !LOCKED_TRACKED_COINS.includes(coin);
+  }
+  async fetchPerpMetas() {
+    if (!this.infoClient) return;
+    const allMetas = await this.infoClient.allPerpMetas();
+    allMetas.forEach((dexMeta) => {
+      const collateralToken = COLLATERAL_TOKEN_MAP[dexMeta.collateralToken];
+      dexMeta.universe.forEach((asset) => {
+        if (!asset.name) return;
+        if (collateralToken && !this.symbolToCollateralToken.has(asset.name)) {
+          this.symbolToCollateralToken.set(asset.name, collateralToken);
+        }
+      });
+    });
+  }
+  async subscribeActiveAssetData(coin) {
+    if (!this.subsClient || !this.address) return;
+    if (this.activeAssetSubscriptions.has(coin)) return;
+    const sub = await this.subsClient.activeAssetData(
+      { coin, user: this.address },
+      (data) => this.handleActiveAssetData(data)
+    );
+    sub.failureSignal.addEventListener("abort", () => {
+      if (!this.manualClose) {
+        this.activeAssetSubscriptions.delete(coin);
+      }
+    });
+    this.activeAssetSubscriptions.set(coin, sub);
+  }
+  async stopAll() {
+    this.clearReconnectTimer();
+    const assetUnsubs = Array.from(this.activeAssetSubscriptions.values()).map((s) => s.unsubscribe().catch(() => {
+    }));
+    this.activeAssetSubscriptions.clear();
+    const unsubs = this.subscriptions.map((s) => s.unsubscribe().catch(() => {
+    }));
+    this.subscriptions = [];
+    await Promise.all([...unsubs, ...assetUnsubs]);
+    this.subsClient = null;
+    this.infoClient = null;
+  }
+  handleClearinghouseState(data) {
+    const states = (data.clearinghouseStates || []).map(([, s]) => s).filter(Boolean);
+    const sumStr = (values) => values.reduce((acc, v) => acc + (Number.parseFloat(v || "0") || 0), 0);
+    const allAssetPositions = states.flatMap((s) => s.assetPositions || []);
+    const totalUnrealizedPnl = allAssetPositions.reduce(
+      (acc, ap) => acc + (Number.parseFloat(ap.position.unrealizedPnl || "0") || 0),
+      0
+    );
+    this.lastSummary = {
+      accountValue: sumStr(states.map((s) => s.crossMarginSummary.accountValue)),
+      totalMarginUsed: sumStr(states.map((s) => s.crossMarginSummary.totalMarginUsed)),
+      totalRawUsd: sumStr(states.map((s) => s.crossMarginSummary.totalRawUsd)),
+      crossMaintenanceMarginUsed: sumStr(states.map((s) => s.crossMaintenanceMarginUsed)),
+      withdrawable: sumStr(states.map((s) => s.withdrawable)),
+      totalUnrealizedPnl
+    };
+    const balance = this.buildBalance();
+    const positions = mapPositions(allAssetPositions);
+    const leverageSettings = /* @__PURE__ */ new Map();
+    for (const ap of allAssetPositions) {
+      const coin = ap.position.coin;
+      if (coin && ap.position.leverage?.value) {
+        leverageSettings.set(coin, ap.position.leverage.value.toString());
+      }
+    }
+    this.onStateUpdate({ balance, positions, leverageSettings });
+  }
+  handleActiveAssetData(data) {
+    if (!data.coin) return;
+    this.trackedAssetData.set(data.coin, data);
+    const collateral = this.symbolToCollateralToken.get(data.coin);
+    if (collateral && data.availableToTrade) {
+      const long = Number.parseFloat(data.availableToTrade[0] || "0");
+      const short = Number.parseFloat(data.availableToTrade[1] || "0");
+      const minAvailable = Math.min(long, short);
+      this.availableToTradeByCollateral.set(collateral, minAvailable);
+      const balance = this.buildBalance();
+      this.onStateUpdate({ balance });
+    }
+    const trackedAssets = /* @__PURE__ */ new Map();
+    trackedAssets.set(data.coin, this.buildTrackedAssetInfo(data));
+    this.onStateUpdate({ trackedAssets });
+  }
+  buildTrackedAssetInfo(data) {
+    return {
+      coin: data.coin,
+      leverage: (data.leverage?.value ?? 1).toString(),
+      marginType: data.leverage?.type === "isolated" ? "isolated" : "cross"
+    };
+  }
+  buildTrackedAssetsMap() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [coin, data] of this.trackedAssetData) {
+      result.set(coin, this.buildTrackedAssetInfo(data));
+    }
+    return result;
+  }
+  buildBalance() {
+    return mapBalance(this.lastSummary, this.spotCoinBalances, this.accountType, this.availableToTradeByCollateral);
+  }
+  handleWebData3(data) {
+    this.accountType = data.userState.abstraction || "disabled";
+  }
+  handleSpotState(data) {
+    const balances = data?.spotState?.balances;
+    if (!balances) return;
+    for (const b of balances) {
+      const total = Number.parseFloat(b.total || "0");
+      const hold = Number.parseFloat(b.hold || "0");
+      if (total !== 0 || hold !== 0) {
+        this.spotCoinBalances.set(b.coin, { coin: b.coin, total, hold });
+      } else {
+        this.spotCoinBalances.delete(b.coin);
+      }
+    }
+    const balance = this.buildBalance();
+    this.onStateUpdate({ balance });
+  }
+}
+
+export { HyperliquidOrchestrator };

package/dist/account/exchanges/hyperliquid/rest.d.ts

@@ -0,0 +1,6 @@
+import { HyperliquidAccountCredentials } from '../../types.js';
+import '@pear-protocol/types';
+
+declare function setLeverage(creds: HyperliquidAccountCredentials, asset: number, leverage: number, isCross: boolean): Promise<void>;
+
+export { setLeverage };

package/dist/account/exchanges/hyperliquid/rest.js

@@ -0,0 +1,11 @@
+import { HttpTransport, ExchangeClient } from '@nktkas/hyperliquid';
+import { privateKeyToAccount } from 'viem/accounts';
+
+async function setLeverage(creds, asset, leverage, isCross) {
+  const transport = new HttpTransport();
+  const wallet = privateKeyToAccount(creds.signer_key);
+  const exchangeClient = new ExchangeClient({ transport, wallet });
+  await exchangeClient.updateLeverage({ asset, leverage, isCross });
+}
+
+export { setLeverage };

package/dist/account/exchanges/hyperliquid/types.d.ts

@@ -0,0 +1,20 @@
+import { AllDexsClearinghouseStateEvent } from '@nktkas/hyperliquid/api/subscription';
+
+type ClearinghouseState = AllDexsClearinghouseStateEvent['clearinghouseStates'][number][1];
+type AssetPosition = ClearinghouseState['assetPositions'][number];
+interface HyperliquidCoinBalance {
+    coin: string;
+    total: number;
+    hold: number;
+}
+interface AggregatedClearinghouseSummary {
+    accountValue: number;
+    totalMarginUsed: number;
+    totalRawUsd: number;
+    crossMaintenanceMarginUsed: number;
+    withdrawable: number;
+    totalUnrealizedPnl: number;
+}
+declare const COLLATERAL_TOKEN_MAP: Record<number, string>;
+
+export { type AggregatedClearinghouseSummary, type AssetPosition, COLLATERAL_TOKEN_MAP, type ClearinghouseState, type HyperliquidCoinBalance };

package/dist/account/exchanges/hyperliquid/types.js

@@ -0,0 +1,8 @@
+const COLLATERAL_TOKEN_MAP = {
+  0: "USDC",
+  235: "USDE",
+  268: "USDT0",
+  360: "USDH"
+};
+
+export { COLLATERAL_TOKEN_MAP };

package/dist/account/exchanges/index.js

@@ -1,6 +1,7 @@
 import './base';
 import { BinanceOrchestrator } from './binance/orchestrator';
 import { BybitOrchestrator } from './bybit/orchestrator';
+import { HyperliquidOrchestrator } from './hyperliquid/orchestrator';
 
 function createOrchestrator(exchange, config) {
   switch (exchange) {
@@ -8,6 +9,8 @@ function createOrchestrator(exchange, config) {
       return new BinanceOrchestrator(config);
     case "bybit":
       return new BybitOrchestrator(config);
+    case "hyperliquid":
+      return new HyperliquidOrchestrator(config);
     default:
       throw new Error(`Unsupported exchange: ${exchange}`);
   }

package/dist/account/index.d.ts

@@ -1,8 +1,8 @@
 export { AccountManager } from './account-manager.js';
 export { ExchangeAccount } from './exchange-account.js';
 export { createOrchestrator } from './exchanges/index.js';
-export { AccountBalance, AccountConfig, AccountPosition, AssetBalance, BalanceCallback, ExchangeState, MarginMode, PositionsCallback, StateUpdate, SupportedCredentials, TrackedAssetCallback, TrackedAssetInfo, Tracker } from './types.js';
+export { AccountBalance, AccountConfig, AccountPosition, AssetBalance, BalanceCallback, ExchangeState, HyperliquidAccountCredentials, MarginMode, PositionsCallback, StateUpdate, SupportedCredentials, TrackedAssetCallback, TrackedAssetInfo, Tracker } from './types.js';
 export { Orchestrator, OrchestratorConfig } from './exchanges/base.js';
+import '@pear-protocol/core-sdk';
 import '@pear-protocol/types';
 import '../credentials.js';
-import '@pear-protocol/core-sdk';

package/dist/account/types.d.ts

@@ -1,4 +1,4 @@
-import { Connector, BinanceUSDMCredentialsDTO, BybitCredentialsDTO } from '@pear-protocol/types';
+import { Connector, BinanceUSDMCredentialsDTO, BybitCredentialsDTO, HyperliquidCredentialsDTO } from '@pear-protocol/types';
 
 type MarginMode = 'cross' | 'isolated';
 interface AssetBalance {
@@ -7,18 +7,10 @@ interface AssetBalance {
     used: string;
     total: string;
     walletBalance: string;
-    unrealizedPnl: string;
     usdValue: string;
-    initialMargin: string;
-    maintenanceMargin: string;
-    isCollateral: boolean;
-    collateralRatio: string;
-    borrowedAmount: string;
 }
 interface AccountBalance {
-    exchange: string;
     accountType: string;
-    marginMode: string;
     free: Record<string, string>;
     used: Record<string, string>;
     total: Record<string, string>;
@@ -46,9 +38,6 @@ interface TrackedAssetInfo {
     coin: string;
     leverage: string;
     marginType: MarginMode;
-    availableToTrade: [string, string] | null;
-    maxTradeSzs: [string, string] | null;
-    collateralToken: string | null;
 }
 interface ExchangeState {
     balance: AccountBalance | null;
@@ -70,7 +59,10 @@ interface AccountConfig {
     demo?: boolean;
     onAuthError?: () => void;
 }
-type SupportedCredentials = BinanceUSDMCredentialsDTO | BybitCredentialsDTO;
+type HyperliquidAccountCredentials = HyperliquidCredentialsDTO & {
+    address: string;
+};
+type SupportedCredentials = BinanceUSDMCredentialsDTO | BybitCredentialsDTO | HyperliquidAccountCredentials;
 interface StateUpdate {
     balance?: AccountBalance;
     positions?: Map<string, AccountPosition>;
@@ -78,4 +70,4 @@ interface StateUpdate {
     trackedAssets?: Map<string, TrackedAssetInfo>;
 }
 
-export type { AccountBalance, AccountConfig, AccountPosition, AssetBalance, BalanceCallback, ExchangeState, MarginMode, PositionsCallback, StateUpdate, SupportedCredentials, TrackedAssetCallback, TrackedAssetInfo, Tracker };
+export type { AccountBalance, AccountConfig, AccountPosition, AssetBalance, BalanceCallback, ExchangeState, HyperliquidAccountCredentials, MarginMode, PositionsCallback, StateUpdate, SupportedCredentials, TrackedAssetCallback, TrackedAssetInfo, Tracker };

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import PearSDK from '@pear-protocol/core-sdk';
 import { AccountManager } from './account/account-manager.js';
 export { ExchangeAccount } from './account/exchange-account.js';
 export { createOrchestrator } from './account/exchanges/index.js';
-export { AccountBalance, AccountConfig, AccountPosition, AssetBalance, BalanceCallback, ExchangeState, MarginMode, PositionsCallback, StateUpdate, SupportedCredentials, TrackedAssetCallback, TrackedAssetInfo, Tracker } from './account/types.js';
+export { AccountBalance, AccountConfig, AccountPosition, AssetBalance, BalanceCallback, ExchangeState, HyperliquidAccountCredentials, MarginMode, PositionsCallback, StateUpdate, SupportedCredentials, TrackedAssetCallback, TrackedAssetInfo, Tracker } from './account/types.js';
 import { Credentials } from './credentials.js';
 export { Orchestrator, OrchestratorConfig } from './account/exchanges/base.js';
 import '@pear-protocol/types';

package/dist/index.js

@@ -10,7 +10,7 @@ class ExchangesSDK {
   constructor(config) {
     this.sdk = config.sdk;
     this.credentials = new Credentials(config.sdk);
-    this.account = new AccountManager(this.credentials, config.demo);
+    this.account = new AccountManager(this.credentials, config.sdk, config.demo);
   }
   destroy() {
     this.account.destroy();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/exchanges-sdk",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Pear Protocol Exchanges SDK",
   "private": false,
   "type": "module",
@@ -25,8 +25,10 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@nktkas/hyperliquid": "0.30.2",
     "@pear-protocol/core-sdk": "0.0.8",
-    "@pear-protocol/types": "0.0.7"
+    "@pear-protocol/types": "0.0.7",
+    "viem": "^2.43.5"
   },
   "devDependencies": {
     "@backend/typescript-config": "workspace:*",