@pear-protocol/exchanges-sdk 0.3.0 → 0.4.0

package/dist/sdk.test.js

@@ -0,0 +1,101 @@
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import { ExchangesSDK } from './sdk';
+
+const { checkAccountStatusMock, createAccountSyncerMock, createAccountTrackerMock, createExchangeWsMock } = vi.hoisted(
+  () => ({
+    checkAccountStatusMock: vi.fn(),
+    createAccountSyncerMock: vi.fn(),
+    createAccountTrackerMock: vi.fn(),
+    createExchangeWsMock: vi.fn()
+  })
+);
+vi.mock("./status", () => ({
+  checkAccountStatus: checkAccountStatusMock
+}));
+vi.mock("./syncer", () => ({
+  createAccountSyncer: createAccountSyncerMock
+}));
+vi.mock("./client", () => ({
+  createExchangeWs: createExchangeWsMock
+}));
+vi.mock("./tracker", () => ({
+  createAccountTracker: createAccountTrackerMock
+}));
+const connection = {
+  connector: "okx",
+  account: { id: "account-1" },
+  credentials: { api_key: "k", api_secret: "s", api_pass: "p" }
+};
+function buildSdk(credentials = vi.fn().mockResolvedValue(connection), demo = true) {
+  const sdk = {
+    core: { accounts: { credentials } }
+  };
+  return { exchangesSdk: new ExchangesSDK({ sdk, demo }), credentials, sdk };
+}
+describe("ExchangesSDK.snapshot", () => {
+  beforeEach(() => {
+    checkAccountStatusMock.mockReset().mockResolvedValue({ status: "active", reasons: [] });
+    createAccountSyncerMock.mockReset().mockReturnValue({});
+    createExchangeWsMock.mockReset();
+    createAccountTrackerMock.mockReset();
+  });
+  it("fetches credentials, builds a ws-free tracker, and returns tracker.snapshot() without opening a socket", async () => {
+    const fakeSnapshot = { balance: null, positions: [] };
+    const trackerSnapshot = vi.fn().mockResolvedValue(fakeSnapshot);
+    createAccountTrackerMock.mockReturnValue({ snapshot: trackerSnapshot });
+    const { exchangesSdk, credentials, sdk } = buildSdk();
+    const result = await exchangesSdk.snapshot("trade-account-1");
+    expect(credentials).toHaveBeenCalledWith("trade-account-1");
+    expect(createAccountTrackerMock).toHaveBeenCalledWith(
+      "okx",
+      expect.objectContaining({
+        demo: true,
+        account: connection.account,
+        credentials: connection.credentials,
+        sdk
+      })
+    );
+    expect(trackerSnapshot).toHaveBeenCalledTimes(1);
+    expect(result).toBe(fakeSnapshot);
+    expect(createExchangeWsMock).not.toHaveBeenCalled();
+  });
+  it("snapshotAssets() delegates the coin list to a ws-free tracker", async () => {
+    const fakeAssets = { BTC: { coin: "BTC", leverage: "10", marginType: "cross" } };
+    const trackerSnapshotAssets = vi.fn().mockResolvedValue(fakeAssets);
+    createAccountTrackerMock.mockReturnValue({ snapshotAssets: trackerSnapshotAssets });
+    const { exchangesSdk, credentials } = buildSdk();
+    const result = await exchangesSdk.snapshotAssets("trade-account-1", ["BTC", "ETH"]);
+    expect(credentials).toHaveBeenCalledWith("trade-account-1");
+    expect(trackerSnapshotAssets).toHaveBeenCalledWith(["BTC", "ETH"]);
+    expect(result).toBe(fakeAssets);
+    expect(createExchangeWsMock).not.toHaveBeenCalled();
+  });
+  it("propagates credential fetch failures", async () => {
+    const { exchangesSdk } = buildSdk(vi.fn().mockRejectedValue(new Error("no access")));
+    await expect(exchangesSdk.snapshot("trade-account-1")).rejects.toThrow("no access");
+    expect(createAccountTrackerMock).not.toHaveBeenCalled();
+    expect(createExchangeWsMock).not.toHaveBeenCalled();
+  });
+  it("connect() is credential-only and opens no socket", async () => {
+    const { exchangesSdk } = buildSdk();
+    const result = await exchangesSdk.connect("trade-account-1");
+    expect(result).toEqual(connection);
+    expect(createExchangeWsMock).not.toHaveBeenCalled();
+  });
+});
+describe("ExchangesSDK configured network routing", () => {
+  beforeEach(() => {
+    checkAccountStatusMock.mockReset().mockResolvedValue({ status: "active", reasons: [] });
+    createAccountSyncerMock.mockReset().mockReturnValue({});
+    createAccountTrackerMock.mockReset().mockReturnValue({});
+  });
+  it("uses the SDK demo option for account-bound operations", async () => {
+    const { exchangesSdk } = buildSdk(void 0, true);
+    await exchangesSdk.status(connection);
+    exchangesSdk.createTracker(connection);
+    exchangesSdk.createSyncer(connection);
+    expect(checkAccountStatusMock).toHaveBeenCalledWith("okx", expect.objectContaining({ demo: true }));
+    expect(createAccountTrackerMock).toHaveBeenCalledWith("okx", expect.objectContaining({ demo: true }));
+    expect(createAccountSyncerMock).toHaveBeenCalledWith("okx", expect.objectContaining({ demo: true }));
+  });
+});

package/dist/status/hyperliquid/status.js

@@ -1,20 +1,32 @@
+import { fetchUserAbstraction } from '../../client/hyperliquid/rest';
 import { createExchangeHelper } from '../../helper/factory';
+import { HyperliquidAccountType } from '../../tracker/hyperliquid/types';
 import { warningStatus } from '../base';
 
 async function checkHyperliquidAccountStatus(config) {
   const reasons = [];
   const options = config.statusOptions;
-  if (!options?.builderAddress) {
+  if (!options?.builderAddress || !options.builderFeeTenthsBps) {
     throw new Error("Missing required hyperliquid connect options");
   }
-  const helper = createExchangeHelper({ exchange: "hyperliquid" });
+  const helper = createExchangeHelper({ exchange: "hyperliquid", demo: config.demo });
   const metadata = config.account.metadata;
+  const approvalAddress = metadata && "isSubaccount" in metadata && metadata.isSubaccount ? metadata.mainAccountAddress : config.account.exchangeIdentifier;
+  try {
+    const abstraction = await fetchUserAbstraction(config.account.exchangeIdentifier, config.demo);
+    const supportedAccountMode = abstraction === HyperliquidAccountType.DEFAULT || abstraction === HyperliquidAccountType.DISABLED || abstraction === HyperliquidAccountType.UNIFIED_ACCOUNT;
+    if (!supportedAccountMode) {
+      reasons.push("hyperliquid_account_mode_unsupported");
+    }
+  } catch {
+    reasons.push("hyperliquid_account_mode_check_failed");
+  }
   if (!metadata || !("agentWalletAddress" in metadata)) {
     reasons.push("hyperliquid_api_wallet_invalid");
   } else {
     try {
       const apiWalletValid = await helper.checkApiWallet({
-        userAddress: config.account.exchangeIdentifier,
+        userAddress: approvalAddress,
         agentWalletAddress: metadata.agentWalletAddress
       });
       if (!apiWalletValid) reasons.push("hyperliquid_api_wallet_invalid");
@@ -24,8 +36,9 @@ async function checkHyperliquidAccountStatus(config) {
   }
   try {
     const approved = await helper.checkBuilderFeeApproval(
-      config.account.exchangeIdentifier,
-      options.builderAddress
+      approvalAddress,
+      options.builderAddress,
+      options.builderFeeTenthsBps
     );
     if (!approved) reasons.push("hyperliquid_builder_fee_not_approved");
   } catch {

package/dist/status/hyperliquid/status.test.js

@@ -0,0 +1,81 @@
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import { checkHyperliquidAccountStatus } from './status';
+
+const { checkApiWalletMock, checkBuilderFeeApprovalMock, fetchUserAbstractionMock } = vi.hoisted(() => ({
+  checkApiWalletMock: vi.fn(),
+  checkBuilderFeeApprovalMock: vi.fn(),
+  fetchUserAbstractionMock: vi.fn()
+}));
+vi.mock("../../helper/factory", () => ({
+  createExchangeHelper: () => ({
+    checkApiWallet: checkApiWalletMock,
+    checkBuilderFeeApproval: checkBuilderFeeApprovalMock
+  })
+}));
+vi.mock("../../client/hyperliquid/rest", () => ({
+  fetchUserAbstraction: fetchUserAbstractionMock
+}));
+const subaccountAddress = "0x1111111111111111111111111111111111111111";
+const mainAccountAddress = "0x2222222222222222222222222222222222222222";
+const agentWalletAddress = "0x3333333333333333333333333333333333333333";
+const builderAddress = "0x4444444444444444444444444444444444444444";
+function statusConfig() {
+  return {
+    sdk: {},
+    connector: "hyperliquid",
+    account: {
+      id: crypto.randomUUID(),
+      alias: "HL",
+      connector: "hyperliquid",
+      exchangeIdentifier: subaccountAddress,
+      metadata: {
+        agentWalletAddress,
+        isSubaccount: true,
+        mainAccountAddress
+      },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    credentials: { signer_key: "sk" },
+    statusOptions: { builderAddress, builderFeeTenthsBps: 10 },
+    demo: true
+  };
+}
+describe("checkHyperliquidAccountStatus", () => {
+  beforeEach(() => {
+    checkApiWalletMock.mockReset().mockResolvedValue(true);
+    checkBuilderFeeApprovalMock.mockReset().mockResolvedValue(true);
+    fetchUserAbstractionMock.mockReset().mockResolvedValue("disabled");
+  });
+  it("checks subaccount approvals against the main account and mode against the trading account", async () => {
+    const status = await checkHyperliquidAccountStatus(statusConfig());
+    expect(status).toEqual({ status: "active", reasons: [] });
+    expect(fetchUserAbstractionMock).toHaveBeenCalledWith(subaccountAddress, true);
+    expect(checkApiWalletMock).toHaveBeenCalledWith({ userAddress: mainAccountAddress, agentWalletAddress });
+    expect(checkBuilderFeeApprovalMock).toHaveBeenCalledWith(mainAccountAddress, builderAddress, 10);
+  });
+  it.each(["portfolioMargin", "dexAbstraction", "somethingNew"])(
+    "warns when account mode %s cannot be represented safely",
+    async (abstraction) => {
+      fetchUserAbstractionMock.mockResolvedValue(abstraction);
+      const status = await checkHyperliquidAccountStatus(statusConfig());
+      expect(status).toEqual({
+        status: "warning",
+        reasons: ["hyperliquid_account_mode_unsupported"]
+      });
+    }
+  );
+  it("distinguishes an account-mode API failure from an unsupported mode", async () => {
+    fetchUserAbstractionMock.mockRejectedValue(new Error("503"));
+    const status = await checkHyperliquidAccountStatus(statusConfig());
+    expect(status).toEqual({
+      status: "warning",
+      reasons: ["hyperliquid_account_mode_check_failed"]
+    });
+  });
+  it("fails closed when the required builder fee is missing", async () => {
+    const config = statusConfig();
+    config.statusOptions = { builderAddress };
+    await expect(checkHyperliquidAccountStatus(config)).rejects.toThrow("Missing required hyperliquid connect options");
+  });
+});

package/dist/status/lighter/status.js

@@ -5,24 +5,31 @@ import { warningStatus } from '../base';
 async function checkLighterAccountStatus(config) {
   const reasons = [];
   const options = config.statusOptions;
-  if (options?.integratorAccountIndex === void 0) {
+  if (options?.integratorAccountIndex === void 0 || options.integratorMinPerpsMakerFee === void 0 || options.integratorMinPerpsTakerFee === void 0) {
     throw new Error("Missing required lighter connect options");
   }
   const credentials = config.credentials;
   const accountIndex = Number(config.account.exchangeIdentifier);
-  try {
-    const { token } = await config.sdk.core.misc.lighter.createAuthToken({
-      accountIndex,
-      apiKeyIndex: credentials.api_key_index,
-      apiPrivateKey: credentials.api_private_key
-    });
-    await fetchAccountMetadata(accountIndex, token);
-  } catch {
+  if (config.demo) {
     reasons.push("lighter_api_key_invalid");
+  } else {
+    try {
+      const { token } = await config.sdk.core.misc.lighter.createAuthToken({
+        accountIndex,
+        apiKeyIndex: credentials.api_key_index,
+        apiPrivateKey: credentials.api_private_key
+      });
+      await fetchAccountMetadata(accountIndex, token, config.demo);
+    } catch {
+      reasons.push("lighter_api_key_invalid");
+    }
   }
   try {
-    const helper = createExchangeHelper({ exchange: "lighter", sdk: config.sdk });
-    const approved = await helper.checkIntegratorApproval(accountIndex, options.integratorAccountIndex);
+    const helper = createExchangeHelper({ exchange: "lighter", sdk: config.sdk, demo: config.demo });
+    const approved = await helper.checkIntegratorApproval(accountIndex, options.integratorAccountIndex, {
+      minPerpsMakerFee: options.integratorMinPerpsMakerFee,
+      minPerpsTakerFee: options.integratorMinPerpsTakerFee
+    });
     if (!approved) reasons.push("lighter_integrator_not_approved");
   } catch {
     reasons.push("lighter_integrator_not_approved");

package/dist/status/lighter/status.test.js

@@ -0,0 +1,75 @@
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import { checkLighterAccountStatus } from './status';
+
+const { checkIntegratorApprovalMock, createAuthTokenMock, createExchangeHelperMock, fetchAccountMetadataMock } = vi.hoisted(() => ({
+  checkIntegratorApprovalMock: vi.fn(),
+  createAuthTokenMock: vi.fn(),
+  createExchangeHelperMock: vi.fn(),
+  fetchAccountMetadataMock: vi.fn()
+}));
+vi.mock("../../client/lighter/rest", () => ({ fetchAccountMetadata: fetchAccountMetadataMock }));
+vi.mock("../../helper/factory", () => ({ createExchangeHelper: createExchangeHelperMock }));
+function config() {
+  return {
+    sdk: {
+      core: {
+        misc: {
+          lighter: {
+            createAuthToken: createAuthTokenMock
+          }
+        }
+      }
+    },
+    connector: "lighter",
+    account: { exchangeIdentifier: "42" },
+    credentials: { api_key_index: 4, api_private_key: "private" },
+    statusOptions: {
+      integratorAccountIndex: 77,
+      integratorMinPerpsMakerFee: 500,
+      integratorMinPerpsTakerFee: 600
+    },
+    demo: true
+  };
+}
+describe("checkLighterAccountStatus", () => {
+  beforeEach(() => {
+    createAuthTokenMock.mockReset().mockResolvedValue({ token: "token" });
+    fetchAccountMetadataMock.mockReset().mockResolvedValue(void 0);
+    checkIntegratorApprovalMock.mockReset().mockResolvedValue(true);
+    createExchangeHelperMock.mockReset().mockReturnValue({
+      checkIntegratorApproval: checkIntegratorApprovalMock
+    });
+  });
+  it("fails demo auth closed without minting a mainnet token and still checks testnet approval", async () => {
+    await expect(checkLighterAccountStatus(config())).resolves.toEqual({
+      status: "warning",
+      reasons: ["lighter_api_key_invalid"]
+    });
+    expect(createAuthTokenMock).not.toHaveBeenCalled();
+    expect(fetchAccountMetadataMock).not.toHaveBeenCalled();
+    expect(createExchangeHelperMock).toHaveBeenCalledWith(expect.objectContaining({ demo: true }));
+    expect(checkIntegratorApprovalMock).toHaveBeenCalledWith(42, 77, {
+      minPerpsMakerFee: 500,
+      minPerpsTakerFee: 600
+    });
+  });
+  it("authenticates mainnet status without unsupported payload fields", async () => {
+    const mainnetConfig = config();
+    mainnetConfig.demo = false;
+    await expect(checkLighterAccountStatus(mainnetConfig)).resolves.toEqual({ status: "active", reasons: [] });
+    expect(createAuthTokenMock).toHaveBeenCalledWith({
+      accountIndex: 42,
+      apiKeyIndex: 4,
+      apiPrivateKey: "private"
+    });
+    expect(fetchAccountMetadataMock).toHaveBeenCalledWith(42, "token", false);
+  });
+  it("fails closed when required approval thresholds are absent", async () => {
+    const missingThresholds = config();
+    missingThresholds.statusOptions = { integratorAccountIndex: 77 };
+    await expect(checkLighterAccountStatus(missingThresholds)).rejects.toThrow(
+      "Missing required lighter connect options"
+    );
+    expect(fetchAccountMetadataMock).not.toHaveBeenCalled();
+  });
+});

package/dist/syncer/base.js

@@ -6,14 +6,12 @@ class BaseAccountSyncer {
   connector;
   account;
   credentials;
-  ws;
   demo;
   constructor(config) {
     this.sdk = config.sdk;
     this.connector = config.connector;
     this.account = config.account;
     this.credentials = config.credentials;
-    this.ws = config.ws;
     this.demo = config.demo;
   }
   // Phase A: Load current Pear state (positions, fills, instruments, watermark).

package/dist/syncer/base.test.js

@@ -59,7 +59,6 @@ function makeSyncer(args) {
     connector: "hyperliquid",
     account: { id: "acct-1" },
     credentials: {},
-    ws: {},
     demo: false
   };
   return { syncer: new FakeSyncer(config), sync };

package/dist/syncer/hyperliquid/syncer.js

@@ -3,6 +3,8 @@ 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) {
@@ -18,15 +20,18 @@ class HyperliquidAccountSyncer extends BaseAccountSyncer {
         { id: instrument.id, contractSize: instrument.precision.quantity.contractSize }
       ])
     );
-    const perpDexs = await fetchInfo({ type: "perpDexs" });
-    const dexNames = perpDexs.map((perpDex) => perpDex?.name ?? "");
+    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
-        })
+        (dex) => fetchInfo(
+          {
+            type: "clearinghouseState",
+            user: this.address,
+            dex
+          },
+          this.demo
+        )
       )
     );
     const assetPositions = states.flatMap((state) => state.assetPositions);
@@ -40,12 +45,13 @@ class HyperliquidAccountSyncer extends BaseAccountSyncer {
         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: szi.abs().times(instrument.contractSize).toFixed(),
+        size,
         side: szi.isPositive() ? "BUY" : "SELL",
         entryPrice: rawPosition.entryPx,
-        markPrice: rawPosition.entryPx
+        markPrice: new BigNumber(rawPosition.positionValue).abs().div(size).toFixed()
       });
       return positions;
     }, []);
@@ -58,48 +64,73 @@ class HyperliquidAccountSyncer extends BaseAccountSyncer {
       acc[instrument.base] = instrument.id;
       return acc;
     }, {});
-    const PAGE_LIMIT = 2e3;
     const allFills = [];
-    const seenTids = /* @__PURE__ */ new Set();
+    const seenFillIds = /* @__PURE__ */ new Set();
+    let oldestReachableFillTime = null;
     const addFill = (fill) => {
-      if (!seenTids.has(fill.tid)) {
-        seenTids.add(fill.tid);
+      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: true
-      });
+      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 (batchSize === PAGE_LIMIT) {
-        cursor = batch[batch.length - 1]?.time ?? cursor;
+      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.`
+        );
       }
-    } while (batchSize === PAGE_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: true
-      });
+      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 === PAGE_LIMIT) {
-        cursor = twapBatch[twapBatch.length - 1]?.fill.time ?? cursor;
+      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 === PAGE_LIMIT);
+    } while (batchSize === HYPERLIQUID_FILL_PAGE_LIMIT);
     allFills.sort((a, b) => a.time - b.time);
     return allFills.reduce((fills, rawFill) => {
       const instrumentId = instrumentSymbolToIdMap[rawFill.coin];
@@ -107,9 +138,15 @@ class HyperliquidAccountSyncer extends BaseAccountSyncer {
         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");
+      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: rawFill.tid.toFixed(),
+        exchangeFillId: hyperliquidFillId(rawFill),
         cloid: rawFill.cloid ?? null,
         symbol: instrumentId,
         price: rawFill.px,
@@ -117,8 +154,8 @@ class HyperliquidAccountSyncer extends BaseAccountSyncer {
         side: rawFill.side === "B" ? "BUY" : "SELL",
         reduceOnly: this.isReduceOnly(rawFill),
         timestamp: rawFill.time,
-        tradeFee: rawFill.fee,
-        builderFee: rawFill.builderFee ?? "0",
+        tradeFee: tradeFee.toFixed(),
+        builderFee: new BigNumber(rawFill.builderFee ?? "0").abs().toFixed(),
         liquidation: rawFill.liquidation ? { mark: rawFill.liquidation.markPx } : null
       });
       return fills;
@@ -133,26 +170,42 @@ class HyperliquidAccountSyncer extends BaseAccountSyncer {
       return acc;
     }, {});
     const PAGE_LIMIT = 500;
-    const allEvents = [];
+    const allEvents = /* @__PURE__ */ new Map();
     let cursor = since.getTime();
     let batchSize;
     do {
-      const batch = await fetchInfo({
-        type: "userFunding",
-        user: this.address,
-        startTime: cursor
-      });
+      const batch = await fetchInfo(
+        {
+          type: "userFunding",
+          user: this.address,
+          startTime: cursor
+        },
+        this.demo
+      );
       batchSize = batch.length;
-      allEvents.push(...batch);
+      for (const event of batch) {
+        allEvents.set(`${event.time}:${event.delta.coin}:${event.hash}`, event);
+      }
       if (batchSize === PAGE_LIMIT) {
-        cursor = batch[batch.length - 1].time;
+        const nextCursor = batch[batch.length - 1]?.time ?? cursor;
+        if (nextCursor <= cursor) {
+          warnStalledPagination("funding", cursor);
+          break;
+        }
+        cursor = nextCursor;
       }
     } while (batchSize === PAGE_LIMIT);
-    return toFundingPaymentEntries(allEvents, instrumentSymbolToIdMap);
+    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 };