@pear-protocol/exchanges-sdk 0.6.5 → 0.6.7

package/dist/sdk.test.js

@@ -1,117 +0,0 @@
-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 }));
-  });
-});
-describe("ExchangesSDK status options", () => {
-  beforeEach(() => {
-    checkAccountStatusMock.mockReset().mockResolvedValue({ status: "active", reasons: [] });
-  });
-  it("passes per-call options through to the status check unchanged", async () => {
-    const options = { builderAddress: "0xabc", builderFeeTenthsBps: 60 };
-    const { exchangesSdk } = buildSdk();
-    await exchangesSdk.status(connection, options);
-    expect(checkAccountStatusMock).toHaveBeenCalledWith("okx", expect.objectContaining({ statusOptions: options }));
-  });
-  it("leaves the options absent when the caller passes none", async () => {
-    const { exchangesSdk } = buildSdk();
-    await exchangesSdk.status(connection);
-    expect(checkAccountStatusMock).toHaveBeenCalledWith("okx", expect.objectContaining({ statusOptions: void 0 }));
-  });
-});

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

@@ -1,94 +0,0 @@
-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(["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("treats Portfolio Margin as a supported account mode", async () => {
-    fetchUserAbstractionMock.mockResolvedValue("portfolioMargin");
-    const status = await checkHyperliquidAccountStatus(statusConfig());
-    expect(status).toEqual({ status: "active", reasons: [] });
-  });
-  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");
-  });
-  it("skips the builder-fee check when no builder address is configured, keeping the other checks", async () => {
-    const config = statusConfig();
-    config.statusOptions = { builderFeeTenthsBps: 10 };
-    const status = await checkHyperliquidAccountStatus(config);
-    expect(status).toEqual({ status: "active", reasons: [] });
-    expect(checkBuilderFeeApprovalMock).not.toHaveBeenCalled();
-    expect(checkApiWalletMock).toHaveBeenCalled();
-  });
-});

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

@@ -1,86 +0,0 @@
-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();
-  });
-  it("skips the integrator check when no integrator is configured, keeping the api-key check", async () => {
-    const noIntegrator = config();
-    noIntegrator.demo = false;
-    noIntegrator.statusOptions = {
-      integratorMinPerpsMakerFee: 500,
-      integratorMinPerpsTakerFee: 600
-    };
-    await expect(checkLighterAccountStatus(noIntegrator)).resolves.toEqual({ status: "active", reasons: [] });
-    expect(checkIntegratorApprovalMock).not.toHaveBeenCalled();
-    expect(fetchAccountMetadataMock).toHaveBeenCalled();
-  });
-});

package/dist/syncer/base.test.js

@@ -1,178 +0,0 @@
-import { FetchError } from '@pear-protocol/core-sdk';
-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,
-      firstSyncStartedAt: args.neverSynced ? FIRST_SYNC_STARTED_AT : void 0,
-      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: { lite: 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;
-const FIRST_SYNC_STARTED_AT = 1e6;
-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("captures an empty first-sync checkpoint before fetching fills", async () => {
-    const { syncer, sync } = makeSyncer({ neverSynced: true });
-    syncer.positionsFn.mockResolvedValue([]);
-    syncer.fillsFn.mockResolvedValue([]);
-    await syncer.synchronizeFills();
-    expect(sync.fills.since.mock.invocationCallOrder[0]).toBeLessThan(syncer.fillsFn.mock.invocationCallOrder[0] ?? 0);
-    expect(sync.fills.create.mock.calls[0]?.[0]?.meta).toEqual({
-      externalMaxTs: null,
-      firstSyncStartedAt: FIRST_SYNC_STARTED_AT
-    });
-  });
-  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("carries the raw newest fill untouched next to a bumped watermark", 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.newestFillTs).toBe(NEWEST_TS);
-  });
-  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("swallows a SYNC_CREATE_* deferral so the next tick retries the same window", 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 })
-    ]);
-    sync.fills.create.mockRejectedValue(new FetchError("deferred", "Conflict", 409, "SYNC_CREATE_EXECUTION_IN_FLIGHT"));
-    await expect(syncer.synchronizeFills()).resolves.toBeUndefined();
-    const deferLogs = logSpy.mock.calls.filter((call) => String(call[0]).includes("SYNC_CREATE_EXECUTION_IN_FLIGHT"));
-    expect(deferLogs).toHaveLength(1);
-  });
-  it("propagates a 409 that is not a sync-create deferral", async () => {
-    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 })
-    ]);
-    sync.fills.create.mockRejectedValue(new FetchError("conflict", "Conflict", 409, "NOOP_ERROR"));
-    await expect(syncer.synchronizeFills()).rejects.toThrow("conflict");
-  });
-  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).toEqual({ externalMaxTs: NEWEST_TS, newestFillTs: NEWEST_TS });
-    expect(logSpy).not.toHaveBeenCalled();
-  });
-});

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

@@ -1,63 +0,0 @@
-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"]);
-  });
-});