@pear-protocol/exchanges-sdk 0.6.4 → 0.6.6

package/dist/client/hyperliquid/client.test.js

@@ -1,41 +0,0 @@
-import { describe, afterEach, vi, it, expect } from 'vitest';
-import { fetchInfo } from './rest';
-import { HyperliquidWs } from './ws';
-
-class InspectableHyperliquidWs extends HyperliquidWs {
-  /** Exposes the selected URL for a transport regression assertion. */
-  url() {
-    return this.getWsUrl();
-  }
-  /** Exposes heartbeat cadence for a transport regression assertion. */
-  pingInterval() {
-    return this.getPingIntervalMs();
-  }
-  /** Exposes the heartbeat payload for a transport regression assertion. */
-  pingMessage() {
-    return this.buildPingMessage();
-  }
-}
-describe("Hyperliquid network clients", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-  it.each([
-    [false, "https://api.hyperliquid.xyz/info"],
-    [true, "https://api.hyperliquid-testnet.xyz/info"]
-  ])("routes info requests to the selected network", async (demo, expectedUrl) => {
-    const fetchMock = vi.fn().mockResolvedValue({ ok: true, json: async () => ({ ok: true }) });
-    vi.stubGlobal("fetch", fetchMock);
-    await fetchInfo({ type: "perpDexs" }, demo);
-    expect(fetchMock).toHaveBeenCalledWith(expectedUrl, expect.objectContaining({ method: "POST" }));
-  });
-  it("uses testnet websocket routing and Hyperliquid heartbeats in demo mode", () => {
-    const ws = new InspectableHyperliquidWs(true);
-    expect(ws.url()).toBe("wss://api.hyperliquid-testnet.xyz/ws");
-    expect(ws.pingInterval()).toBe(3e4);
-    expect(ws.pingMessage()).toEqual({ method: "ping" });
-  });
-  it("keeps no-argument websocket construction on mainnet", () => {
-    expect(new InspectableHyperliquidWs().url()).toBe("wss://api.hyperliquid.xyz/ws");
-  });
-});

package/dist/client/lighter/constants.test.js

@@ -1,22 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getLighterBaseUrl, getLighterWsUrl } from './constants';
-import { LighterWs } from './ws';
-
-class InspectableLighterWs extends LighterWs {
-  url() {
-    return this.getWsUrl();
-  }
-}
-describe("Lighter network endpoints", () => {
-  it("routes demo traffic to testnet", () => {
-    expect(getLighterBaseUrl(true)).toBe("https://testnet.zklighter.elliot.ai");
-    expect(getLighterWsUrl(true)).toBe("wss://testnet.zklighter.elliot.ai/stream");
-  });
-  it("routes non-demo traffic to mainnet", () => {
-    expect(getLighterBaseUrl(false)).toBe("https://mainnet.zklighter.elliot.ai");
-    expect(getLighterWsUrl(false)).toBe("wss://mainnet.zklighter.elliot.ai/stream");
-  });
-  it("keeps no-argument websocket construction on mainnet", () => {
-    expect(new InspectableLighterWs().url()).toBe("wss://mainnet.zklighter.elliot.ai/stream");
-  });
-});

package/dist/client/lighter/rest.test.js

@@ -1,158 +0,0 @@
-import { afterEach, vi, describe, it, expect } from 'vitest';
-import { fetchAccount, fetchAssetDetails, fetchAccountsByL1Address, fetchAccountLimits, fetchPositionFundingSince, fetchTradesSince } from './rest';
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-describe("Lighter REST client", () => {
-  it("routes demo account reads to testnet and rejects exchange-level errors", async () => {
-    const fetchMock = vi.fn().mockResolvedValue(
-      new Response(JSON.stringify({ code: 20001, message: "account not found" }), {
-        status: 400
-      })
-    );
-    vi.stubGlobal("fetch", fetchMock);
-    await expect(fetchAccount(42, true)).rejects.toThrow("Lighter /account returned 20001: account not found");
-    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://testnet.zklighter.elliot.ai/api/v1/account?by=index&value=42");
-  });
-  it("rejects HTTP failures before reading endpoint data", async () => {
-    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(new Response("unavailable", { status: 503 })));
-    await expect(fetchAssetDetails(false)).rejects.toThrow("Lighter /assetDetails returned 503");
-  });
-  it("preserves the account-not-registered lookup result for the helper", async () => {
-    vi.stubGlobal(
-      "fetch",
-      vi.fn().mockResolvedValue(
-        new Response(JSON.stringify({ code: 21100, message: "account not found" }), {
-          status: 400
-        })
-      )
-    );
-    await expect(fetchAccountsByL1Address("0xabc", true)).resolves.toEqual({
-      code: 21100,
-      message: "account not found"
-    });
-  });
-  it("paginates and de-duplicates subaccounts while stopping a repeated cursor", async () => {
-    const fetchMock = vi.fn().mockResolvedValueOnce(
-      new Response(
-        JSON.stringify({
-          code: 200,
-          sub_accounts: [
-            { account_type: 0, index: 1 },
-            { account_type: 1, index: 2 }
-          ],
-          next_cursor: "page-2"
-        }),
-        { status: 200 }
-      )
-    ).mockResolvedValueOnce(
-      new Response(
-        JSON.stringify({
-          code: 200,
-          sub_accounts: [
-            { account_type: 1, index: 2 },
-            { account_type: 1, index: 3 }
-          ],
-          next_cursor: "page-2"
-        }),
-        { status: 200 }
-      )
-    );
-    vi.stubGlobal("fetch", fetchMock);
-    await expect(fetchAccountsByL1Address("0xabc", true)).resolves.toMatchObject({
-      code: 200,
-      sub_accounts: [
-        { account_type: 0, index: 1 },
-        { account_type: 1, index: 2 },
-        { account_type: 1, index: 3 }
-      ]
-    });
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-    expect(String(fetchMock.mock.calls[1]?.[0])).toContain("cursor=page-2");
-  });
-  it("reads authenticated account limits from the selected environment", async () => {
-    const fetchMock = vi.fn().mockResolvedValue(
-      new Response(JSON.stringify({ code: 200, user_tier: "premium" }), {
-        status: 200
-      })
-    );
-    vi.stubGlobal("fetch", fetchMock);
-    await expect(fetchAccountLimits(42, "auth-token", true)).resolves.toMatchObject({ user_tier: "premium" });
-    expect(fetchMock).toHaveBeenCalledWith(
-      "https://testnet.zklighter.elliot.ai/api/v1/accountLimits?account_index=42",
-      { headers: { authorization: "auth-token" } }
-    );
-  });
-  it("returns typed L1 and L2 decimals from assetDetails", async () => {
-    const fetchMock = vi.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          code: 200,
-          asset_details: [{ asset_id: 1, symbol: "ETH", l1_decimals: 18, decimals: 8 }]
-        }),
-        { status: 200 }
-      )
-    );
-    vi.stubGlobal("fetch", fetchMock);
-    await expect(fetchAssetDetails(false)).resolves.toEqual([
-      { asset_id: 1, symbol: "ETH", l1_decimals: 18, decimals: 8 }
-    ]);
-    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://mainnet.zklighter.elliot.ai/api/v1/assetDetails");
-  });
-  it("paginates and de-duplicates funding rows by market and funding id", async () => {
-    const duplicate = fundingRow({ funding_id: 2, timestamp: 2e3 });
-    const fetchMock = vi.fn().mockResolvedValueOnce(
-      new Response(
-        JSON.stringify({
-          code: 200,
-          position_fundings: [fundingRow({ funding_id: 1, timestamp: 1e3 }), duplicate],
-          next_cursor: "page-2"
-        }),
-        { status: 200 }
-      )
-    ).mockResolvedValueOnce(
-      new Response(
-        JSON.stringify({
-          code: 200,
-          position_fundings: [duplicate, fundingRow({ funding_id: 3, timestamp: 3e3 })]
-        }),
-        { status: 200 }
-      )
-    );
-    vi.stubGlobal("fetch", fetchMock);
-    const rows = await fetchPositionFundingSince(42, "auth", /* @__PURE__ */ new Date(1e3), true);
-    expect(rows.map((row) => row.funding_id)).toEqual([1, 2, 3]);
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-    expect(String(fetchMock.mock.calls[0]?.[0])).toContain("start_timestamp=1");
-    expect(String(fetchMock.mock.calls[1]?.[0])).toContain("cursor=page-2");
-  });
-  it("floors an epoch watermark to start_timestamp=1 since Lighter rejects 0 in seconds", async () => {
-    const fetchMock = vi.fn().mockResolvedValue(new Response(JSON.stringify({ code: 200, position_fundings: [] }), { status: 200 }));
-    vi.stubGlobal("fetch", fetchMock);
-    await fetchPositionFundingSince(42, "auth", /* @__PURE__ */ new Date(0), true);
-    expect(String(fetchMock.mock.calls[0]?.[0])).toContain("start_timestamp=1");
-  });
-  it("stops trades pagination when the API repeats a cursor", async () => {
-    const page = new Response(JSON.stringify({ code: 200, trades: [], next_cursor: "same-page" }), { status: 200 });
-    const fetchMock = vi.fn().mockResolvedValueOnce(page).mockResolvedValueOnce(
-      new Response(JSON.stringify({ code: 200, trades: [], next_cursor: "same-page" }), { status: 200 })
-    );
-    vi.stubGlobal("fetch", fetchMock);
-    await expect(fetchTradesSince(42, "auth", /* @__PURE__ */ new Date(1e3), true)).resolves.toEqual([]);
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-    expect(String(fetchMock.mock.calls[1]?.[0])).toContain("cursor=same-page");
-  });
-});
-function fundingRow(overrides) {
-  return {
-    timestamp: overrides.timestamp,
-    market_id: 1,
-    funding_id: overrides.funding_id,
-    change: "-2",
-    discount: "0",
-    rate: "0.0001",
-    position_size: "4",
-    position_side: "long"
-  };
-}

package/dist/helper/hyperliquid/helper.test.js

@@ -1,72 +0,0 @@
-import { vi, describe, beforeEach, it, expect } from 'vitest';
-import { createHyperliquidHelper } from './helper';
-
-const { fetchInfoMock, fetchUserRoleMock } = vi.hoisted(() => ({
-  fetchInfoMock: vi.fn(),
-  fetchUserRoleMock: vi.fn()
-}));
-vi.mock("../../client/hyperliquid/rest", () => ({ fetchInfo: fetchInfoMock, fetchUserRole: fetchUserRoleMock }));
-const userAddress = "0x1111111111111111111111111111111111111111";
-const agentWalletAddress = "0x2222222222222222222222222222222222222222";
-const builderAddress = "0x3333333333333333333333333333333333333333";
-const masterAddress = "0x4444444444444444444444444444444444444444";
-describe("createHyperliquidHelper", () => {
-  beforeEach(() => {
-    fetchInfoMock.mockReset();
-    fetchUserRoleMock.mockReset();
-  });
-  it("reports an address Hyperliquid does not know as not activated", async () => {
-    fetchUserRoleMock.mockResolvedValue({ role: "missing" });
-    const activated = await createHyperliquidHelper(true).checkAccountActivation(userAddress);
-    expect(activated).toBe(false);
-    expect(fetchUserRoleMock).toHaveBeenCalledWith(userAddress, true);
-  });
-  it.each([
-    ["user", { role: "user" }],
-    ["agent", { role: "agent", data: { user: masterAddress } }],
-    ["vault", { role: "vault" }],
-    ["subAccount", { role: "subAccount", data: { master: masterAddress } }]
-  ])("reports the %s role as activated", async (_role, response) => {
-    fetchUserRoleMock.mockResolvedValue(response);
-    await expect(createHyperliquidHelper().checkAccountActivation(userAddress)).resolves.toBe(true);
-    expect(fetchUserRoleMock).toHaveBeenCalledWith(userAddress, false);
-  });
-  it("surfaces a failed role request as an error instead of an inactive account", async () => {
-    fetchUserRoleMock.mockRejectedValue(new Error("Hyperliquid info request failed: 429"));
-    await expect(createHyperliquidHelper().checkAccountActivation(userAddress)).rejects.toThrow(
-      "Hyperliquid info request failed: 429"
-    );
-  });
-  it("accepts unexpired and non-expiring API wallets on the selected network", async () => {
-    fetchInfoMock.mockResolvedValue([
-      { name: "expired", address: agentWalletAddress, validUntil: Date.now() - 1 },
-      { name: "active", address: agentWalletAddress.toUpperCase(), validUntil: null }
-    ]);
-    const valid = await createHyperliquidHelper(true).checkApiWallet({ userAddress, agentWalletAddress });
-    expect(valid).toBe(true);
-    expect(fetchInfoMock).toHaveBeenCalledWith({ type: "extraAgents", user: userAddress }, true);
-  });
-  it("rejects an expired API wallet", async () => {
-    fetchInfoMock.mockResolvedValue([{ name: "expired", address: agentWalletAddress, validUntil: Date.now() - 1 }]);
-    await expect(createHyperliquidHelper().checkApiWallet({ userAddress, agentWalletAddress })).resolves.toBe(false);
-  });
-  it("requires the approval to cover the requested fee rather than merely be positive", async () => {
-    fetchInfoMock.mockResolvedValue(6);
-    const helper = createHyperliquidHelper(true);
-    await expect(helper.checkBuilderFeeApproval(userAddress, builderAddress, 10)).resolves.toBe(false);
-    await expect(helper.checkBuilderFeeApproval(userAddress, builderAddress, 6)).resolves.toBe(true);
-    expect(fetchInfoMock).toHaveBeenCalledWith(
-      { type: "maxBuilderFee", user: userAddress, builder: builderAddress },
-      true
-    );
-  });
-  it("preserves the two-argument helper contract as an any-positive-approval check", async () => {
-    fetchInfoMock.mockResolvedValue(1);
-    const approved = await createHyperliquidHelper().checkBuilderFeeApproval(userAddress, builderAddress);
-    expect(approved).toBe(true);
-    expect(fetchInfoMock).toHaveBeenCalledWith(
-      { type: "maxBuilderFee", user: userAddress, builder: builderAddress },
-      false
-    );
-  });
-});

package/dist/helper/lighter/helper.test.js

@@ -1,289 +0,0 @@
-import { vi, describe, beforeEach, it, expect } from 'vitest';
-import { createLighterHelper, findAvailableApiKeyIndex, MAX_API_KEY_INDEX, MIN_USER_API_KEY_INDEX } from './helper';
-
-const {
-  fetchAccountMock,
-  fetchAccountsByL1AddressMock,
-  fetchApiKeysMock,
-  fetchAssetDetailsMock,
-  writeDepositMock,
-  writeWithdrawMock
-} = vi.hoisted(() => ({
-  fetchAccountMock: vi.fn(),
-  fetchAccountsByL1AddressMock: vi.fn(),
-  fetchApiKeysMock: vi.fn(),
-  fetchAssetDetailsMock: vi.fn(),
-  writeDepositMock: vi.fn(),
-  writeWithdrawMock: vi.fn()
-}));
-vi.mock("../../client/lighter/rest", () => ({
-  fetchAccount: fetchAccountMock,
-  fetchAccountsByL1Address: fetchAccountsByL1AddressMock,
-  fetchApiKeys: fetchApiKeysMock,
-  fetchAssetDetails: fetchAssetDetailsMock
-}));
-vi.mock("./ethereum", () => ({
-  writeDeposit: writeDepositMock,
-  writeWithdraw: writeWithdrawMock
-}));
-const createApiKeyMock = vi.fn();
-const changePubKeyMock = vi.fn();
-const prepareApproveIntegratorMock = vi.fn();
-const submitApproveIntegratorMock = vi.fn();
-const signMessageMock = vi.fn();
-const sdk = {
-  core: {
-    misc: {
-      lighter: {
-        createApiKey: createApiKeyMock,
-        changePubKey: changePubKeyMock,
-        prepareApproveIntegrator: prepareApproveIntegratorMock,
-        submitApproveIntegrator: submitApproveIntegratorMock
-      }
-    }
-  }
-};
-const walletClient = {
-  account: { address: "0x0000000000000000000000000000000000000001" },
-  signMessage: signMessageMock
-};
-describe("Lighter helper asset decimals", () => {
-  beforeEach(() => {
-    fetchAssetDetailsMock.mockReset();
-    writeDepositMock.mockReset().mockResolvedValue("0xdeposit");
-    writeWithdrawMock.mockReset().mockResolvedValue("0xwithdraw");
-  });
-  it("uses assetDetails.l1_decimals for Ethereum deposits", async () => {
-    fetchAssetDetailsMock.mockResolvedValue([{ asset_id: 1, symbol: "ETH", l1_decimals: 18, decimals: 8 }]);
-    const helper = createLighterHelper(sdk);
-    await helper.deposit(walletClient, {
-      to: "0x0000000000000000000000000000000000000002",
-      assetId: 1,
-      routeType: 1,
-      amount: "1"
-    });
-    expect(fetchAssetDetailsMock).toHaveBeenCalledWith(false);
-    expect(writeDepositMock).toHaveBeenCalledWith(
-      walletClient,
-      expect.objectContaining({
-        assetIndex: 1,
-        amount: 1000000000000000000n,
-        value: 1000000000000000000n
-      })
-    );
-  });
-  it("rejects demo deposits and withdrawals before reading assets or invoking the wallet writer", async () => {
-    const helper = createLighterHelper(sdk, true);
-    await expect(
-      helper.deposit(walletClient, {
-        to: "0x0000000000000000000000000000000000000002",
-        assetId: 1,
-        routeType: 1,
-        amount: "1"
-      })
-    ).rejects.toThrow("testnet gateway is not verified");
-    await expect(
-      helper.withdraw(walletClient, {
-        accountIndex: 42,
-        assetId: 1,
-        routeType: 1,
-        amount: "1"
-      })
-    ).rejects.toThrow("testnet gateway is not verified");
-    expect(fetchAssetDetailsMock).not.toHaveBeenCalled();
-    expect(writeDepositMock).not.toHaveBeenCalled();
-    expect(writeWithdrawMock).not.toHaveBeenCalled();
-  });
-  it("uses six-decimal USDC L1 precision without sending native value", async () => {
-    fetchAssetDetailsMock.mockResolvedValue([{ asset_id: 3, symbol: "USDC", l1_decimals: 6, decimals: 6 }]);
-    const helper = createLighterHelper(sdk);
-    await helper.deposit(walletClient, {
-      to: "0x0000000000000000000000000000000000000002",
-      assetId: 3,
-      routeType: 0,
-      amount: "1.25"
-    });
-    expect(writeDepositMock).toHaveBeenCalledWith(
-      walletClient,
-      expect.objectContaining({ assetIndex: 3, amount: 1250000n, value: void 0 })
-    );
-  });
-  it("rejects mismatched native ETH amount and msg.value before submitting", async () => {
-    fetchAssetDetailsMock.mockResolvedValue([{ asset_id: 1, symbol: "ETH", l1_decimals: 18, decimals: 8 }]);
-    const helper = createLighterHelper(sdk);
-    await expect(
-      helper.deposit(walletClient, {
-        to: "0x0000000000000000000000000000000000000002",
-        assetId: 1,
-        routeType: 1,
-        amount: "1",
-        nativeValue: "0.5"
-      })
-    ).rejects.toThrow("native ETH deposit amount and msg.value must match");
-    expect(writeDepositMock).not.toHaveBeenCalled();
-  });
-  it("uses assetDetails.decimals for Lighter withdrawal base amounts", async () => {
-    fetchAssetDetailsMock.mockResolvedValue([{ asset_id: 1, symbol: "ETH", l1_decimals: 18, decimals: 8 }]);
-    const helper = createLighterHelper(sdk, false);
-    await helper.withdraw(walletClient, { accountIndex: 42, assetId: 1, routeType: 1, amount: "1" });
-    expect(fetchAssetDetailsMock).toHaveBeenCalledWith(false);
-    expect(writeWithdrawMock).toHaveBeenCalledWith(
-      walletClient,
-      expect.objectContaining({ assetIndex: 1, baseAmount: 100000000n })
-    );
-  });
-  it("accepts cached authoritative decimals without another assetDetails request", async () => {
-    const helper = createLighterHelper(sdk);
-    await helper.deposit(walletClient, {
-      to: "0x0000000000000000000000000000000000000002",
-      assetId: 999,
-      routeType: 1,
-      amount: "1.25",
-      l1Decimals: 6
-    });
-    expect(fetchAssetDetailsMock).not.toHaveBeenCalled();
-    expect(writeDepositMock).toHaveBeenCalledWith(
-      walletClient,
-      expect.objectContaining({ assetIndex: 999, amount: 1250000n })
-    );
-  });
-});
-describe("Lighter helper integrator approval validation", () => {
-  const approval = {
-    account_index: 728059,
-    name: "Pear",
-    max_perps_taker_fee: 600,
-    max_perps_maker_fee: 500,
-    max_spot_taker_fee: 0,
-    max_spot_maker_fee: 0,
-    approval_expiry: 4e12
-  };
-  beforeEach(() => {
-    fetchAccountMock.mockReset().mockResolvedValue({
-      code: 200,
-      accounts: [{ approved_integrators: [approval] }]
-    });
-  });
-  it("requires a future approval with sufficient maker and taker fee caps", async () => {
-    const helper = createLighterHelper(sdk, true);
-    await expect(
-      helper.checkIntegratorApproval(42, approval.account_index, {
-        minPerpsMakerFee: 500,
-        minPerpsTakerFee: 600
-      })
-    ).resolves.toBe(true);
-    expect(fetchAccountMock).toHaveBeenCalledWith(42, true);
-  });
-  it("rejects expired approvals even when no fee requirements are supplied", async () => {
-    fetchAccountMock.mockResolvedValue({
-      code: 200,
-      accounts: [{ approved_integrators: [{ ...approval, approval_expiry: 1 }] }]
-    });
-    const helper = createLighterHelper(sdk);
-    await expect(helper.checkIntegratorApproval(42, approval.account_index)).resolves.toBe(false);
-  });
-  it("rejects approval caps below either configured requirement", async () => {
-    const helper = createLighterHelper(sdk);
-    await expect(
-      helper.checkIntegratorApproval(42, approval.account_index, {
-        minPerpsMakerFee: 501,
-        minPerpsTakerFee: 600
-      })
-    ).resolves.toBe(false);
-    await expect(
-      helper.checkIntegratorApproval(42, approval.account_index, {
-        minPerpsMakerFee: 500,
-        minPerpsTakerFee: 601
-      })
-    ).resolves.toBe(false);
-  });
-});
-describe("Lighter helper API key allocation", () => {
-  beforeEach(() => {
-    fetchApiKeysMock.mockReset();
-    createApiKeyMock.mockReset();
-    changePubKeyMock.mockReset();
-    signMessageMock.mockReset();
-  });
-  it("uses the first free non-reserved index instead of growing past gaps", () => {
-    expect(findAvailableApiKeyIndex([{ api_key_index: 0 }, { api_key_index: 4 }, { api_key_index: 6 }])).toBe(5);
-  });
-  it("throws once every documented user API-key slot from 4 through 254 is occupied", () => {
-    const keys = Array.from({ length: MAX_API_KEY_INDEX - MIN_USER_API_KEY_INDEX + 1 }, (_, offset) => ({
-      api_key_index: MIN_USER_API_KEY_INDEX + offset
-    }));
-    expect(() => findAvailableApiKeyIndex(keys)).toThrow("No available Lighter API key slots");
-  });
-  it("fails before signing when the account has no free user API-key slot", async () => {
-    fetchApiKeysMock.mockResolvedValue(
-      Array.from({ length: MAX_API_KEY_INDEX - MIN_USER_API_KEY_INDEX + 1 }, (_, offset) => ({
-        api_key_index: MIN_USER_API_KEY_INDEX + offset
-      }))
-    );
-    const helper = createLighterHelper(sdk);
-    await expect(helper.connectWallet(walletClient, { accountIndex: 42 })).rejects.toThrow(
-      "No available Lighter API key slots"
-    );
-    expect(fetchApiKeysMock).toHaveBeenCalledWith(42, false);
-    expect(createApiKeyMock).not.toHaveBeenCalled();
-    expect(signMessageMock).not.toHaveBeenCalled();
-    expect(changePubKeyMock).not.toHaveBeenCalled();
-  });
-  it("submits mainnet API-key preparation and association without unsupported fields", async () => {
-    fetchApiKeysMock.mockResolvedValue([]);
-    createApiKeyMock.mockResolvedValue({ privateKey: "private", messageToSign: "message", txInfo: "tx-info" });
-    signMessageMock.mockResolvedValue("0xsignature");
-    changePubKeyMock.mockResolvedValue({ txHash: "tx-hash" });
-    await createLighterHelper(sdk).connectWallet(walletClient, { accountIndex: 42 });
-    expect(createApiKeyMock).toHaveBeenCalledWith({ accountIndex: 42, apiKeyIndex: 4 });
-    expect(changePubKeyMock).toHaveBeenCalledWith({
-      l1Signature: "0xsignature",
-      txInfo: "tx-info",
-      accountIndex: 42,
-      apiKeyIndex: 4
-    });
-  });
-  it("rejects demo wallet connection before public reads or backend signing", async () => {
-    await expect(createLighterHelper(sdk, true).connectWallet(walletClient, { accountIndex: 42 })).rejects.toThrow(
-      "backend signing is mainnet-only"
-    );
-    expect(fetchApiKeysMock).not.toHaveBeenCalled();
-    expect(createApiKeyMock).not.toHaveBeenCalled();
-  });
-});
-describe("Lighter helper integrator approval submission", () => {
-  beforeEach(() => {
-    prepareApproveIntegratorMock.mockReset().mockResolvedValue({ messageToSign: "message", txInfo: "tx-info" });
-    submitApproveIntegratorMock.mockReset().mockResolvedValue({ txHash: "tx-hash" });
-    signMessageMock.mockReset().mockResolvedValue("0xsignature");
-  });
-  it("submits mainnet approval preparation and association without unsupported fields", async () => {
-    await createLighterHelper(sdk).approveIntegrator(walletClient, {
-      accountIndex: 42,
-      apiKeyIndex: 4,
-      apiPrivateKey: "private"
-    });
-    expect(prepareApproveIntegratorMock).toHaveBeenCalledWith({
-      accountIndex: 42,
-      apiKeyIndex: 4,
-      apiPrivateKey: "private"
-    });
-    expect(submitApproveIntegratorMock).toHaveBeenCalledWith({
-      l1Signature: "0xsignature",
-      txInfo: "tx-info",
-      accountIndex: 42,
-      apiKeyIndex: 4
-    });
-  });
-  it("rejects demo approval before backend signing", async () => {
-    await expect(
-      createLighterHelper(sdk, true).approveIntegrator(walletClient, {
-        accountIndex: 42,
-        apiKeyIndex: 4,
-        apiPrivateKey: "private"
-      })
-    ).rejects.toThrow("backend signing is mainnet-only");
-    expect(prepareApproveIntegratorMock).not.toHaveBeenCalled();
-    expect(submitApproveIntegratorMock).not.toHaveBeenCalled();
-  });
-});