@pear-protocol/exchanges-sdk 0.2.0 → 0.4.0

package/dist/syncer/base.test.js

@@ -0,0 +1,131 @@
+import { describe, afterEach, vi, it, expect } from 'vitest';
+import { BaseAccountSyncer } from './base';
+
+function extFill(overrides = {}) {
+  return {
+    exchangeFillId: "tx-default",
+    cloid: null,
+    connector: "hyperliquid",
+    symbol: "BTC",
+    price: "100",
+    quantity: "1",
+    side: "BUY",
+    reduceOnly: false,
+    timestamp: 1e3,
+    tradeFee: "0",
+    builderFee: "0",
+    liquidation: null,
+    ...overrides
+  };
+}
+function exchangePos(overrides = {}) {
+  return { symbol: "BTC", size: "1", side: "BUY", entryPrice: "100", markPrice: "100", ...overrides };
+}
+class FakeSyncer extends BaseAccountSyncer {
+  positionsFn = vi.fn();
+  fillsFn = vi.fn();
+  listExternalPositions(params) {
+    return this.positionsFn(params);
+  }
+  listExternalFills(params) {
+    return this.fillsFn(params);
+  }
+  listExternalFunding() {
+    return Promise.resolve([]);
+  }
+  isReduceOnly() {
+    return false;
+  }
+}
+function makeSyncer(args) {
+  const fills = {
+    since: vi.fn().mockResolvedValue({ sinceMs: 0, neverSynced: args.neverSynced, confirmedExchangeFillIds: [] }),
+    reconcile: vi.fn().mockResolvedValue({}),
+    confirm: vi.fn().mockResolvedValue({}),
+    create: vi.fn().mockResolvedValue({}),
+    createBulk: vi.fn().mockResolvedValue({})
+  };
+  const sync = { fills };
+  const sdk = {
+    core: {
+      positions: { openLite: vi.fn().mockResolvedValue({ positions: [] }) },
+      fills: { provisionals: vi.fn().mockResolvedValue({ fills: [] }), details: vi.fn() },
+      instruments: { list: vi.fn().mockResolvedValue({ instruments: [] }) },
+      sync
+    }
+  };
+  const config = {
+    sdk,
+    connector: "hyperliquid",
+    account: { id: "acct-1" },
+    credentials: {},
+    demo: false
+  };
+  return { syncer: new FakeSyncer(config), sync };
+}
+const NEWEST_TS = 105e4;
+function trimmableFills(btcEraTs) {
+  return [
+    extFill({ exchangeFillId: "a", symbol: "BTC", side: "BUY", quantity: "1", timestamp: btcEraTs.open }),
+    extFill({ exchangeFillId: "b", symbol: "BTC", side: "SELL", quantity: "1", timestamp: btcEraTs.close }),
+    extFill({ exchangeFillId: "e", symbol: "SOL", side: "BUY", quantity: "2", timestamp: NEWEST_TS })
+  ];
+}
+const SOL_SNAPSHOT = [exchangePos({ symbol: "SOL", size: "2" })];
+describe("BaseAccountSyncer \u2014 first-sync plumbing", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+  it("neverSynced=true: the posted snapshot is fetched AFTER the fill stream", async () => {
+    const { syncer, sync } = makeSyncer({ neverSynced: true });
+    syncer.positionsFn.mockResolvedValue(SOL_SNAPSHOT);
+    syncer.fillsFn.mockResolvedValue([
+      extFill({ exchangeFillId: "e", symbol: "SOL", side: "BUY", quantity: "2", timestamp: NEWEST_TS })
+    ]);
+    await syncer.synchronizeFills();
+    expect(syncer.positionsFn).toHaveBeenCalledTimes(1);
+    expect(syncer.fillsFn.mock.invocationCallOrder[0]).toBeLessThan(
+      syncer.positionsFn.mock.invocationCallOrder[0] ?? 0
+    );
+    expect(sync.fills.create).toHaveBeenCalledTimes(1);
+    expect(sync.fills.create.mock.calls[0]?.[0]?.exchangePositions).toBe(SOL_SNAPSHOT);
+  });
+  it("bumps the posted watermark past the overlap window when trimmed fills fall inside it", async () => {
+    const { syncer, sync } = makeSyncer({ neverSynced: true });
+    syncer.positionsFn.mockResolvedValue(SOL_SNAPSHOT);
+    syncer.fillsFn.mockResolvedValue(trimmableFills({ open: 1e6, close: NEWEST_TS - 2e4 }));
+    await syncer.synchronizeFills();
+    expect(sync.fills.create.mock.calls[0]?.[0]?.meta.externalMaxTs).toBe(NEWEST_TS + 6e4 + 1);
+  });
+  it("leaves the watermark unbumped when the trimmed era is entirely older than the overlap window", async () => {
+    const { syncer, sync } = makeSyncer({ neverSynced: true });
+    syncer.positionsFn.mockResolvedValue(SOL_SNAPSHOT);
+    syncer.fillsFn.mockResolvedValue(trimmableFills({ open: 1e5, close: 2e5 }));
+    await syncer.synchronizeFills();
+    expect(sync.fills.create.mock.calls[0]?.[0]?.meta.externalMaxTs).toBe(NEWEST_TS);
+  });
+  it("logs the trim exactly once when a trim happened", async () => {
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {
+    });
+    const { syncer } = makeSyncer({ neverSynced: true });
+    syncer.positionsFn.mockResolvedValue(SOL_SNAPSHOT);
+    syncer.fillsFn.mockResolvedValue(trimmableFills({ open: 1e5, close: 2e5 }));
+    await syncer.synchronizeFills();
+    const trimLogs = logSpy.mock.calls.filter((call) => String(call[0]).includes("first-sync trim"));
+    expect(trimLogs).toHaveLength(1);
+    expect(String(trimLogs[0]?.[0])).toContain("hyperliquid");
+  });
+  it("neverSynced=false: positions fetched once, no bump, no trim log", async () => {
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {
+    });
+    const { syncer, sync } = makeSyncer({ neverSynced: false });
+    syncer.positionsFn.mockResolvedValue(SOL_SNAPSHOT);
+    syncer.fillsFn.mockResolvedValue([
+      extFill({ exchangeFillId: "e", symbol: "SOL", side: "BUY", quantity: "2", timestamp: NEWEST_TS })
+    ]);
+    await syncer.synchronizeFills();
+    expect(syncer.positionsFn).toHaveBeenCalledTimes(1);
+    expect(sync.fills.create.mock.calls[0]?.[0]?.meta.externalMaxTs).toBe(NEWEST_TS);
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+});

package/dist/syncer/binance/syncer.js

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { fetchUserTradesSince, fetchAllOrdersSince } from '../../client/binance/rest';
+import { fetchAllPositionRisk, fetchUserTradesSince, fetchAllOrdersSince } from '../../client/binance/rest';
 import { BaseAccountSyncer } from '../base';
 
 class BinanceAccountSyncer extends BaseAccountSyncer {
@@ -8,6 +8,31 @@ class BinanceAccountSyncer extends BaseAccountSyncer {
     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,
@@ -25,33 +50,36 @@ class BinanceAccountSyncer extends BaseAccountSyncer {
       fetchAllOrdersSince(this.creds, instrumentIds, since, this.demo)
     ]);
     const ordersBySymbolOrderId = this.mapOrdersBySymbolOrderId(orders);
-    return trades.reduce((acc, trade) => {
-      if (!requestedInstrumentIds.has(trade.symbol)) {
-        return acc;
+    return trades.reduce((fills, rawFill) => {
+      if (!requestedInstrumentIds.has(rawFill.symbol)) {
+        return fills;
       }
-      const order = ordersBySymbolOrderId.get(this.orderKey(trade.symbol, trade.orderId));
-      acc.push({
+      const order = ordersBySymbolOrderId.get(this.orderKey(rawFill.symbol, rawFill.orderId));
+      fills.push({
         connector: "binance",
-        exchangeFillId: trade.id.toString(),
+        exchangeFillId: rawFill.id.toString(),
         cloid: order?.clientOrderId || null,
-        symbol: trade.symbol,
-        price: trade.price,
-        quantity: trade.qty,
-        side: trade.side,
-        reduceOnly: this.isReduceOnly(trade),
-        timestamp: trade.time,
-        tradeFee: new BigNumber(trade.commission || 0).abs().toFixed(),
+        symbol: rawFill.symbol,
+        price: rawFill.price,
+        quantity: rawFill.qty,
+        side: rawFill.side,
+        reduceOnly: this.isReduceOnly(rawFill),
+        timestamp: rawFill.time,
+        tradeFee: new BigNumber(rawFill.commission || 0).abs().toFixed(),
         builderFee: "0",
         liquidation: null
       });
-      return acc;
+      return fills;
     }, []);
   }
-  isReduceOnly(trade) {
-    if (trade.positionSide === "LONG") return trade.side === "SELL";
-    if (trade.positionSide === "SHORT") return trade.side === "BUY";
-    if (trade.positionSide === "BOTH") {
-      return !new BigNumber(trade.realizedPnl || 0).isZero();
+  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;
   }

package/dist/syncer/bybit/syncer.js

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { fetchExecutionsSince } from '../../client/bybit/rest';
+import { fetchPositions, fetchExecutionsSince } from '../../client/bybit/rest';
 import { BaseAccountSyncer } from '../base';
 
 class BybitAccountSyncer extends BaseAccountSyncer {
@@ -8,28 +8,52 @@ class BybitAccountSyncer extends BaseAccountSyncer {
     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((acc, execution) => {
-      acc.push({
+    return executions.reduce((fills, rawFill) => {
+      fills.push({
         connector: "bybit",
-        exchangeFillId: execution.execId,
-        cloid: execution.orderLinkId || null,
-        symbol: execution.symbol,
-        price: execution.execPrice,
-        quantity: execution.execQty,
-        side: execution.side === "Buy" ? "BUY" : "SELL",
-        reduceOnly: this.isReduceOnly(execution),
-        timestamp: Number(execution.execTime),
-        tradeFee: new BigNumber(execution.execFee || 0).abs().toFixed(),
+        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: new BigNumber(rawFill.execFee || 0).abs().toFixed(),
         builderFee: "0",
         liquidation: null
       });
-      return acc;
+      return fills;
     }, []);
   }
-  isReduceOnly(execution) {
-    return Number(execution.closedSize || "0") > 0;
+  async listExternalFunding(_params) {
+    throw new Error("funding sync is not implemented for bybit");
+  }
+  isReduceOnly(rawFill) {
+    return Number(rawFill.closedSize || "0") > 0;
   }
 }
 

package/dist/syncer/hyperliquid/funding.js

@@ -0,0 +1,24 @@
+import BigNumber from 'bignumber.js';
+
+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;
+  }, []);
+}
+
+export { toFundingPaymentEntries };

package/dist/syncer/hyperliquid/funding.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest';
+import { toFundingPaymentEntries } from './funding';
+
+const fundingEvent = (over) => ({
+  time: over.time,
+  hash: "0xabc",
+  delta: {
+    type: "funding",
+    coin: over.coin,
+    usdc: over.usdc ?? "1.5",
+    szi: over.szi ?? "10",
+    fundingRate: over.fundingRate,
+    nSamples: 1
+  }
+});
+describe("toFundingPaymentEntries", () => {
+  const map = {
+    BTC: "HL-BTC",
+    ETH: "HL-ETH"
+  };
+  it("maps a funding event to a funding-payment entry (rate + notional + per-size)", () => {
+    const result = toFundingPaymentEntries(
+      [fundingEvent({ coin: "BTC", fundingRate: "-0.0001", usdc: "-2.5", szi: "5", time: 1e3 })],
+      map
+    );
+    expect(result).toEqual([
+      {
+        connector: "hyperliquid",
+        instrumentId: "HL-BTC",
+        fundingRate: "-0.0001",
+        notional: "-2.5",
+        // notional / szi = -2.5 / 5
+        fundingPerUnit: "-0.5",
+        timestamp: 1e3
+      }
+    ]);
+  });
+  it("uses signed division by szi (per-size is the attribution coefficient)", () => {
+    const result = toFundingPaymentEntries(
+      [fundingEvent({ coin: "BTC", fundingRate: "0.0001", usdc: "2.5", szi: "-5", time: 1e3 })],
+      map
+    );
+    expect(result[0]?.fundingPerUnit).toBe("-0.5");
+  });
+  it("uses zero per-size when size is zero (no divide by zero)", () => {
+    const result = toFundingPaymentEntries(
+      [fundingEvent({ coin: "BTC", fundingRate: "0.0001", usdc: "0", szi: "0", time: 1e3 })],
+      map
+    );
+    expect(result[0]?.fundingPerUnit).toBe("0");
+  });
+  it("skips events whose coin is not in the instrument map", () => {
+    const result = toFundingPaymentEntries(
+      [
+        fundingEvent({ coin: "BTC", fundingRate: "0.0001", time: 1e3 }),
+        fundingEvent({ coin: "DOGE", fundingRate: "0.0002", time: 2e3 }),
+        fundingEvent({ coin: "ETH", fundingRate: "0.0003", time: 3e3 })
+      ],
+      map
+    );
+    expect(result.map((entry) => entry.instrumentId)).toEqual(["HL-BTC", "HL-ETH"]);
+  });
+});

package/dist/syncer/hyperliquid/syncer.js

@@ -1,12 +1,61 @@
+import BigNumber from 'bignumber.js';
 import { fetchInfo } from '../../client/hyperliquid/rest';
 import { BaseAccountSyncer } from '../base';
+import { toFundingPaymentEntries } from './funding';
 
+const HYPERLIQUID_FILL_PAGE_LIMIT = 2e3;
+const HYPERLIQUID_FILL_RETENTION_LIMIT = 1e4;
 class HyperliquidAccountSyncer extends BaseAccountSyncer {
   address;
   constructor(config) {
     super(config);
     this.address = config.account.exchangeIdentifier;
   }
+  async listExternalPositions({
+    instruments
+  }) {
+    const instrumentByBase = new Map(
+      instruments.map((instrument) => [
+        instrument.base,
+        { id: instrument.id, contractSize: instrument.precision.quantity.contractSize }
+      ])
+    );
+    const perpDexs = await fetchInfo({ type: "perpDexs" }, this.demo);
+    const dexNames = [...new Set(perpDexs.map((perpDex) => perpDex?.name ?? ""))];
+    const states = await Promise.all(
+      dexNames.map(
+        (dex) => fetchInfo(
+          {
+            type: "clearinghouseState",
+            user: this.address,
+            dex
+          },
+          this.demo
+        )
+      )
+    );
+    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
@@ -15,38 +64,148 @@ class HyperliquidAccountSyncer extends BaseAccountSyncer {
       acc[instrument.base] = instrument.id;
       return acc;
     }, {});
-    const result = await fetchInfo({
-      type: "userFillsByTime",
-      user: this.address,
-      startTime: since.getTime(),
-      aggregateByTime: true
-    });
-    return result.reduce((acc, fill) => {
-      const instrumentId = instrumentSymbolToIdMap[fill.coin];
+    const allFills = [];
+    const seenFillIds = /* @__PURE__ */ new Set();
+    let oldestReachableFillTime = null;
+    const addFill = (fill) => {
+      const fillId = hyperliquidFillId(fill);
+      if (!seenFillIds.has(fillId)) {
+        seenFillIds.add(fillId);
+        allFills.push(fill);
+      }
+    };
+    let cursor = since.getTime();
+    let batchSize;
+    do {
+      const batch = await fetchInfo(
+        {
+          type: "userFillsByTime",
+          user: this.address,
+          startTime: cursor,
+          aggregateByTime: false
+        },
+        this.demo
+      );
+      batchSize = batch.length;
+      if (batch.length > 0 && oldestReachableFillTime === null) {
+        oldestReachableFillTime = Math.min(...batch.map((fill) => fill.time));
+      }
+      for (const rawFill of batch) {
+        addFill(rawFill);
+      }
+      if (seenFillIds.size >= HYPERLIQUID_FILL_RETENTION_LIMIT && oldestReachableFillTime !== null && since.getTime() < oldestReachableFillTime) {
+        throw new Error(
+          `Hyperliquid fill history is incomplete: requested since ${since.getTime()} predates oldest reachable fill ${oldestReachableFillTime} within the ${HYPERLIQUID_FILL_RETENTION_LIMIT}-fill retention limit.`
+        );
+      }
+      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 fetchInfo(
+        {
+          type: "userTwapSliceFillsByTime",
+          user: this.address,
+          startTime: cursor,
+          aggregateByTime: false
+        },
+        this.demo
+      );
+      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 ${fill.coin} not found in instrument symbol to id map.`);
-        return acc;
+        console.warn(`Instrument symbol ${rawFill.coin} not found in instrument symbol to id map.`);
+        return fills;
       }
-      acc.push({
+      const tradeFee = new BigNumber(rawFill.fee).minus(rawFill.builderFee ?? "0");
+      if (tradeFee.isNegative()) {
+        throw new Error(
+          `Hyperliquid fill ${hyperliquidFillId(rawFill)} has a negative net trade fee (${tradeFee.toFixed()}); the backend external-fill contract does not accept Hyperliquid rebates.`
+        );
+      }
+      fills.push({
         connector: "hyperliquid",
-        exchangeFillId: fill.tid.toFixed(),
-        cloid: fill.cloid ?? null,
+        exchangeFillId: hyperliquidFillId(rawFill),
+        cloid: rawFill.cloid ?? null,
         symbol: instrumentId,
-        price: fill.px,
-        quantity: fill.sz,
-        side: fill.side === "B" ? "BUY" : "SELL",
-        reduceOnly: this.isReduceOnly(fill),
-        timestamp: fill.time,
-        tradeFee: fill.fee,
-        builderFee: fill.builderFee ?? "0",
-        liquidation: fill.liquidation ? { mark: fill.liquidation.markPx } : null
+        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(),
+        liquidation: rawFill.liquidation ? { mark: rawFill.liquidation.markPx } : null
       });
-      return acc;
+      return fills;
     }, []);
   }
-  isReduceOnly(fill) {
-    return fill.dir.includes("Close");
+  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 fetchInfo(
+        {
+          type: "userFunding",
+          user: this.address,
+          startTime: cursor
+        },
+        this.demo
+      );
+      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");
   }
 }
+function hyperliquidFillId(fill) {
+  return `${fill.time}:${fill.coin}:${fill.tid}`;
+}
+function warnStalledPagination(stream, cursor) {
+  console.warn(`Hyperliquid ${stream} pagination stalled at timestamp ${cursor}; returned history may be incomplete.`);
+}
 
 export { HyperliquidAccountSyncer };