@pear-protocol/exchanges-sdk 0.3.0 → 0.4.0

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

@@ -0,0 +1,289 @@
+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();
+  });
+});

package/dist/helper/lighter/types.js

@@ -6,13 +6,14 @@ const AssetId = {
   UNI: 6,
   AAVE: 7,
   SKY: 8,
-  LDO: 9
+  LDO: 9,
+  AZTEC: 10
 };
 const RouteType = {
   PERP: 0,
   SPOT: 1
 };
-const ASSET_DECIMALS = {
+const L2_ASSET_DECIMALS = {
   [AssetId.ETH]: 8,
   [AssetId.LIT]: 8,
   [AssetId.USDC]: 6,
@@ -20,16 +21,16 @@ const ASSET_DECIMALS = {
   [AssetId.UNI]: 8,
   [AssetId.AAVE]: 8,
   [AssetId.SKY]: 8,
-  [AssetId.LDO]: 8
+  [AssetId.LDO]: 8,
+  [AssetId.AZTEC]: 8
 };
+const ASSET_DECIMALS = L2_ASSET_DECIMALS;
 function getAssetDecimals(assetId) {
-  const decimals = ASSET_DECIMALS[assetId];
+  const decimals = L2_ASSET_DECIMALS[assetId];
   if (decimals === void 0) {
-    throw new Error(
-      `Unknown lighter asset ID: ${assetId}. Provide decimals via ASSET_DECIMALS or use a known AssetId.`
-    );
+    throw new Error(`Unknown Lighter asset ID: ${assetId}. Read its decimals from the assetDetails endpoint.`);
   }
   return decimals;
 }
 
-export { ASSET_DECIMALS, AssetId, RouteType, getAssetDecimals };
+export { ASSET_DECIMALS, AssetId, L2_ASSET_DECIMALS, RouteType, getAssetDecimals };