@pear-protocol/exchanges-sdk 0.0.1

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

@@ -0,0 +1,7 @@
+declare const BASE_URL = "https://api.bybit.com";
+declare const BASE_URL_DEMO = "https://api-demo.bybit.com";
+declare const WS_URL = "wss://stream.bybit.com/v5/private";
+declare const WS_URL_DEMO = "wss://stream-demo.bybit.com/v5/private";
+declare const DEFAULT_PING_INTERVAL_MS = 20000;
+
+export { BASE_URL, BASE_URL_DEMO, DEFAULT_PING_INTERVAL_MS, WS_URL, WS_URL_DEMO };

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

@@ -0,0 +1,7 @@
+const BASE_URL = "https://api.bybit.com";
+const BASE_URL_DEMO = "https://api-demo.bybit.com";
+const WS_URL = "wss://stream.bybit.com/v5/private";
+const WS_URL_DEMO = "wss://stream-demo.bybit.com/v5/private";
+const DEFAULT_PING_INTERVAL_MS = 2e4;
+
+export { BASE_URL, BASE_URL_DEMO, DEFAULT_PING_INTERVAL_MS, WS_URL, WS_URL_DEMO };

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

@@ -0,0 +1,11 @@
+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 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>;
+declare function mapPositionUpdates(raw: BybitRawPosition[]): Map<string, AccountPosition>;
+
+export { buildBalance, mapPositionUpdates, mapPositions, mapSinglePosition, mergeRawCoins };

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

@@ -0,0 +1,106 @@
+import '../../types';
+import { positionKey } from '../../utils';
+
+function buildBalance(raw, coins, marginMode, collateralRatios) {
+  const free = {};
+  const used = {};
+  const total = {};
+  const assets = [];
+  const isPortfolio = marginMode === "portfolio";
+  for (const [, c] of coins) {
+    const equity = c.equity ?? "0";
+    const positionInitialMargin = c.totalPositionIM === "" ? "0" : c.totalPositionIM ?? "0";
+    const orderInitialMargin = c.totalOrderIM === "" ? "0" : c.totalOrderIM ?? "0";
+    const positionMaintenanceMargin = c.totalPositionMM === "" ? "0" : c.totalPositionMM ?? "0";
+    const locked = c.locked ?? "0";
+    const equityNum = parseFloat(equity);
+    const positionInitialMarginNum = parseFloat(positionInitialMargin);
+    const orderInitialMarginNum = parseFloat(orderInitialMargin);
+    const lockedNum = parseFloat(locked);
+    if (equityNum === 0 && parseFloat(c.walletBalance ?? "0") === 0) continue;
+    let coinFree;
+    let coinUsed;
+    if (isPortfolio) {
+      coinFree = (equityNum - lockedNum).toString();
+      coinUsed = "0";
+    } else {
+      coinFree = (equityNum - positionInitialMarginNum - orderInitialMarginNum - lockedNum).toString();
+      coinUsed = (positionInitialMarginNum + orderInitialMarginNum).toString();
+    }
+    free[c.coin] = coinFree;
+    used[c.coin] = coinUsed;
+    total[c.coin] = equity;
+    assets.push({
+      asset: c.coin,
+      free: coinFree,
+      used: coinUsed,
+      total: equity,
+      walletBalance: c.walletBalance ?? "0",
+      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"
+    });
+  }
+  return {
+    exchange: "bybit",
+    accountType: "UNIFIED",
+    marginMode,
+    free,
+    used,
+    total,
+    availableToTrade: raw.totalAvailableBalance ?? "0",
+    totalEquity: raw.totalEquity ?? "0",
+    walletBalance: raw.totalWalletBalance ?? "0",
+    unrealizedPnl: raw.totalPerpUPL ?? "0",
+    initialMarginUsed: raw.totalInitialMargin ?? "0",
+    maintenanceMargin: raw.totalMaintenanceMargin ?? "0",
+    marginRatio: raw.accountMMRate ?? "0.0000",
+    assets,
+    timestamp: Date.now()
+  };
+}
+function mergeRawCoins(existing, incoming) {
+  const merged = new Map(existing);
+  for (const c of incoming) {
+    merged.set(c.coin, c);
+  }
+  return merged;
+}
+function mapSinglePosition(p, size) {
+  const side = p.side === "Buy" ? "long" : p.side === "Sell" ? "short" : "both";
+  return {
+    symbol: p.symbol ?? "",
+    side,
+    size: size === "0" || size === "" ? "0" : side === "short" ? `-${size}` : size,
+    entryPrice: p.avgPrice ?? "0",
+    unrealizedPnl: p.unrealisedPnl ?? "0",
+    leverage: p.leverage ?? "0",
+    marginType: p.tradeMode === "1" ? "isolated" : "cross",
+    liquidationPrice: p.liqPrice || null
+  };
+}
+function mapPositions(raw) {
+  const positions = /* @__PURE__ */ new Map();
+  for (const p of raw) {
+    const size = p.size ?? "0";
+    if (size === "0" || size === "") continue;
+    const mapped = mapSinglePosition(p, size);
+    positions.set(positionKey(mapped.symbol, mapped.side), mapped);
+  }
+  return positions;
+}
+function mapPositionUpdates(raw) {
+  const positions = /* @__PURE__ */ new Map();
+  for (const p of raw) {
+    const size = p.size ?? "0";
+    const mapped = mapSinglePosition(p, size);
+    positions.set(positionKey(mapped.symbol, mapped.side), mapped);
+  }
+  return positions;
+}
+
+export { buildBalance, mapPositionUpdates, mapPositions, mapSinglePosition, mergeRawCoins };

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

@@ -0,0 +1,23 @@
+import { SupportedCredentials } from '../../types.js';
+import { BaseOrchestrator } from '../base.js';
+import '@pear-protocol/types';
+
+declare class BybitOrchestrator extends BaseOrchestrator {
+    private ws;
+    private rawCoins;
+    private lastWallet;
+    private trackedAssetInfos;
+    private marginMode;
+    private collateralRatios;
+    start(credentials: SupportedCredentials): Promise<void>;
+    stop(): void;
+    get isConnected(): boolean;
+    onAssetTracked(coin: string): void;
+    onAssetUntracked(coin: string): void;
+    setLeverage(symbol: string, leverage: string): Promise<void>;
+    private stopAll;
+    private handleMessage;
+    private handleWalletUpdate;
+}
+
+export { BybitOrchestrator };

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

@@ -0,0 +1,159 @@
+import { BaseOrchestrator } from '../base';
+import { mergeRawCoins, buildBalance, mapPositions, mapPositionUpdates } from './mapper';
+import { fetchWalletBalance, fetchPositions, fetchAccountInfo, fetchCollateralRatios, fetchPositionLeverage, setLeverage } from './rest';
+import { BybitWs } from './ws';
+
+class BybitOrchestrator extends BaseOrchestrator {
+  ws = null;
+  rawCoins = /* @__PURE__ */ new Map();
+  lastWallet = null;
+  trackedAssetInfos = /* @__PURE__ */ new Map();
+  marginMode = "cross";
+  collateralRatios = /* @__PURE__ */ new Map();
+  async start(credentials) {
+    const gen = ++this.startGeneration;
+    this.manualClose = false;
+    this.credentials = credentials;
+    const creds = credentials;
+    this.stopAll();
+    try {
+      const [wallet, positions, accountInfo, ratios] = await Promise.all([
+        fetchWalletBalance(creds, this.demo),
+        fetchPositions(creds, this.demo),
+        fetchAccountInfo(creds, this.demo),
+        fetchCollateralRatios(creds, this.demo)
+      ]);
+      if (gen !== this.startGeneration) return;
+      const MARGIN_MODE_MAP = {
+        ISOLATED_MARGIN: "isolated",
+        PORTFOLIO_MARGIN: "portfolio",
+        REGULAR_MARGIN: "cross"
+      };
+      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)
+        });
+      }
+      this.onStateUpdate({ positions: mapPositions(positions) });
+      this.ws = new BybitWs(
+        {
+          onMessage: (topic, data) => this.handleMessage(topic, data),
+          onClose: () => {
+            if (!this.manualClose) {
+              this.stopAll();
+              this.scheduleReconnect();
+            }
+          }
+        },
+        this.demo
+      );
+      await this.ws.connect(creds);
+      this.reconnectAttempts = 0;
+    } catch (err) {
+      if (gen !== this.startGeneration) return;
+      this.stopAll();
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+      this.scheduleReconnect();
+    }
+  }
+  stop() {
+    this.manualClose = true;
+    this.stopAll();
+    this.rawCoins.clear();
+    this.lastWallet = null;
+    this.trackedAssetInfos.clear();
+    this.collateralRatios.clear();
+    this.marginMode = "cross";
+    this.credentials = null;
+  }
+  get isConnected() {
+    return this.ws?.isConnected ?? false;
+  }
+  onAssetTracked(coin) {
+    const creds = this.credentials;
+    if (!creds) return;
+    fetchPositionLeverage(creds, coin, this.demo).then((pos) => {
+      const leverage = pos?.leverage || "1";
+      const marginType = pos?.tradeMode === "1" ? "isolated" : "cross";
+      const info = {
+        coin,
+        leverage,
+        marginType,
+        availableToTrade: null,
+        maxTradeSzs: null,
+        collateralToken: null
+      };
+      this.trackedAssetInfos.set(coin, info);
+      const trackedAssets = /* @__PURE__ */ new Map();
+      trackedAssets.set(coin, info);
+      this.onStateUpdate({ trackedAssets });
+    }).catch((err) => {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    });
+  }
+  onAssetUntracked(coin) {
+    this.trackedAssetInfos.delete(coin);
+    this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
+  }
+  async setLeverage(symbol, leverage) {
+    const creds = this.credentials;
+    if (!creds) throw new Error("Not connected");
+    await setLeverage(creds, symbol, leverage, this.demo);
+  }
+  stopAll() {
+    this.clearReconnectTimer();
+    this.ws?.close();
+    this.ws = null;
+  }
+  handleMessage(topic, data) {
+    if (topic === "wallet") {
+      const wallet = data[0];
+      if (wallet) this.handleWalletUpdate(wallet);
+    } else if (topic === "position") {
+      const rawPositions = data;
+      const positions = mapPositionUpdates(rawPositions);
+      if (positions.size > 0) {
+        const trackedAssets = /* @__PURE__ */ new Map();
+        for (const pos of rawPositions) {
+          const existing = this.trackedAssetInfos.get(pos.symbol);
+          if (existing) {
+            const leverage = pos.leverage || existing.leverage;
+            const marginType = pos.tradeMode === "1" ? "isolated" : "cross";
+            const updated = { ...existing, leverage, marginType };
+            this.trackedAssetInfos.set(pos.symbol, updated);
+            trackedAssets.set(pos.symbol, updated);
+          }
+        }
+        this.onStateUpdate({
+          positions,
+          ...trackedAssets.size > 0 ? { trackedAssets } : {}
+        });
+      }
+    }
+  }
+  handleWalletUpdate(raw) {
+    this.rawCoins = mergeRawCoins(this.rawCoins, raw.coin ?? []);
+    const merged = this.lastWallet ? {
+      totalEquity: raw.totalEquity || this.lastWallet.totalEquity,
+      totalWalletBalance: raw.totalWalletBalance || this.lastWallet.totalWalletBalance,
+      totalMarginBalance: raw.totalMarginBalance || this.lastWallet.totalMarginBalance,
+      totalAvailableBalance: raw.totalAvailableBalance || this.lastWallet.totalAvailableBalance,
+      totalPerpUPL: raw.totalPerpUPL || this.lastWallet.totalPerpUPL,
+      totalInitialMargin: raw.totalInitialMargin || this.lastWallet.totalInitialMargin,
+      totalMaintenanceMargin: raw.totalMaintenanceMargin || this.lastWallet.totalMaintenanceMargin,
+      accountMMRate: raw.accountMMRate || this.lastWallet.accountMMRate,
+      coin: raw.coin ?? this.lastWallet.coin
+    } : raw;
+    this.lastWallet = merged;
+    this.onStateUpdate({
+      balance: buildBalance(merged, this.rawCoins, this.marginMode, this.collateralRatios)
+    });
+  }
+}
+
+export { BybitOrchestrator };

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

@@ -0,0 +1,11 @@
+import { BybitCredentialsDTO } from '@pear-protocol/types';
+import { BybitRawAccountInfo, BybitRawPosition, BybitRawWallet } from './types.js';
+
+declare function fetchWalletBalance(creds: BybitCredentialsDTO, demo: boolean): Promise<BybitRawWallet | undefined>;
+declare function fetchPositions(creds: BybitCredentialsDTO, demo: boolean): Promise<BybitRawPosition[]>;
+declare function fetchPositionLeverage(creds: BybitCredentialsDTO, symbol: string, demo: boolean): Promise<BybitRawPosition | undefined>;
+declare function setLeverage(creds: BybitCredentialsDTO, symbol: string, leverage: string, demo: boolean): Promise<void>;
+declare function fetchAccountInfo(creds: BybitCredentialsDTO, demo: boolean): Promise<BybitRawAccountInfo>;
+declare function fetchCollateralRatios(creds: BybitCredentialsDTO, demo: boolean): Promise<Map<string, string>>;
+
+export { fetchAccountInfo, fetchCollateralRatios, fetchPositionLeverage, fetchPositions, fetchWalletBalance, setLeverage };

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

@@ -0,0 +1,110 @@
+import { hmacSha256Hex } from '../../../utils/hmac';
+import { BASE_URL_DEMO, BASE_URL } from './const';
+
+async function signedPost(creds, path, body, demo) {
+  const baseUrl = demo ? BASE_URL_DEMO : BASE_URL;
+  const timestamp = Date.now().toString();
+  const recvWindow = "5000";
+  const bodyStr = JSON.stringify(body);
+  const signPayload = `${timestamp}${creds.api_key}${recvWindow}${bodyStr}`;
+  const signature = await hmacSha256Hex(creds.api_secret, signPayload);
+  const response = await fetch(`${baseUrl}${path}`, {
+    method: "POST",
+    headers: {
+      "X-BAPI-API-KEY": creds.api_key,
+      "X-BAPI-SIGN": signature,
+      "X-BAPI-TIMESTAMP": timestamp,
+      "X-BAPI-RECV-WINDOW": recvWindow,
+      "Content-Type": "application/json"
+    },
+    body: bodyStr
+  });
+  if (!response.ok) {
+    throw new Error(`Bybit API error: ${response.status} ${response.statusText}`);
+  }
+  const result = await response.json();
+  if (result.retCode !== 0) {
+    throw new Error(`Bybit API error: ${result.retCode} ${result.retMsg}`);
+  }
+  return result.result;
+}
+async function signedGet(creds, path, params, demo) {
+  const baseUrl = demo ? BASE_URL_DEMO : BASE_URL;
+  const timestamp = Date.now().toString();
+  const recvWindow = "5000";
+  const queryString = new URLSearchParams(params).toString();
+  const signPayload = `${timestamp}${creds.api_key}${recvWindow}${queryString}`;
+  const signature = await hmacSha256Hex(creds.api_secret, signPayload);
+  const response = await fetch(`${baseUrl}${path}?${queryString}`, {
+    headers: {
+      "X-BAPI-API-KEY": creds.api_key,
+      "X-BAPI-SIGN": signature,
+      "X-BAPI-TIMESTAMP": timestamp,
+      "X-BAPI-RECV-WINDOW": recvWindow
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Bybit API error: ${response.status} ${response.statusText}`);
+  }
+  const body = await response.json();
+  if (body.retCode !== 0) {
+    throw new Error(`Bybit API error: ${body.retCode} ${body.retMsg}`);
+  }
+  return body.result;
+}
+async function fetchWalletBalance(creds, demo) {
+  const result = await signedGet(
+    creds,
+    "/v5/account/wallet-balance",
+    { accountType: "UNIFIED" },
+    demo
+  );
+  return result.list[0];
+}
+async function fetchPositions(creds, demo) {
+  const result = await signedGet(
+    creds,
+    "/v5/position/list",
+    { category: "linear", settleCoin: "USDT" },
+    demo
+  );
+  return result.list;
+}
+async function fetchPositionLeverage(creds, symbol, demo) {
+  const result = await signedGet(
+    creds,
+    "/v5/position/list",
+    { category: "linear", symbol },
+    demo
+  );
+  return result.list[0];
+}
+async function setLeverage(creds, symbol, leverage, demo) {
+  await signedPost(
+    creds,
+    "/v5/position/set-leverage",
+    { category: "linear", symbol, buyLeverage: leverage, sellLeverage: leverage },
+    demo
+  );
+}
+async function fetchAccountInfo(creds, demo) {
+  return signedGet(creds, "/v5/account/account-info", {}, demo);
+}
+async function fetchCollateralRatios(creds, demo) {
+  const result = await signedGet(
+    creds,
+    "/v5/spot-margin-uta/tier-collateral-ratio",
+    {},
+    demo
+  );
+  const ratios = /* @__PURE__ */ new Map();
+  for (const entry of result ?? []) {
+    const first = entry.tiers?.[0];
+    if (first) {
+      ratios.set(entry.currency, first.rate);
+    }
+  }
+  return ratios;
+}
+
+export { fetchAccountInfo, fetchCollateralRatios, fetchPositionLeverage, fetchPositions, fetchWalletBalance, setLeverage };

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

@@ -0,0 +1,59 @@
+interface BybitRawCoin {
+    coin: string;
+    equity: string;
+    usdValue: string;
+    walletBalance: string;
+    unrealisedPnl: string;
+    totalPositionIM: string;
+    totalPositionMM: string;
+    totalOrderIM: string;
+    locked: string;
+    borrowAmount: string;
+    marginCollateral: boolean;
+    collateralSwitch: boolean;
+}
+interface BybitRawWallet {
+    totalEquity: string;
+    totalWalletBalance: string;
+    totalMarginBalance: string;
+    totalAvailableBalance: string;
+    totalPerpUPL: string;
+    totalInitialMargin: string;
+    totalMaintenanceMargin: string;
+    accountMMRate: string;
+    coin: BybitRawCoin[];
+}
+interface BybitRawAccountInfo {
+    marginMode: string;
+    updatedTime: string;
+}
+interface BybitRawCollateralTier {
+    collateralCoin: string;
+    rate: string;
+    collateralAmount: string;
+}
+interface BybitRawCollateralRatioEntry {
+    currency: string;
+    tiers: BybitRawCollateralTier[];
+}
+interface BybitRawPosition {
+    symbol: string;
+    side: string;
+    size: string;
+    avgPrice: string;
+    unrealisedPnl: string;
+    leverage: string;
+    tradeMode: string;
+    liqPrice: string;
+}
+interface BybitResponse<T> {
+    retCode: number;
+    retMsg: string;
+    result: T;
+}
+interface BybitWsHandlers {
+    onMessage: (topic: string, data: unknown[]) => void;
+    onClose: () => void;
+}
+
+export type { BybitRawAccountInfo, BybitRawCoin, BybitRawCollateralRatioEntry, BybitRawCollateralTier, BybitRawPosition, BybitRawWallet, BybitResponse, BybitWsHandlers };

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,18 @@
+import { BybitCredentialsDTO } from '@pear-protocol/types';
+import { BybitWsHandlers } from './types.js';
+
+declare class BybitWs {
+    private ws;
+    private pingTimer;
+    private handlers;
+    private demo;
+    private readonly pingIntervalMs;
+    constructor(handlers: BybitWsHandlers, demo: boolean, pingIntervalMs?: number);
+    connect(creds: BybitCredentialsDTO): Promise<void>;
+    close(): void;
+    get isConnected(): boolean;
+    private clearPing;
+    private authenticate;
+}
+
+export { BybitWs };

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

@@ -0,0 +1,74 @@
+import { hmacSha256Hex } from '../../../utils/hmac';
+import { connectWs, sendWs, clearIntervalTimer } from '../../../utils/ws';
+import { DEFAULT_PING_INTERVAL_MS, WS_URL_DEMO, WS_URL } from './const';
+
+class BybitWs {
+  ws = null;
+  pingTimer = null;
+  handlers;
+  demo;
+  pingIntervalMs;
+  constructor(handlers, demo, pingIntervalMs = DEFAULT_PING_INTERVAL_MS) {
+    this.handlers = handlers;
+    this.demo = demo;
+    this.pingIntervalMs = pingIntervalMs;
+  }
+  async connect(creds) {
+    this.ws = await connectWs(this.demo ? WS_URL_DEMO : WS_URL);
+    this.ws.onclose = () => {
+      this.clearPing();
+      this.handlers.onClose();
+    };
+    this.ws.onerror = () => {
+    };
+    this.ws.addEventListener("message", (event) => {
+      try {
+        const msg = JSON.parse(event.data);
+        if (msg.topic && msg.data) {
+          this.handlers.onMessage(msg.topic, msg.data);
+        }
+      } catch {
+      }
+    });
+    await this.authenticate(creds);
+    sendWs(this.ws, { op: "subscribe", args: ["wallet", "position", "execution"] });
+    this.pingTimer = setInterval(() => sendWs(this.ws, { op: "ping" }), this.pingIntervalMs);
+  }
+  close() {
+    this.clearPing();
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  get isConnected() {
+    return this.ws?.readyState === WebSocket.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/index.d.ts

@@ -0,0 +1,8 @@
+import { Connector } from '@pear-protocol/types';
+import { OrchestratorConfig, BaseOrchestrator } from './base.js';
+export { Orchestrator } from './base.js';
+import '../types.js';
+
+declare function createOrchestrator(exchange: Connector, config: OrchestratorConfig): BaseOrchestrator;
+
+export { OrchestratorConfig, createOrchestrator };

package/dist/account/exchanges/index.js

@@ -0,0 +1,16 @@
+import './base';
+import { BinanceOrchestrator } from './binance/orchestrator';
+import { BybitOrchestrator } from './bybit/orchestrator';
+
+function createOrchestrator(exchange, config) {
+  switch (exchange) {
+    case "binanceusdm":
+      return new BinanceOrchestrator(config);
+    case "bybit":
+      return new BybitOrchestrator(config);
+    default:
+      throw new Error(`Unsupported exchange: ${exchange}`);
+  }
+}
+
+export { createOrchestrator };

package/dist/account/index.d.ts

@@ -0,0 +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 { Orchestrator, OrchestratorConfig } from './exchanges/base.js';
+import '@pear-protocol/types';
+import '../credentials.js';
+import '@pear-protocol/core-sdk';

package/dist/account/index.js

@@ -0,0 +1,4 @@
+export * from './account-manager';
+export * from './exchange-account';
+export * from './exchanges';
+export * from './types';