@pear-protocol/exchanges-sdk 0.0.18 → 0.1.3

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

@@ -1,83 +0,0 @@
-import { hmacSha256Hex } from '../../../utils/hmac';
-import { createWs, sendWs, waitForOpen, ReconnectingWebSocket, clearIntervalTimer } from '../../../utils/ws';
-import { DEFAULT_PING_INTERVAL_MS, WS_URL_DEMO, WS_URL } from './const';
-
-class BybitWs {
-  ws = null;
-  pingTimer = null;
-  handlers;
-  demo;
-  creds = null;
-  pingIntervalMs;
-  constructor(handlers, demo, pingIntervalMs = DEFAULT_PING_INTERVAL_MS) {
-    this.handlers = handlers;
-    this.demo = demo;
-    this.pingIntervalMs = pingIntervalMs;
-  }
-  async connect(creds) {
-    this.creds = creds;
-    this.ws = createWs(this.demo ? WS_URL_DEMO : WS_URL);
-    this.ws.addEventListener("message", (event) => {
-      try {
-        const msg = JSON.parse(event.data);
-        if (msg.topic && msg.data) {
-          this.handlers.onMessage({ topic: msg.topic, data: msg.data });
-        }
-      } catch {
-      }
-    });
-    let initialOpen = true;
-    this.ws.addEventListener("open", () => {
-      if (initialOpen) {
-        initialOpen = false;
-        return;
-      }
-      if (!this.creds) return;
-      this.authenticate(this.creds).then(() => {
-        sendWs(this.ws, { op: "subscribe", args: ["wallet", "position"] });
-      }).catch(() => {
-      });
-    });
-    await waitForOpen(this.ws);
-    await this.authenticate(creds);
-    sendWs(this.ws, { op: "subscribe", args: ["wallet", "position"] });
-    this.pingTimer = setInterval(() => sendWs(this.ws, { op: "ping" }), this.pingIntervalMs);
-  }
-  close() {
-    this.clearPing();
-    this.creds = null;
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  get isConnected() {
-    return this.ws?.readyState === ReconnectingWebSocket.OPEN;
-  }
-  clearPing() {
-    this.pingTimer = clearIntervalTimer(this.pingTimer);
-  }
-  async authenticate(creds) {
-    const expires = Date.now() + 1e4;
-    const signature = await hmacSha256Hex(creds.api_secret, `GET/realtime${expires}`);
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => reject(new Error("Bybit auth timeout")), 1e4);
-      const handler = (event) => {
-        try {
-          const msg = JSON.parse(event.data);
-          if (msg.op === "auth") {
-            clearTimeout(timeout);
-            this.ws?.removeEventListener("message", handler);
-            if (msg.success) resolve();
-            else reject(new Error(`Bybit auth failed: ${msg.ret_msg}`));
-          }
-        } catch {
-        }
-      };
-      this.ws?.addEventListener("message", handler);
-      sendWs(this.ws, { op: "auth", args: [creds.api_key, expires, signature] });
-    });
-  }
-}
-
-export { BybitWs };

package/dist/account/exchanges/hyperliquid/asset-tracker.d.ts

@@ -1,35 +0,0 @@
-import { WebSocket } from 'partysocket';
-import { S as StateUpdate } from '../../../types-Caz2X4h0.js';
-import { ActiveAssetDataEvent } from './types.js';
-import '@pear-protocol/types';
-import '../bybit/types.js';
-import '../okx/types.js';
-
-type OnStateUpdate = (update: StateUpdate) => void;
-type OnActiveAssetData = (data: ActiveAssetDataEvent) => void;
-declare class HyperliquidAssetTracker {
-    private onStateUpdate;
-    private onActiveAssetData;
-    private getWs;
-    private getAddress;
-    private isStopped;
-    private subscribedCoins;
-    private trackedAssetData;
-    constructor(deps: {
-        onStateUpdate: OnStateUpdate;
-        onActiveAssetData: OnActiveAssetData;
-        getWs: () => WebSocket | null;
-        getAddress: () => `0x${string}` | null;
-        isStopped: () => boolean;
-    });
-    onAssetTracked(coin: string): void;
-    onAssetUntracked(coin: string): void;
-    canUntrack(coin: string): boolean;
-    handleActiveAssetDataMessage(data: ActiveAssetDataEvent): void;
-    subscribeAll(coins: ReadonlySet<string>): void;
-    private subscribeActiveAssetData;
-    private unsubscribeActiveAssetData;
-    private buildTrackedAssetsMap;
-}
-
-export { HyperliquidAssetTracker };

package/dist/account/exchanges/hyperliquid/asset-tracker.js

@@ -1,83 +0,0 @@
-import { sendWs } from '../../../utils/ws';
-import { LOCKED_TRACKED_COINS } from './const';
-import { buildTrackedAssetInfo } from './state-handler';
-
-class HyperliquidAssetTracker {
-  onStateUpdate;
-  onActiveAssetData;
-  getWs;
-  getAddress;
-  isStopped;
-  subscribedCoins = /* @__PURE__ */ new Set();
-  trackedAssetData = /* @__PURE__ */ new Map();
-  constructor(deps) {
-    this.onStateUpdate = deps.onStateUpdate;
-    this.onActiveAssetData = deps.onActiveAssetData;
-    this.getWs = deps.getWs;
-    this.getAddress = deps.getAddress;
-    this.isStopped = deps.isStopped;
-  }
-  onAssetTracked(coin) {
-    this.subscribeActiveAssetData(coin);
-  }
-  onAssetUntracked(coin) {
-    this.unsubscribeActiveAssetData(coin);
-    this.trackedAssetData.delete(coin);
-    this.onStateUpdate({ trackedAssets: this.buildTrackedAssetsMap() });
-  }
-  canUntrack(coin) {
-    return !LOCKED_TRACKED_COINS.includes(coin);
-  }
-  handleActiveAssetDataMessage(data) {
-    if (!data.coin) return;
-    if (!this.subscribedCoins.has(data.coin)) return;
-    this.trackedAssetData.set(data.coin, data);
-    this.onActiveAssetData(data);
-  }
-  subscribeAll(coins) {
-    for (const coin of coins) {
-      if (!LOCKED_TRACKED_COINS.includes(coin)) {
-        this.subscribeActiveAssetData(coin);
-      }
-    }
-  }
-  subscribeActiveAssetData(coin) {
-    const ws = this.getWs();
-    const address = this.getAddress();
-    if (!ws || !address || this.isStopped()) return;
-    if (this.subscribedCoins.has(coin)) return;
-    this.subscribedCoins.add(coin);
-    sendWs(ws, {
-      method: "subscribe",
-      subscription: {
-        type: "activeAssetData",
-        coin,
-        user: address.toLowerCase()
-      }
-    });
-  }
-  unsubscribeActiveAssetData(coin) {
-    if (!this.subscribedCoins.has(coin)) return;
-    this.subscribedCoins.delete(coin);
-    const ws = this.getWs();
-    const address = this.getAddress();
-    if (!ws || !address) return;
-    sendWs(ws, {
-      method: "unsubscribe",
-      subscription: {
-        type: "activeAssetData",
-        coin,
-        user: address.toLowerCase()
-      }
-    });
-  }
-  buildTrackedAssetsMap() {
-    const result = /* @__PURE__ */ new Map();
-    for (const [coin, data] of this.trackedAssetData) {
-      result.set(coin, buildTrackedAssetInfo(data));
-    }
-    return result;
-  }
-}
-
-export { HyperliquidAssetTracker };

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

@@ -1,26 +0,0 @@
-import { g as SupportedCredentials } from '../../../types-Caz2X4h0.js';
-import { BaseOrchestrator, OrchestratorConfig } from '../base.js';
-import '@pear-protocol/types';
-import '../bybit/types.js';
-import './types.js';
-import '../okx/types.js';
-
-declare class HyperliquidOrchestrator extends BaseOrchestrator {
-    private ws;
-    private address;
-    private stateHandler;
-    private assetTracker;
-    constructor(config: OrchestratorConfig, credentials: SupportedCredentials);
-    protected initAsync(): Promise<void>;
-    private subscribe;
-    private handleMessage;
-    private fetchInfo;
-    protected cleanupConnections(): void;
-    stop(): Promise<void>;
-    get isConnected(): boolean;
-    onAssetTracked(coin: string): void;
-    onAssetUntracked(coin: string): void;
-    protected canUntrackAsset(coin: string): boolean;
-}
-
-export { HyperliquidOrchestrator };

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

@@ -1,102 +0,0 @@
-import { createWs, waitForOpen, sendWs } from '../../../utils/ws';
-import { BaseOrchestrator } from '../base';
-import { HyperliquidAssetTracker } from './asset-tracker';
-import { LOCKED_TRACKED_COINS } from './const';
-import { HyperliquidStateHandler } from './state-handler';
-
-const HL_WS_URL = "wss://api.hyperliquid.xyz/ws";
-const HL_INFO_URL = "https://api.hyperliquid.xyz/info";
-class HyperliquidOrchestrator extends BaseOrchestrator {
-  ws = null;
-  address;
-  stateHandler;
-  assetTracker;
-  constructor(config, credentials) {
-    super(config);
-    const creds = credentials;
-    this.credentials = credentials;
-    this.address = creds.address;
-    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 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);
-    });
-    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);
-  }
-  subscribe(subscription) {
-    sendWs(this.ws, { method: "subscribe", subscription });
-  }
-  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 {
-    }
-  }
-  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();
-  }
-  cleanupConnections() {
-    this.ws?.close();
-    this.ws = null;
-  }
-  async stop() {
-    this.stopped = true;
-    this.cleanupConnections();
-  }
-  get isConnected() {
-    return this.ws !== null && !this.stopped;
-  }
-  onAssetTracked(coin) {
-    this.assetTracker.onAssetTracked(coin);
-  }
-  onAssetUntracked(coin) {
-    this.assetTracker.onAssetUntracked(coin);
-  }
-  canUntrackAsset(coin) {
-    return this.assetTracker.canUntrack(coin);
-  }
-}
-
-export { HyperliquidOrchestrator };

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

@@ -1,25 +0,0 @@
-import { S as StateUpdate, h as TrackedAssetInfo } from '../../../types-Caz2X4h0.js';
-import { AllPerpMetasResponse, AllDexsClearinghouseStateEvent, ActiveAssetDataEvent, WebData3Event, SpotStateEvent } from './types.js';
-import '@pear-protocol/types';
-import '../bybit/types.js';
-import '../okx/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

@@ -1,104 +0,0 @@
-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
-  };
-}
-
-export { HyperliquidStateHandler, buildTrackedAssetInfo };

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

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

package/dist/account/exchanges/index.js

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

package/dist/account/exchanges/okx/asset-tracker.d.ts

@@ -1,26 +0,0 @@
-import { OkxCredentialsDTO } from '@pear-protocol/types';
-import { S as StateUpdate, h as TrackedAssetInfo } from '../../../types-Caz2X4h0.js';
-import '../bybit/types.js';
-import '../hyperliquid/types.js';
-import './types.js';
-
-type OnStateUpdate = (update: StateUpdate) => void;
-type OnError = (error: Error) => void;
-declare class OkxAssetTracker {
-    private onStateUpdate;
-    private onError;
-    private getCreds;
-    private getDemo;
-    private trackedAssetInfos;
-    constructor(deps: {
-        onStateUpdate: OnStateUpdate;
-        onError: OnError;
-        getCreds: () => OkxCredentialsDTO;
-        getDemo: () => boolean;
-    });
-    getInfos(): Map<string, TrackedAssetInfo>;
-    onAssetTracked(instId: string): void;
-    onAssetUntracked(instId: string): void;
-}
-
-export { OkxAssetTracker };

package/dist/account/exchanges/okx/asset-tracker.js

@@ -1,34 +0,0 @@
-import { fetchLeverageInfo } from './rest';
-
-class OkxAssetTracker {
-  onStateUpdate;
-  onError;
-  getCreds;
-  getDemo;
-  trackedAssetInfos = /* @__PURE__ */ new Map();
-  constructor(deps) {
-    this.onStateUpdate = deps.onStateUpdate;
-    this.onError = deps.onError;
-    this.getCreds = deps.getCreds;
-    this.getDemo = deps.getDemo;
-  }
-  getInfos() {
-    return this.trackedAssetInfos;
-  }
-  onAssetTracked(instId) {
-    fetchLeverageInfo(this.getCreds(), instId, this.getDemo()).then((info) => {
-      const leverage = info?.lever || "0";
-      const marginType = info?.mgnMode;
-      const trackedAssetInfo = { coin: instId, leverage, marginType };
-      this.trackedAssetInfos.set(instId, trackedAssetInfo);
-      const trackedAssets = /* @__PURE__ */ new Map([[instId, trackedAssetInfo]]);
-      this.onStateUpdate({ trackedAssets });
-    }).catch((err) => this.onError(err instanceof Error ? err : new Error(String(err))));
-  }
-  onAssetUntracked(instId) {
-    this.trackedAssetInfos.delete(instId);
-    this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
-  }
-}
-
-export { OkxAssetTracker };

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

@@ -1,7 +0,0 @@
-declare const REST_BASE_URL = "https://www.okx.com";
-declare const WS_PRIVATE_URL = "wss://ws.okx.com:8443/ws/v5/private";
-declare const WS_PRIVATE_URL_DEMO = "wss://wspap.okx.com:8443/ws/v5/private?brokerId=9999";
-declare const DEFAULT_PING_INTERVAL_MS = 25000;
-declare const LOGIN_TIMEOUT_MS = 10000;
-
-export { DEFAULT_PING_INTERVAL_MS, LOGIN_TIMEOUT_MS, REST_BASE_URL, WS_PRIVATE_URL, WS_PRIVATE_URL_DEMO };

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

@@ -1,7 +0,0 @@
-const REST_BASE_URL = "https://www.okx.com";
-const WS_PRIVATE_URL = "wss://ws.okx.com:8443/ws/v5/private";
-const WS_PRIVATE_URL_DEMO = "wss://wspap.okx.com:8443/ws/v5/private?brokerId=9999";
-const DEFAULT_PING_INTERVAL_MS = 25e3;
-const LOGIN_TIMEOUT_MS = 1e4;
-
-export { DEFAULT_PING_INTERVAL_MS, LOGIN_TIMEOUT_MS, REST_BASE_URL, WS_PRIVATE_URL, WS_PRIVATE_URL_DEMO };

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

@@ -1,22 +0,0 @@
-import { g as SupportedCredentials } from '../../../types-Caz2X4h0.js';
-import { BaseOrchestrator, OrchestratorConfig } from '../base.js';
-import '@pear-protocol/types';
-import '../bybit/types.js';
-import '../hyperliquid/types.js';
-import './types.js';
-
-declare class OkxOrchestrator extends BaseOrchestrator {
-    private ws;
-    private creds;
-    private stateHandler;
-    private assetTracker;
-    constructor(config: OrchestratorConfig, credentials: SupportedCredentials);
-    protected initAsync(): Promise<void>;
-    protected cleanupConnections(): void;
-    stop(): Promise<void>;
-    get isConnected(): boolean;
-    onAssetTracked(coin: string): void;
-    onAssetUntracked(coin: string): void;
-}
-
-export { OkxOrchestrator };

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

@@ -1,57 +0,0 @@
-import { BaseOrchestrator } from '../base';
-import { OkxAssetTracker } from './asset-tracker';
-import { acctLvToAccountType } from './mapper';
-import { fetchAccountConfig, fetchBalance, fetchPositions } from './rest';
-import { OkxStateHandler } from './state-handler';
-import { OkxWs } from './ws';
-
-class OkxOrchestrator extends BaseOrchestrator {
-  ws = null;
-  creds;
-  stateHandler;
-  assetTracker;
-  constructor(config, credentials) {
-    super(config);
-    this.credentials = credentials;
-    this.creds = credentials;
-    this.assetTracker = new OkxAssetTracker({
-      onStateUpdate: (update) => this.onStateUpdate(update),
-      onError: (err) => this.onError(err),
-      getCreds: () => this.creds,
-      getDemo: () => this.demo
-    });
-    this.stateHandler = new OkxStateHandler({
-      onStateUpdate: (update) => this.onStateUpdate(update),
-      getTrackedAssetInfos: () => this.assetTracker.getInfos()
-    });
-  }
-  async initAsync() {
-    const [config, balance, positions] = await Promise.all([
-      fetchAccountConfig(this.creds, this.demo),
-      fetchBalance(this.creds, this.demo),
-      fetchPositions(this.creds, this.demo)
-    ]);
-    this.stateHandler.setAccountType(acctLvToAccountType(config.acctLv));
-    this.stateHandler.handleInitialData(balance, positions);
-    this.ws = new OkxWs({ onMessage: (msg) => this.stateHandler.handleMessage(msg) }, this.demo);
-    await this.ws.connect(this.creds);
-  }
-  cleanupConnections() {
-    this.ws?.close();
-  }
-  async stop() {
-    this.stopped = true;
-    this.cleanupConnections();
-  }
-  get isConnected() {
-    return this.ws?.isConnected ?? false;
-  }
-  onAssetTracked(coin) {
-    this.assetTracker.onAssetTracked(coin);
-  }
-  onAssetUntracked(coin) {
-    this.assetTracker.onAssetUntracked(coin);
-  }
-}
-
-export { OkxOrchestrator };