@pear-protocol/exchanges-sdk 0.21.0 → 0.22.0

package/dist/syncer/base.js

@@ -1,241 +0,0 @@
-import { computePositionEntryPrices, abs, isZero, add, multiply, divide, computeSyncPayload } from '@pear-protocol/utils';
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-const OVERLAP_MS = 6e4;
-class BaseAccountSyncer {
-  static {
-    __name(this, "BaseAccountSyncer");
-  }
-  sdk;
-  connector;
-  account;
-  credentials;
-  demo;
-  throttle;
-  constructor(config) {
-    this.sdk = config.sdk;
-    this.connector = config.connector;
-    this.account = config.account;
-    this.credentials = config.credentials;
-    this.demo = config.demo;
-    this.throttle = config.throttle;
-  }
-  // Phase A: Load current Pear state (positions, fills, instruments, watermark).
-  async loadPearState() {
-    const watermark = await this.sdk.core.sync.fills.since({
-      overlapMs: OVERLAP_MS
-    });
-    const [{ positions: openPositions }, { fills: provisionalFills }, { instruments }] = await Promise.all([
-      this.sdk.core.positions.openLite(),
-      this.sdk.core.fills.provisionals(),
-      this.sdk.core.instruments.lite({
-        connector: this.connector
-      })
-    ]);
-    const entryBySymbol = await this.loadEntryBySymbol(openPositions);
-    return {
-      openPositions,
-      entryBySymbol,
-      provisionalFills,
-      instruments,
-      watermark
-    };
-  }
-  /**
-  * Global per-symbol cost-basis entry of existing open positions, derived from each
-  * position's assigned ledger and remaining exposure. One call per open position today —
-  * can collapse to a single endpoint later.
-  */
-  async loadEntryBySymbol(openPositions) {
-    const states = await Promise.all(openPositions.map(async (position) => {
-      const { fills } = await this.sdk.core.fills.details(position.id);
-      fills.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-      return {
-        exposure: position.exposure,
-        entryPrices: computePositionEntryPrices(position.exposure, fills)
-      };
-    }));
-    const totals = /* @__PURE__ */ new Map();
-    for (const state of states) {
-      for (const [symbol, signedQuantity] of Object.entries(state.exposure)) {
-        const quantity = abs(signedQuantity);
-        if (isZero(quantity)) {
-          continue;
-        }
-        const entry = state.entryPrices[symbol];
-        const existing = totals.get(symbol);
-        totals.set(symbol, {
-          quantity: add(existing?.quantity ?? "0", quantity).toFixed(),
-          notional: add(existing?.notional ?? "0", multiply(quantity, entry ?? "0")).toFixed(),
-          unpriced: existing?.unpriced === true || entry === void 0
-        });
-      }
-    }
-    const entryBySymbol = {};
-    for (const [symbol, total] of totals) {
-      if (!total.unpriced) {
-        entryBySymbol[symbol] = divide(total.notional, total.quantity).toFixed();
-      }
-    }
-    return entryBySymbol;
-  }
-  // Phase B: Snapshot the exchange — fetch positions and fills since the watermark.
-  async snapshotExchange(state) {
-    const { openPositions, provisionalFills, instruments, watermark } = state;
-    const { firstSyncStartedAt } = watermark;
-    const externalFills = await this.listExternalFills({
-      since: new Date(watermark.sinceMs),
-      instruments,
-      openPositions,
-      provisionalFills
-    });
-    const exchangePositions = await this.listExternalPositions({
-      instruments
-    });
-    return {
-      exchangePositions,
-      externalFills,
-      firstSyncStartedAt
-    };
-  }
-  // Phase C: Compute the sync payload and post the applicables to the create endpoint.
-  async computeAndPostSync(state, snapshot) {
-    const { openPositions, entryBySymbol, provisionalFills, watermark } = state;
-    const { exchangePositions, externalFills, firstSyncStartedAt } = snapshot;
-    let payload = await computeSyncPayload({
-      tradeAccountId: this.account.id,
-      connector: this.connector,
-      openPositions,
-      entryBySymbol,
-      provisionalFills,
-      confirmedExchangeFillIds: watermark.confirmedExchangeFillIds ?? [],
-      externalFills,
-      exchangePositions,
-      neverSynced: watermark.neverSynced
-    });
-    if (!payload) {
-      if (watermark.hasPendingSynthetics !== true) {
-        return;
-      }
-      payload = {
-        fills: [],
-        applicables: [],
-        exchangePositions,
-        meta: {
-          externalMaxTs: null
-        },
-        firstSyncTrim: null
-      };
-    }
-    const { firstSyncTrim } = payload;
-    let meta = {
-      ...payload.meta,
-      ...payload.meta.externalMaxTs === null ? {} : {
-        newestFillTs: payload.meta.externalMaxTs
-      },
-      ...firstSyncStartedAt === void 0 ? {} : {
-        firstSyncStartedAt
-      },
-      // Core defers the create when any execution write postdates this server-minted token.
-      executionsUpdatedAtEpochMs: watermark.executionsUpdatedAtEpochMs
-    };
-    if (firstSyncTrim) {
-      console.log(`${this.connector}: first-sync trim \u2014 dropped ${firstSyncTrim.trimmedCount} pre-cutoff fills (cutoffTs=${firstSyncTrim.cutoffTs})`);
-      if (meta.externalMaxTs !== null && firstSyncTrim.trimmedMaxTs >= meta.externalMaxTs - OVERLAP_MS) {
-        meta = {
-          ...meta,
-          externalMaxTs: meta.externalMaxTs + OVERLAP_MS + 1
-        };
-      }
-    }
-    const createBody = {
-      fills: payload.fills,
-      applicables: payload.applicables,
-      exchangePositions: payload.exchangePositions,
-      meta
-    };
-    const createBytes = new Blob([
-      JSON.stringify(createBody)
-    ]).size;
-    if (createBytes > 50 * 1024) {
-      await this.sdk.core.sync.fills.createBulk(createBody);
-    } else {
-      await this.sdk.core.sync.fills.create(createBody);
-    }
-  }
-  /**
-  * Pull historical funding payments since the funding watermark and post them.
-  * Independent of the fill sync cycle (`synchronizeFills`) — funding rows are
-  * immutable and upsert idempotently, so this is driven on its own cadence.
-  */
-  async synchronizeFunding() {
-    const [{ instruments }, watermark] = await Promise.all([
-      this.sdk.core.instruments.lite({
-        connector: this.connector
-      }),
-      this.sdk.core.sync.funding.since({
-        overlapMs: 6e4
-      })
-    ]);
-    let payments;
-    try {
-      payments = await this.listExternalFunding({
-        since: new Date(watermark.sinceMs),
-        instruments
-      });
-    } catch (error) {
-      console.error(`${this.connector}: funding fetch failed \u2014 funding sync aborted, retry next tick`, error);
-      return "aborted";
-    }
-    if (payments.length === 0) {
-      return "synced";
-    }
-    const externalMaxTs = Math.max(...payments.map((payment) => payment.timestamp));
-    const createBody = {
-      payments,
-      meta: {
-        externalMaxTs
-      }
-    };
-    const bytes = new Blob([
-      JSON.stringify(createBody)
-    ]).size;
-    if (bytes > 50 * 1024) {
-      await this.sdk.core.sync.funding.createBulk(createBody);
-      return "synced";
-    }
-    await this.sdk.core.sync.funding.create(createBody);
-    return "synced";
-  }
-  async synchronizeFills() {
-    const state = await this.loadPearState();
-    let snapshot;
-    try {
-      snapshot = await this.snapshotExchange(state);
-    } catch (error) {
-      console.error(`${this.connector}: position/fill fetch failed \u2014 sync cycle aborted, retry next tick`, error);
-      return "aborted";
-    }
-    try {
-      await this.computeAndPostSync(state, snapshot);
-    } catch (error) {
-      if (isSyncCreateDeferral(error)) {
-        console.log(`${this.connector}: sync cycle deferred by the server (${error.errorCode}) \u2014 retry next tick`);
-        return "deferred";
-      }
-      throw error;
-    }
-    return "synced";
-  }
-}
-function isSyncCreateDeferral(error) {
-  if (typeof error !== "object" || error === null) {
-    return false;
-  }
-  const { status, errorCode } = error;
-  return status === 409 && typeof errorCode === "string" && errorCode.startsWith("SYNC_CREATE_");
-}
-__name(isSyncCreateDeferral, "isSyncCreateDeferral");
-
-export { BaseAccountSyncer };

package/dist/syncer/binance/syncer.js

@@ -1,112 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { fetchAllPositionRisk, fetchUserTradesSince, fetchAllOrdersSince } from '../../client/binance/rest';
-import { BaseAccountSyncer } from '../base';
-import { toSignedTradeFee } from '../trade-fee';
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-class BinanceAccountSyncer extends BaseAccountSyncer {
-  static {
-    __name(this, "BinanceAccountSyncer");
-  }
-  creds;
-  constructor(config) {
-    super(config);
-    this.creds = config.credentials;
-  }
-  async listExternalPositions({ instruments }) {
-    const contractSizeByInstrumentId = new Map(instruments.map((instrument) => [
-      instrument.id,
-      instrument.precision.quantity.contractSize
-    ]));
-    const rawPositions = await fetchAllPositionRisk(this.creds, this.demo);
-    return rawPositions.reduce((positions, rawPosition) => {
-      const signedSize = new BigNumber(rawPosition.positionAmt);
-      if (signedSize.isZero()) {
-        return positions;
-      }
-      const contractSize = contractSizeByInstrumentId.get(rawPosition.symbol) ?? 1;
-      const size = signedSize.abs().times(contractSize).toFixed();
-      const side = signedSize.isGreaterThan(0) ? "BUY" : "SELL";
-      positions.push({
-        symbol: rawPosition.symbol,
-        size,
-        side,
-        entryPrice: rawPosition.entryPrice,
-        markPrice: rawPosition.markPrice
-      });
-      return positions;
-    }, []);
-  }
-  async listExternalFills({ since, instruments, openPositions, provisionalFills }) {
-    const knownInstrumentIds = new Set(instruments.map((instrument) => instrument.id));
-    const requestedInstrumentIds = this.collectRequestedInstrumentIds(openPositions, provisionalFills);
-    const instrumentIds = [
-      ...requestedInstrumentIds
-    ].filter((instrumentId) => knownInstrumentIds.has(instrumentId));
-    if (!instrumentIds.length) {
-      return [];
-    }
-    const [trades, orders] = await Promise.all([
-      fetchUserTradesSince(this.creds, instrumentIds, since, this.demo),
-      fetchAllOrdersSince(this.creds, instrumentIds, since, this.demo)
-    ]);
-    const ordersBySymbolOrderId = this.mapOrdersBySymbolOrderId(orders);
-    return trades.reduce((fills, rawFill) => {
-      if (!requestedInstrumentIds.has(rawFill.symbol)) {
-        return fills;
-      }
-      const order = ordersBySymbolOrderId.get(this.orderKey(rawFill.symbol, rawFill.orderId));
-      fills.push({
-        connector: "binance",
-        exchangeFillId: rawFill.id.toString(),
-        cloid: order?.clientOrderId || null,
-        symbol: rawFill.symbol,
-        price: rawFill.price,
-        quantity: rawFill.qty,
-        side: rawFill.side,
-        reduceOnly: this.isReduceOnly(rawFill),
-        timestamp: rawFill.time,
-        tradeFee: toSignedTradeFee("binance", rawFill.commission),
-        builderFee: "0",
-        liquidation: null
-      });
-      return fills;
-    }, []);
-  }
-  async listExternalFunding(_params) {
-    throw new Error("funding sync is not implemented for binance");
-  }
-  isReduceOnly(rawFill) {
-    if (rawFill.positionSide === "LONG") return rawFill.side === "SELL";
-    if (rawFill.positionSide === "SHORT") return rawFill.side === "BUY";
-    if (rawFill.positionSide === "BOTH") {
-      return !new BigNumber(rawFill.realizedPnl || 0).isZero();
-    }
-    return false;
-  }
-  collectRequestedInstrumentIds(openPositions, provisionalFills) {
-    const instrumentIds = /* @__PURE__ */ new Set();
-    for (const position of openPositions) {
-      for (const instrumentId of Object.keys(position.exposure)) {
-        instrumentIds.add(instrumentId);
-      }
-    }
-    for (const fill of provisionalFills) {
-      instrumentIds.add(fill.symbol);
-    }
-    return instrumentIds;
-  }
-  mapOrdersBySymbolOrderId(orders) {
-    const bySymbolOrderId = /* @__PURE__ */ new Map();
-    for (const order of orders) {
-      bySymbolOrderId.set(this.orderKey(order.symbol, order.orderId), order);
-    }
-    return bySymbolOrderId;
-  }
-  orderKey(symbol, orderId) {
-    return `${symbol}:${orderId}`;
-  }
-}
-
-export { BinanceAccountSyncer };

package/dist/syncer/bybit/syncer.js

@@ -1,68 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { fetchPositions, fetchExecutionsSince } from '../../client/bybit/rest';
-import { BaseAccountSyncer } from '../base';
-import { toSignedTradeFee } from '../trade-fee';
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-class BybitAccountSyncer extends BaseAccountSyncer {
-  static {
-    __name(this, "BybitAccountSyncer");
-  }
-  creds;
-  constructor(config) {
-    super(config);
-    this.creds = config.credentials;
-  }
-  async listExternalPositions({ instruments }) {
-    const rawPositions = await fetchPositions(this.creds, "USDT", this.demo);
-    const contractSizeByInstrumentId = new Map(instruments.map((instrument) => [
-      instrument.id,
-      instrument.precision.quantity.contractSize
-    ]));
-    return rawPositions.reduce((positions, rawPosition) => {
-      if (!rawPosition.size || rawPosition.size === "0" || !rawPosition.side) return positions;
-      const contractSize = contractSizeByInstrumentId.get(rawPosition.symbol) ?? 1;
-      const size = new BigNumber(rawPosition.size).abs().times(contractSize).toFixed();
-      positions.push({
-        symbol: rawPosition.symbol,
-        size,
-        side: rawPosition.side === "Buy" ? "BUY" : "SELL",
-        entryPrice: rawPosition.avgPrice,
-        markPrice: rawPosition.avgPrice
-      });
-      return positions;
-    }, []);
-  }
-  async listExternalFills({ since }) {
-    const executions = await fetchExecutionsSince(this.creds, since, this.demo);
-    return executions.reduce((fills, rawFill) => {
-      if (rawFill.execType === "Funding") {
-        return fills;
-      }
-      fills.push({
-        connector: "bybit",
-        exchangeFillId: rawFill.execId,
-        cloid: rawFill.orderLinkId || null,
-        symbol: rawFill.symbol,
-        price: rawFill.execPrice,
-        quantity: rawFill.execQty,
-        side: rawFill.side === "Buy" ? "BUY" : "SELL",
-        reduceOnly: this.isReduceOnly(rawFill),
-        timestamp: Number(rawFill.execTime),
-        tradeFee: toSignedTradeFee("bybit", rawFill.execFee),
-        builderFee: "0",
-        liquidation: null
-      });
-      return fills;
-    }, []);
-  }
-  async listExternalFunding(_params) {
-    throw new Error("funding sync is not implemented for bybit");
-  }
-  isReduceOnly(rawFill) {
-    return Number(rawFill.closedSize || "0") > 0;
-  }
-}
-
-export { BybitAccountSyncer };

package/dist/syncer/factory.js

@@ -1,33 +0,0 @@
-import { BinanceAccountSyncer } from './binance/syncer';
-import { BybitAccountSyncer } from './bybit/syncer';
-import { HyperliquidAccountSyncer } from './hyperliquid/syncer';
-import { LighterAccountSyncer } from './lighter/syncer';
-import { OkxAccountSyncer } from './okx/syncer';
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-function createAccountSyncer(exchange, config) {
-  switch (exchange) {
-    case "binance":
-      return new BinanceAccountSyncer(config);
-    case "bybit":
-      return new BybitAccountSyncer(config);
-    case "okx":
-      return new OkxAccountSyncer(config);
-    case "hyperliquid":
-      return new HyperliquidAccountSyncer(config);
-    case "lighter":
-    case "lighter_rhc":
-      return new LighterAccountSyncer({
-        ...config,
-        connector: exchange
-      });
-    default: {
-      const _exhaustive = exchange;
-      throw new Error(`Unsupported exchange: ${String(_exhaustive)}`);
-    }
-  }
-}
-__name(createAccountSyncer, "createAccountSyncer");
-
-export { createAccountSyncer };

package/dist/syncer/hyperliquid/funding.js

@@ -1,27 +0,0 @@
-import BigNumber from 'bignumber.js';
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-function toFundingPaymentEntries(events, symbolToInstrumentId) {
-  return events.reduce((entries, event) => {
-    const instrumentId = symbolToInstrumentId[event.delta.coin];
-    if (!instrumentId) {
-      console.warn(`Instrument symbol ${event.delta.coin} not found in instrument symbol to id map.`);
-      return entries;
-    }
-    const size = new BigNumber(event.delta.szi);
-    const fundingPerUnit = size.isZero() ? "0" : new BigNumber(event.delta.usdc).div(size).toFixed();
-    entries.push({
-      connector: "hyperliquid",
-      instrumentId,
-      fundingRate: event.delta.fundingRate,
-      notional: event.delta.usdc,
-      fundingPerUnit,
-      timestamp: event.time
-    });
-    return entries;
-  }, []);
-}
-__name(toFundingPaymentEntries, "toFundingPaymentEntries");
-
-export { toFundingPaymentEntries };

package/dist/syncer/hyperliquid/syncer.js

@@ -1,208 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { fetchInfo } from '../../client/hyperliquid/rest';
-import { BaseAccountSyncer } from '../base';
-import { toFundingPaymentEntries } from './funding';
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-const HYPERLIQUID_FILL_PAGE_LIMIT = 2e3;
-class HyperliquidAccountSyncer extends BaseAccountSyncer {
-  static {
-    __name(this, "HyperliquidAccountSyncer");
-  }
-  address;
-  perpDexNames;
-  constructor(config) {
-    super(config);
-    this.address = config.account.exchangeIdentifier;
-    this.perpDexNames = config.hyperliquidPerpDexNames;
-  }
-  async listExternalPositions({ instruments }) {
-    const instrumentByBase = new Map(instruments.map((instrument) => [
-      instrument.base,
-      {
-        id: instrument.id,
-        contractSize: instrument.precision.quantity.contractSize
-      }
-    ]));
-    const dexNames = this.perpDexNames ?? await this.fetchPerpDexNames();
-    const states = await Promise.all(dexNames.map((dex) => this.fetchInfoGated({
-      type: "clearinghouseState",
-      user: this.address,
-      dex
-    })));
-    const assetPositions = states.flatMap((state) => state.assetPositions);
-    return assetPositions.reduce((positions, { position: rawPosition }) => {
-      const szi = new BigNumber(rawPosition.szi);
-      if (szi.isZero()) {
-        return positions;
-      }
-      const instrument = instrumentByBase.get(rawPosition.coin);
-      if (!instrument) {
-        console.warn(`Instrument for coin ${rawPosition.coin} not found.`);
-        return positions;
-      }
-      const size = szi.abs().times(instrument.contractSize).toFixed();
-      positions.push({
-        symbol: instrument.id,
-        size,
-        side: szi.isPositive() ? "BUY" : "SELL",
-        entryPrice: rawPosition.entryPx,
-        markPrice: new BigNumber(rawPosition.positionValue).abs().div(size).toFixed()
-      });
-      return positions;
-    }, []);
-  }
-  async listExternalFills({ since, instruments }) {
-    const instrumentSymbolToIdMap = instruments.reduce((acc, instrument) => {
-      acc[instrument.base] = instrument.id;
-      return acc;
-    }, {});
-    const allFills = [];
-    const seenTids = /* @__PURE__ */ new Set();
-    const addFill = /* @__PURE__ */ __name((fill) => {
-      if (!seenTids.has(fill.tid)) {
-        seenTids.add(fill.tid);
-        allFills.push(fill);
-      }
-    }, "addFill");
-    let cursor = since.getTime();
-    let batchSize;
-    do {
-      const batch = await this.fetchInfoGated({
-        type: "userFillsByTime",
-        user: this.address,
-        startTime: cursor,
-        aggregateByTime: true
-      });
-      batchSize = batch.length;
-      for (const rawFill of batch) {
-        addFill(rawFill);
-      }
-      if (batchSize === HYPERLIQUID_FILL_PAGE_LIMIT) {
-        const nextCursor = batch[batch.length - 1]?.time ?? cursor;
-        if (nextCursor <= cursor) {
-          warnStalledPagination("fills", cursor);
-          break;
-        }
-        cursor = nextCursor;
-      }
-    } while (batchSize === HYPERLIQUID_FILL_PAGE_LIMIT);
-    cursor = since.getTime();
-    do {
-      const twapBatch = await this.fetchInfoGated({
-        type: "userTwapSliceFillsByTime",
-        user: this.address,
-        startTime: cursor,
-        aggregateByTime: true
-      });
-      batchSize = twapBatch.length;
-      for (const item of twapBatch) {
-        addFill(item.fill);
-      }
-      if (batchSize === HYPERLIQUID_FILL_PAGE_LIMIT) {
-        const nextCursor = twapBatch[twapBatch.length - 1]?.fill.time ?? cursor;
-        if (nextCursor <= cursor) {
-          warnStalledPagination("TWAP fills", cursor);
-          break;
-        }
-        cursor = nextCursor;
-      }
-    } while (batchSize === HYPERLIQUID_FILL_PAGE_LIMIT);
-    allFills.sort((a, b) => a.time - b.time);
-    return allFills.reduce((fills, rawFill) => {
-      const instrumentId = instrumentSymbolToIdMap[rawFill.coin];
-      if (!instrumentId) {
-        console.warn(`Instrument symbol ${rawFill.coin} not found in instrument symbol to id map.`);
-        return fills;
-      }
-      const tradeFee = new BigNumber(rawFill.fee).minus(rawFill.builderFee ?? "0");
-      fills.push({
-        connector: "hyperliquid",
-        exchangeFillId: rawFill.tid.toFixed(),
-        cloid: rawFill.cloid ?? null,
-        symbol: instrumentId,
-        price: rawFill.px,
-        quantity: rawFill.sz,
-        side: rawFill.side === "B" ? "BUY" : "SELL",
-        reduceOnly: this.isReduceOnly(rawFill),
-        timestamp: rawFill.time,
-        tradeFee: tradeFee.toFixed(),
-        builderFee: new BigNumber(rawFill.builderFee ?? "0").abs().toFixed(),
-        // Preserve the existing marker when attribution is absent; reject explicitly named counterparties.
-        liquidation: rawFill.liquidation && (!rawFill.liquidation.liquidatedUser || rawFill.liquidation.liquidatedUser.toLowerCase() === this.address.toLowerCase()) ? {
-          mark: rawFill.liquidation.markPx
-        } : null
-      });
-      return fills;
-    }, []);
-  }
-  async listExternalFunding({ since, instruments }) {
-    const instrumentSymbolToIdMap = instruments.reduce((acc, instrument) => {
-      acc[instrument.base] = instrument.id;
-      return acc;
-    }, {});
-    const PAGE_LIMIT = 500;
-    const allEvents = /* @__PURE__ */ new Map();
-    let cursor = since.getTime();
-    let batchSize;
-    do {
-      const batch = await this.fetchInfoGated({
-        type: "userFunding",
-        user: this.address,
-        startTime: cursor
-      });
-      batchSize = batch.length;
-      for (const event of batch) {
-        allEvents.set(`${event.time}:${event.delta.coin}:${event.hash}`, event);
-      }
-      if (batchSize === PAGE_LIMIT) {
-        const nextCursor = batch[batch.length - 1]?.time ?? cursor;
-        if (nextCursor <= cursor) {
-          warnStalledPagination("funding", cursor);
-          break;
-        }
-        cursor = nextCursor;
-      }
-    } while (batchSize === PAGE_LIMIT);
-    return toFundingPaymentEntries([
-      ...allEvents.values()
-    ], instrumentSymbolToIdMap);
-  }
-  isReduceOnly(rawFill) {
-    return rawFill.dir.includes("Close");
-  }
-  /** Fetch the perp-dex descriptors and reduce them to unique dex names ('' = the main dex). */
-  async fetchPerpDexNames() {
-    const perpDexs = await this.fetchInfoGated({
-      type: "perpDexs"
-    });
-    return [
-      ...new Set(perpDexs.map((perpDex) => perpDex?.name ?? ""))
-    ];
-  }
-  /**
-  * Route one info request through the optional throttle seam: gate before the
-  * call, report the response size after, surface a failure before it propagates.
-  */
-  async fetchInfoGated(body) {
-    if (!this.throttle) {
-      return fetchInfo(body, this.demo);
-    }
-    await this.throttle.beforeRequest(body.type);
-    try {
-      const response = await fetchInfo(body, this.demo);
-      this.throttle.afterRequest(body.type, Array.isArray(response) ? response.length : 0);
-      return response;
-    } catch (error) {
-      this.throttle.afterRequestError(body.type, error);
-      throw error;
-    }
-  }
-}
-function warnStalledPagination(stream, cursor) {
-  console.warn(`Hyperliquid ${stream} pagination stalled at timestamp ${cursor}; returned history may be incomplete.`);
-}
-__name(warnStalledPagination, "warnStalledPagination");
-
-export { HyperliquidAccountSyncer };

package/dist/syncer/index.js

@@ -1,7 +0,0 @@
-export * from './base';
-export * from './binance/syncer';
-export * from './bybit/syncer';
-export * from './factory';
-export * from './hyperliquid/syncer';
-export * from './lighter/syncer';
-export * from './okx/syncer';