@pear-protocol/exchanges-sdk 0.0.10 → 0.0.12

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

@@ -1,238 +1,101 @@
-import { HttpTransport, WebSocketTransport, InfoClient, SubscriptionClient } from '@nktkas/hyperliquid';
+import { createWs, waitForOpen, sendWs } from '../../../utils/ws';
 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';
+import { HyperliquidStateHandler } from './state-handler';
+import { HyperliquidAssetTracker } from './asset-tracker';
 
+const HL_WS_URL = "wss://api.hyperliquid.xyz/ws";
+const HL_INFO_URL = "https://api.hyperliquid.xyz/info";
 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;
+  ws = null;
+  address;
+  stateHandler;
+  assetTracker;
+  constructor(config, credentials) {
+    super(config);
     const creds = credentials;
+    this.credentials = 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);
-        }
-      });
+    this.stateHandler = new HyperliquidStateHandler((update) => this.onStateUpdate(update));
+    this.assetTracker = new HyperliquidAssetTracker({
+      onStateUpdate: (update) => this.onStateUpdate(update),
+      onActiveAssetData: (data) => this.stateHandler.handleActiveAssetData(data),
+      getWs: () => this.ws,
+      getAddress: () => this.address,
+      isStopped: () => this.stopped
     });
   }
-  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);
-      }
+  async initAsync() {
+    const allMetas = await this.fetchInfo({ type: "allPerpMetas" });
+    this.stateHandler.loadPerpMetas(allMetas);
+    this.ws = createWs(HL_WS_URL);
+    await waitForOpen(this.ws);
+    this.ws.addEventListener("message", (event) => {
+      this.handleMessage(event.data);
     });
-    this.activeAssetSubscriptions.set(coin, sub);
+    const userAddr = this.address.toLowerCase();
+    this.subscribe({ type: "allDexsClearinghouseState", user: userAddr });
+    this.subscribe({ type: "spotState", user: userAddr });
+    this.subscribe({ type: "webData3", user: userAddr });
+    for (const coin of LOCKED_TRACKED_COINS) {
+      this.trackAsset(coin);
+    }
+    this.assetTracker.subscribeAll(this.trackedCoins);
   }
-  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;
+  subscribe(subscription) {
+    sendWs(this.ws, { method: "subscribe", subscription });
   }
-  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());
+  handleMessage(raw) {
+    try {
+      const text = typeof raw === "string" ? raw : void 0;
+      if (!text) return;
+      const msg = JSON.parse(text);
+      if (!msg.channel || !msg.data) return;
+      switch (msg.channel) {
+        case "allDexsClearinghouseState":
+          this.stateHandler.handleClearinghouseState(msg.data);
+          break;
+        case "spotState":
+          this.stateHandler.handleSpotState(msg.data);
+          break;
+        case "webData3":
+          this.stateHandler.handleWebData3(msg.data);
+          break;
+        case "activeAssetData":
+          this.assetTracker.handleActiveAssetDataMessage(msg.data);
+          break;
       }
+    } catch {
     }
-    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 });
+  async fetchInfo(body) {
+    const res = await fetch(HL_INFO_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) throw new Error(`Hyperliquid info request failed: ${res.status}`);
+    return res.json();
   }
-  buildTrackedAssetInfo(data) {
-    return {
-      coin: data.coin,
-      leverage: (data.leverage?.value ?? 1).toString(),
-      marginType: data.leverage?.type === "isolated" ? "isolated" : "cross"
-    };
+  cleanupConnections() {
+    this.ws?.close();
+    this.ws = null;
   }
-  buildTrackedAssetsMap() {
-    const result = /* @__PURE__ */ new Map();
-    for (const [coin, data] of this.trackedAssetData) {
-      result.set(coin, this.buildTrackedAssetInfo(data));
-    }
-    return result;
+  async stop() {
+    this.stopped = true;
+    this.cleanupConnections();
   }
-  buildBalance() {
-    return mapBalance(this.lastSummary, this.spotCoinBalances, this.accountType, this.availableToTradeByCollateral);
+  get isConnected() {
+    return this.ws !== null && !this.stopped;
   }
-  handleWebData3(data) {
-    this.accountType = data.userState.abstraction || "disabled";
+  onAssetTracked(coin) {
+    this.assetTracker.onAssetTracked(coin);
   }
-  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 });
+  onAssetUntracked(coin) {
+    this.assetTracker.onAssetUntracked(coin);
+  }
+  canUntrackAsset(coin) {
+    return this.assetTracker.canUntrack(coin);
   }
 }
 

package/dist/account/exchanges/hyperliquid/state-handler.d.ts

@@ -0,0 +1,24 @@
+import { S as StateUpdate, h as TrackedAssetInfo } from '../../../types-D2dbAtin.js';
+import { AllPerpMetasResponse, AllDexsClearinghouseStateEvent, ActiveAssetDataEvent, WebData3Event, SpotStateEvent } from './types.js';
+import '@pear-protocol/types';
+import '../bybit/types.js';
+
+type OnStateUpdate = (update: StateUpdate) => void;
+declare class HyperliquidStateHandler {
+    private onStateUpdate;
+    private lastSummary;
+    private spotCoinBalances;
+    private accountType;
+    private symbolToCollateralToken;
+    private availableToTradeByCollateral;
+    constructor(onStateUpdate: OnStateUpdate);
+    loadPerpMetas(allMetas: AllPerpMetasResponse): void;
+    handleClearinghouseState(data: AllDexsClearinghouseStateEvent): void;
+    handleActiveAssetData(data: ActiveAssetDataEvent): void;
+    handleWebData3(data: WebData3Event): void;
+    handleSpotState(data: SpotStateEvent): void;
+    private buildBalance;
+}
+declare function buildTrackedAssetInfo(data: ActiveAssetDataEvent): TrackedAssetInfo;
+
+export { HyperliquidStateHandler, buildTrackedAssetInfo };

package/dist/account/exchanges/hyperliquid/state-handler.js

@@ -0,0 +1,104 @@
+import { mapPositions, mapBalance } from './mapper';
+import { COLLATERAL_TOKEN_MAP } from './types';
+
+class HyperliquidStateHandler {
+  onStateUpdate;
+  lastSummary = {
+    accountValue: 0,
+    totalMarginUsed: 0,
+    totalRawUsd: 0,
+    crossMaintenanceMarginUsed: 0,
+    withdrawable: 0,
+    totalUnrealizedPnl: 0
+  };
+  spotCoinBalances = /* @__PURE__ */ new Map();
+  accountType = null;
+  symbolToCollateralToken = /* @__PURE__ */ new Map();
+  availableToTradeByCollateral = /* @__PURE__ */ new Map();
+  constructor(onStateUpdate) {
+    this.onStateUpdate = onStateUpdate;
+  }
+  loadPerpMetas(allMetas) {
+    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);
+        }
+      });
+    });
+  }
+  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: balance ?? void 0, positions, leverageSettings });
+  }
+  handleActiveAssetData(data) {
+    if (!data.coin) return;
+    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();
+      if (balance) this.onStateUpdate({ balance });
+    }
+    const trackedAssets = /* @__PURE__ */ new Map();
+    trackedAssets.set(data.coin, buildTrackedAssetInfo(data));
+    this.onStateUpdate({ trackedAssets });
+  }
+  handleWebData3(data) {
+    this.accountType = data.userState.abstraction ?? null;
+  }
+  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();
+    if (balance) this.onStateUpdate({ balance });
+  }
+  buildBalance() {
+    return mapBalance(this.lastSummary, this.spotCoinBalances, this.accountType, this.availableToTradeByCollateral);
+  }
+}
+function buildTrackedAssetInfo(data) {
+  return {
+    coin: data.coin,
+    leverage: (data.leverage?.value ?? 1).toString(),
+    marginType: data.leverage?.type === "isolated" ? "isolated" : "cross"
+  };
+}
+
+export { HyperliquidStateHandler, buildTrackedAssetInfo };

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

@@ -1,7 +1,10 @@
-import { AllDexsClearinghouseStateEvent } from '@nktkas/hyperliquid/api/subscription';
-
-type ClearinghouseState = AllDexsClearinghouseStateEvent['clearinghouseStates'][number][1];
-type AssetPosition = ClearinghouseState['assetPositions'][number];
+declare enum HyperliquidAccountType {
+    DEFAULT = "default",
+    DEX_ABSTRACTION = "dexAbstraction",
+    DISABLED = "disabled",
+    PORTFOLIO_MARGIN = "portfolioMargin",
+    UNIFIED_ACCOUNT = "unifiedAccount"
+}
 interface HyperliquidCoinBalance {
     coin: string;
     total: number;
@@ -16,5 +19,116 @@ interface AggregatedClearinghouseSummary {
     totalUnrealizedPnl: number;
 }
 declare const COLLATERAL_TOKEN_MAP: Record<number, string>;
+type MetaResponse = {
+    universe: {
+        szDecimals: number;
+        name: string;
+        maxLeverage: number;
+        marginTableId: number;
+        onlyIsolated?: true;
+        isDelisted?: true;
+    }[];
+    marginTables: [
+        id: number,
+        table: {
+            description: string;
+            marginTiers: {
+                lowerBound: string;
+                maxLeverage: number;
+            }[];
+        }
+    ][];
+    collateralToken: number;
+};
+type AllPerpMetasResponse = MetaResponse[];
+type LeverageInfo = {
+    type: 'isolated';
+    value: number;
+    rawUsd: string;
+} | {
+    type: 'cross';
+    value: number;
+};
+type ClearinghouseStateResponse = {
+    marginSummary: {
+        accountValue: string;
+        totalNtlPos: string;
+        totalRawUsd: string;
+        totalMarginUsed: string;
+    };
+    crossMarginSummary: {
+        accountValue: string;
+        totalNtlPos: string;
+        totalRawUsd: string;
+        totalMarginUsed: string;
+    };
+    crossMaintenanceMarginUsed: string;
+    withdrawable: string;
+    assetPositions: {
+        type: 'oneWay';
+        position: {
+            coin: string;
+            szi: string;
+            leverage: LeverageInfo;
+            entryPx: string;
+            positionValue: string;
+            unrealizedPnl: string;
+            returnOnEquity: string;
+            liquidationPx: string | null;
+            marginUsed: string;
+            maxLeverage: number;
+            cumFunding: {
+                allTime: string;
+                sinceOpen: string;
+                sinceChange: string;
+            };
+        };
+    }[];
+    time: number;
+};
+type AssetPosition = ClearinghouseStateResponse['assetPositions'][number];
+type AllDexsClearinghouseStateEvent = {
+    user: `0x${string}`;
+    clearinghouseStates: [dex: string, state: ClearinghouseStateResponse][];
+};
+type ActiveAssetDataEvent = {
+    user: `0x${string}`;
+    coin: string;
+    leverage: LeverageInfo;
+    maxTradeSzs: [min: string, max: string];
+    availableToTrade: [min: string, max: string];
+    markPx: string;
+};
+type SpotClearinghouseStateResponse = {
+    balances: {
+        coin: string;
+        token: number;
+        total: string;
+        hold: string;
+        entryNtl: string;
+    }[];
+};
+type SpotStateEvent = {
+    user: `0x${string}`;
+    spotState: SpotClearinghouseStateResponse;
+};
+type WebData3Event = {
+    userState: {
+        agentAddress: `0x${string}` | null;
+        agentValidUntil: number | null;
+        cumLedger: string;
+        serverTime: number;
+        isVault: boolean;
+        user: `0x${string}`;
+        optOutOfSpotDusting?: true;
+        dexAbstractionEnabled?: boolean;
+        abstraction?: 'dexAbstraction' | 'unifiedAccount' | 'portfolioMargin' | 'disabled';
+    };
+    perpDexStates: {
+        totalVaultEquity: string;
+        perpsAtOpenInterestCap?: unknown;
+        leadingVaults?: unknown;
+    }[];
+};
 
-export { type AggregatedClearinghouseSummary, type AssetPosition, COLLATERAL_TOKEN_MAP, type ClearinghouseState, type HyperliquidCoinBalance };
+export { type ActiveAssetDataEvent, type AggregatedClearinghouseSummary, type AllDexsClearinghouseStateEvent, type AllPerpMetasResponse, type AssetPosition, COLLATERAL_TOKEN_MAP, type ClearinghouseStateResponse, HyperliquidAccountType, type HyperliquidCoinBalance, type LeverageInfo, type MetaResponse, type SpotClearinghouseStateResponse, type SpotStateEvent, type WebData3Event };

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

@@ -1,3 +1,11 @@
+var HyperliquidAccountType = /* @__PURE__ */ ((HyperliquidAccountType2) => {
+  HyperliquidAccountType2["DEFAULT"] = "default";
+  HyperliquidAccountType2["DEX_ABSTRACTION"] = "dexAbstraction";
+  HyperliquidAccountType2["DISABLED"] = "disabled";
+  HyperliquidAccountType2["PORTFOLIO_MARGIN"] = "portfolioMargin";
+  HyperliquidAccountType2["UNIFIED_ACCOUNT"] = "unifiedAccount";
+  return HyperliquidAccountType2;
+})(HyperliquidAccountType || {});
 const COLLATERAL_TOKEN_MAP = {
   0: "USDC",
   235: "USDE",
@@ -5,4 +13,4 @@ const COLLATERAL_TOKEN_MAP = {
   360: "USDH"
 };
 
-export { COLLATERAL_TOKEN_MAP };
+export { COLLATERAL_TOKEN_MAP, HyperliquidAccountType };

package/dist/account/exchanges/index.d.ts

@@ -1,8 +1,10 @@
 import { Connector } from '@pear-protocol/types';
-import { OrchestratorConfig, BaseOrchestrator } from './base.js';
-export { Orchestrator } from './base.js';
-import '../types.js';
+import { OrchestratorConfig, Orchestrator } from './base.js';
+import { g as SupportedCredentials } from '../../types-D2dbAtin.js';
+export { f as BinanceAccountType } from '../../types-D2dbAtin.js';
+export { BybitAccountType } from './bybit/types.js';
+export { HyperliquidAccountType } from './hyperliquid/types.js';
 
-declare function createOrchestrator(exchange: Connector, config: OrchestratorConfig): BaseOrchestrator;
+declare function createOrchestrator(exchange: Connector, config: OrchestratorConfig, credentials: SupportedCredentials): Orchestrator;
 
-export { OrchestratorConfig, createOrchestrator };
+export { Orchestrator, OrchestratorConfig, createOrchestrator };

package/dist/account/exchanges/index.js

@@ -2,18 +2,26 @@ import './base';
 import { BinanceOrchestrator } from './binance/orchestrator';
 import { BybitOrchestrator } from './bybit/orchestrator';
 import { HyperliquidOrchestrator } from './hyperliquid/orchestrator';
+export { BinanceAccountType } from './binance/types';
+export { BybitAccountType } from './bybit/types';
+export { HyperliquidAccountType } from './hyperliquid/types';
 
-function createOrchestrator(exchange, config) {
+function createOrchestrator(exchange, config, credentials) {
+  let orchestrator;
   switch (exchange) {
     case "binance":
-      return new BinanceOrchestrator(config);
+      orchestrator = new BinanceOrchestrator(config, credentials);
+      break;
     case "bybit":
-      return new BybitOrchestrator(config);
+      orchestrator = new BybitOrchestrator(config, credentials);
+      break;
     case "hyperliquid":
-      return new HyperliquidOrchestrator(config);
+      orchestrator = new HyperliquidOrchestrator(config, credentials);
+      break;
     default:
       throw new Error(`Unsupported exchange: ${exchange}`);
   }
+  return orchestrator;
 }
 
 export { createOrchestrator };

package/dist/account/index.d.ts

@@ -1,7 +1,9 @@
 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, HyperliquidAccountCredentials, MarginMode, PositionsCallback, StateUpdate, SupportedCredentials, TrackedAssetCallback, TrackedAssetInfo, Tracker } from './types.js';
+export { A as ACCOUNT_TYPE_LABELS, a as AccountBalance, b as AccountConfig, c as AccountPosition, d as AccountType, e as AssetBalance, B as BalanceCallback, f as BinanceAccountType, E as ExchangeState, H as HyperliquidAccountCredentials, M as MarginMode, P as PositionsCallback, S as StateUpdate, g as SupportedCredentials, T as TrackedAssetCallback, h as TrackedAssetInfo, i as Tracker } from '../types-D2dbAtin.js';
+export { BybitAccountType } from './exchanges/bybit/types.js';
+export { HyperliquidAccountType } from './exchanges/hyperliquid/types.js';
 export { Orchestrator, OrchestratorConfig } from './exchanges/base.js';
 import '@pear-protocol/core-sdk';
 import '@pear-protocol/types';