@steerprotocol/sdk 1.30.8-test-algebra-plugins.2 → 1.31.0

package/src/__tests__/base/StakingClient.test.ts

@@ -1,3 +1,5 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
 import { createTestClient, http, publicActions, walletActions } from 'viem';
 import { foundry } from 'viem/chains';
 import { StakingClient } from '../../base/StakingClient.js';
@@ -5,7 +7,24 @@ import { privateKeyToAccount } from 'viem/accounts';
 import { createPublicClient, createWalletClient } from 'viem';
 import { kava } from 'viem/chains';
 import { SteerClient } from '../../client.js';
-import { StakingProtocol } from '../../const/protocol.js';
+import { StakingProtocol, isValidStakingProtocol, normalizeProtocol } from '../../const/protocol.js';
+
+const stakingPoolsFixturePath = resolve(__dirname, '../fixtures/live/staking-pools.fixture.json');
+const stakingPoolsFixture = JSON.parse(readFileSync(stakingPoolsFixturePath, 'utf8')) as {
+  livePools: any[];
+  selectedPools: any[];
+};
+
+const dedupedFixturePools = [...stakingPoolsFixture.livePools, ...stakingPoolsFixture.selectedPools].filter(
+  (pool, index, pools) => pools.findIndex((item) => item.stakingPool === pool.stakingPool) === index,
+);
+
+const normalizedFixturePools = dedupedFixturePools
+  .filter((pool) => isValidStakingProtocol(pool.protocol))
+  .map((pool) => ({
+    ...pool,
+    protocol: normalizeProtocol(pool.protocol),
+  }));
 
 describe('StakingClient', () => {
   let client: StakingClient;
@@ -28,131 +47,104 @@ describe('StakingClient', () => {
   });
 
   describe('getStakingPools', () => {
-    // const mockStakingPools = [
-    //   {
-    //     chainId: 137,
-    //     stakingPool: '0x1234567890123456789012345678901234567890',
-    //     protocol: 'forge', // lowercase protocol
-    //     isDualFactory: true,
-    //     dailyEmissionRewardA: 657.6,
-    //     dailyEmissionRewardB: 11234.624,
-    //     rewardTokenA: '0xD4949664cD82660AaE99bEdc034a0deA8A0bd517',
-    //     rewardTokenB: '0x98fAFD9F714CE0B4bB2870527076F2F314aAed82',
-    //     periodFinish: (Math.floor(Date.now() / 1000) + 86400).toString(), // 24 hours from now
-    //     rewardsDuration: '604800'
-    //   },
-    //   {
-    //     chainId: 1,
-    //     stakingPool: '0x2234567890123456789012345678901234567890',
-    //     protocol: 'ARTHSWAP', // uppercase protocol
-    //     isDualFactory: false,
-    //     dailyEmissionRewardA: 100,
-    //     dailyEmissionRewardB: 0,
-    //     rewardTokenA: '0xD4949664cD82660AaE99bEdc034a0deA8A0bd517',
-    //     rewardTokenB: '',
-    //     periodFinish: (Math.floor(Date.now() / 1000) - 86400).toString(), // 24 hours ago
-    //     rewardsDuration: '604800'
-    //   },
-    //   {
-    //     chainId: 137,
-    //     stakingPool: '0x3234567890123456789012345678901234567890',
-    //     protocol: 'Forge', // correct case protocol
-    //     isDualFactory: true,
-    //     dailyEmissionRewardA: 1000,
-    //     dailyEmissionRewardB: 2000,
-    //     rewardTokenA: '0xD4949664cD82660AaE99bEdc034a0deA8A0bd517',
-    //     rewardTokenB: '0x98fAFD9F714CE0B4bB2870527076F2F314aAed82',
-    //     periodFinish: (Math.floor(Date.now() / 1000) + 86400).toString(), // 24 hours from now
-    //     rewardsDuration: '604800'
-    //   }
-    // ];
-
     beforeEach(() => {
-      // global.fetch = jest.fn().mockResolvedValue({
-      //   ok: true,
-      //   json: async () => ({ pools: mockStakingPools }),
-      // });
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({ pools: dedupedFixturePools }),
+      });
     });
 
     it('should fetch all staking pools without filters', async () => {
       const response = await client.getStakingPools();
       expect(response.success).toBe(true);
       expect(response.status).toBe(200);
-      expect(response.data).toHaveLength(3);
+      expect(response.data).toHaveLength(normalizedFixturePools.length);
     });
 
     it('should filter pools by chainId', async () => {
+      const expected = normalizedFixturePools.filter((pool) => pool.chainId === 2222);
       const response = await client.getStakingPools({
-        chainId: 137
+        chainId: 2222
       });
       expect(response.success).toBe(true);
-      expect(response.data).toHaveLength(2);
-      expect(response.data!.every(pool => pool.chainId === 137)).toBe(true);
+      expect(response.data).toHaveLength(expected.length);
+      expect(response.data!.every(pool => pool.chainId === 2222)).toBe(true);
     });
 
     it('should filter pools by chainId and protocol', async () => {
+      const expected = normalizedFixturePools.filter(
+        (pool) => pool.chainId === 2222 && pool.protocol === StakingProtocol.Kinetix,
+      );
       const response = await client.getStakingPools({
         chainId: 2222,
         protocol: StakingProtocol.Kinetix
       });
       expect(response.success).toBe(true);
-      expect(response.data).toHaveLength(2);
+      expect(response.data).toHaveLength(expected.length);
       expect(response.data!.every(pool => 
-        pool.chainId === 137 && pool.protocol === StakingProtocol.Forge
+        pool.chainId === 2222 && pool.protocol === StakingProtocol.Kinetix
       )).toBe(true);
     });
 
     it('should filter live pools', async () => {
+      const now = Math.floor(Date.now() / 1000);
+      const expected = normalizedFixturePools.filter((pool) => parseInt(pool.periodFinish) > now);
       const response = await client.getStakingPools({
         isLive: true
       });
       expect(response.success).toBe(true);
-      expect(response.data!.length).toBe(2);
+      expect(response.data!.length).toBe(expected.length);
       expect(response.data!.every(pool => {
-        const now = Math.floor(Date.now() / 1000);
         return parseInt(pool.periodFinish) > now;
       })).toBe(true);
     });
 
     it('should filter by chainId and live status', async () => {
+      const now = Math.floor(Date.now() / 1000);
+      const expected = normalizedFixturePools.filter(
+        (pool) => pool.chainId === 8453 && parseInt(pool.periodFinish) > now,
+      );
       const response = await client.getStakingPools({
-        chainId: 2222,
+        chainId: 8453,
         isLive: true
       });
       expect(response.success).toBe(true);
-      expect(response.data!.length).toBe(2);
+      expect(response.data!.length).toBe(expected.length);
       expect(response.data!.every(pool => {
-        const now = Math.floor(Date.now() / 1000);
-        return pool.chainId === 137 && parseInt(pool.periodFinish) > now;
+        return pool.chainId === 8453 && parseInt(pool.periodFinish) > now;
       })).toBe(true);
     });
 
     it('should filter using multiple criteria', async () => {
+      const expected = normalizedFixturePools.filter(
+        (pool) =>
+          pool.chainId === 2222 &&
+          pool.protocol === StakingProtocol.Kinetix &&
+          pool.isDualFactory === true,
+      );
       const response = await client.getStakingPools({
-        chainId: 137,
-        protocol: StakingProtocol.Forge,
-        isLive: true,
+        chainId: 2222,
+        protocol: StakingProtocol.Kinetix,
         isDualRewards: true
       });
       
       expect(response.success).toBe(true);
-      expect(response.data!.length).toBe(2);
+      expect(response.data!.length).toBe(expected.length);
       expect(response.data!.every(pool => {
-        const now = Math.floor(Date.now() / 1000);
-        return pool.chainId === 137 &&
-               pool.protocol === StakingProtocol.Forge &&
-               parseInt(pool.periodFinish) > now &&
+        return pool.chainId === 2222 &&
+               pool.protocol === StakingProtocol.Kinetix &&
                pool.isDualFactory === true;
       })).toBe(true);
     });
 
     it('should filter by minimum daily emissions', async () => {
+      const expected = normalizedFixturePools.filter((pool) => pool.dailyEmissionRewardA >= 800);
       const response = await client.getStakingPools({
         minDailyEmissionA: 800
       });
       
       expect(response.success).toBe(true);
-      expect(response.data!.length).toBe(1);
+      expect(response.data!.length).toBe(expected.length);
       expect(response.data!.every(pool => pool.dailyEmissionRewardA >= 800)).toBe(true);
     });
 
@@ -170,7 +162,7 @@ describe('StakingClient', () => {
 
     it('should return empty array when no pools match filters', async () => {
       const response = await client.getStakingPools({
-        chainId: 999, // non-existent chain
+        chainId: 999,
         protocol: StakingProtocol.ArthSwap
       });
       
@@ -179,12 +171,13 @@ describe('StakingClient', () => {
     });
 
     it('should handle case-insensitive protocol matching', async () => {
+      const expected = normalizedFixturePools.filter((pool) => pool.protocol === StakingProtocol.Forge);
       const response = await client.getStakingPools({
         protocol: StakingProtocol.Forge
       });
       
       expect(response.success).toBe(true);
-      expect(response.data!.length).toBe(2);
+      expect(response.data!.length).toBe(expected.length);
       expect(response.data!.every(pool => pool.protocol === StakingProtocol.Forge)).toBe(true);
     });
 
@@ -192,9 +185,10 @@ describe('StakingClient', () => {
       const response = await client.getStakingPools();
       
       expect(response.success).toBe(true);
-      expect(response.data!.length).toBe(3);
+      expect(response.data!.length).toBe(normalizedFixturePools.length);
       expect(response.data!.find(pool => pool.protocol === StakingProtocol.ArthSwap)).toBeDefined();
-      expect(response.data!.filter(pool => pool.protocol === StakingProtocol.Forge)).toHaveLength(2);
+      expect(response.data!.find(pool => pool.protocol === StakingProtocol.Kinetix)).toBeDefined();
+      expect(response.data!.find(pool => pool.protocol === StakingProtocol.QuickSwapV3)).toBeDefined();
     });
   });
 
@@ -427,7 +421,10 @@ describe('StakingClient', () => {
       expect(poolsResponse.success).toBe(true);
       expect(poolsResponse.data).toBeDefined();
       expect(Array.isArray(poolsResponse.data)).toBe(true);
-      expect(poolsResponse.data!.length).toBeGreaterThan(0);
+      if (poolsResponse.data!.length === 0) {
+        console.log('No active staking pools found on Polygon');
+        return;
+      }
 
       // Log the number of active pools found
       console.log(`Found ${poolsResponse.data!.length} active staking pools on Polygon`);
@@ -504,7 +501,10 @@ describe('StakingClient', () => {
       });
 
       expect(poolsResponse.success).toBe(true);
-      expect(poolsResponse.data!.length).toBeGreaterThan(0);
+      if (poolsResponse.data!.length === 0) {
+        console.log('No active pools found to test totalSupply and balanceOf');
+        return;
+      }
 
       // Check first active pool
       const testPool = poolsResponse.data![0];
@@ -769,4 +769,4 @@ describe('StakingClient', () => {
   afterEach(() => {
     jest.restoreAllMocks();
   });
-}); 
+}); 

package/src/__tests__/base/VaultClient.protocol-filter.test.ts

@@ -1,104 +1,25 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
 import type { PublicClient, WalletClient } from 'viem';
-import { VaultClient } from '../../base/VaultClient.js';
+import { VaultClient, type VaultEdge, type VaultNode } from '../../base/VaultClient.js';
 import { ChainId } from '../../const/chain.js';
 
-type ApiVaultEdge = {
-  cursor: string;
-  node: {
-    id: string;
-    chainId: number;
-    vaultAddress: string;
-    protocol: string;
-    beaconName: string;
-    protocolBaseType: string;
-    name: string;
-    feeApr?: number | null;
-    stakingApr?: number | null;
-    merklApr?: number | null;
-    pool?: {
-      id?: string;
-      poolAddress?: string;
-      feeTier?: string;
-    };
-    token0?: {
-      id?: string;
-      symbol?: string;
-      name?: string;
-      decimals?: number;
-      address?: string;
-      chainId?: number;
-    };
-    token1?: {
-      id?: string;
-      symbol?: string;
-      name?: string;
-      decimals?: number;
-      address?: string;
-      chainId?: number;
-    };
-  };
+const fixture = JSON.parse(
+  readFileSync(resolve(__dirname, '../fixtures/live/vaults.fixture.json'), 'utf8'),
+) as {
+  selectedForProtocolFilter: VaultNode[];
+  selectedForPagination: VaultNode[];
 };
 
-const buildApiVaultEdge = (
-  id: string,
-  protocol: string,
-  beaconName: string = `MultiPosition${protocol}`
-): ApiVaultEdge => ({
-  cursor: id,
-  node: {
-    id,
-    chainId: ChainId.Polygon,
-    vaultAddress: `0x${id.padEnd(40, '0').slice(0, 40)}`,
-    protocol,
-    beaconName,
-    protocolBaseType: protocol,
-    name: `${protocol} vault`,
-    pool: {
-      id: `pool-${id}`,
-      poolAddress: `pool-${id}`,
-      feeTier: '3000',
-    },
-    token0: {
-      id: 'token0',
-      symbol: 'USDC',
-      name: 'USD Coin',
-      decimals: 6,
-      address: '0x0000000000000000000000000000000000000001',
-      chainId: ChainId.Polygon,
-    },
-    token1: {
-      id: 'token1',
-      symbol: 'WETH',
-      name: 'Wrapped Ether',
-      decimals: 18,
-      address: '0x0000000000000000000000000000000000000002',
-      chainId: ChainId.Polygon,
-    },
-  },
-});
-
-const buildApiVaultsResponse = (
-  edges: ApiVaultEdge[],
-  hasNextPage: boolean,
-  endCursor: string | null,
-  totalCount: number = edges.length
-) => ({
-  status: 200,
-  data: {
-    vaults: {
-      edges,
-      pageInfo: {
-        hasNextPage,
-        endCursor,
-      },
-      totalCount,
-    },
-  },
+const toEdge = (node: VaultNode, index: number): VaultEdge => ({
+  cursor: `fixture_${index}_${node.vaultAddress.toLowerCase()}`,
+  node,
 });
 
 describe('VaultClient protocol filtering', () => {
   let vaultClient: VaultClient;
-  let vaultsMock: jest.Mock;
+  let getAllVaultsFromApiSpy: jest.SpyInstance;
+  let getAllVaultsFromSubgraphSpy: jest.SpyInstance;
 
   beforeEach(() => {
     vaultClient = new VaultClient(
@@ -106,74 +27,80 @@ describe('VaultClient protocol filtering', () => {
       {} as WalletClient,
       'production'
     );
-
-    vaultsMock = jest.fn();
-    (vaultClient as unknown as { apiClient: { vaults: jest.Mock } }).apiClient = {
-      vaults: vaultsMock,
-    };
+    getAllVaultsFromApiSpy = jest.spyOn(vaultClient as any, 'getAllVaultsFromApi');
+    getAllVaultsFromSubgraphSpy = jest.spyOn(vaultClient as any, 'getAllVaultsFromSubgraph');
   });
 
   it('filters getVaults results by protocol even when API returns mixed protocols', async () => {
-    vaultsMock.mockResolvedValue(
-      buildApiVaultsResponse(
-        [
-          buildApiVaultEdge('vault-sushi', 'Sushi', 'MultiPositionSushi'),
-          buildApiVaultEdge('vault-uni', 'Uniswap', 'MultiPositionUniswapV3'),
-        ],
-        false,
-        null
-      )
-    );
+    const protocolFixtureNodes = (fixture.selectedForProtocolFilter as VaultNode[]).map((vault) => ({
+      ...vault,
+      chainId: ChainId.Polygon,
+    }));
+    const protocolEdges = protocolFixtureNodes.map(toEdge);
+
+    getAllVaultsFromApiSpy.mockResolvedValue({
+      success: true,
+      status: 200,
+      data: protocolEdges.slice(0, 2),
+    });
+    getAllVaultsFromSubgraphSpy.mockResolvedValue({
+      success: true,
+      status: 200,
+      data: protocolEdges.slice(2),
+    });
 
     const response = await vaultClient.getVaults({
       chainId: ChainId.Polygon,
       protocol: 'sushi',
     });
 
+    const expectedSushi = protocolFixtureNodes.filter((vault) =>
+      String(vault.beaconName || '').toLowerCase().includes('sushi'),
+    );
+
     expect(response.success).toBe(true);
     expect(response.status).toBe(200);
-    expect(response.data?.edges).toHaveLength(1);
-    expect(response.data?.edges[0]?.node.id).toBe('vault-sushi');
-    expect(response.data?.edges[0]?.node.protocol).toBe('Sushi');
+    expect(response.data?.edges).toHaveLength(expectedSushi.length);
+    expect(response.data?.edges.every((edge) => edge.node.beaconName.toLowerCase().includes('sushi'))).toBe(true);
+    expect(getAllVaultsFromApiSpy).toHaveBeenCalledTimes(1);
+    expect(getAllVaultsFromSubgraphSpy).toHaveBeenCalledTimes(1);
   });
 
   it('filters all pages in getAllVaults by protocol', async () => {
-    vaultsMock
-      .mockResolvedValueOnce(
-        buildApiVaultsResponse(
-          [
-            buildApiVaultEdge('vault-uni-1', 'Uniswap', 'MultiPositionUniswapV3'),
-            buildApiVaultEdge('vault-sushi-1', 'Sushi', 'MultiPositionSushi'),
-          ],
-          true,
-          'cursor-1',
-          4
-        )
-      )
-      .mockResolvedValueOnce(
-        buildApiVaultsResponse(
-          [
-            buildApiVaultEdge('vault-thena-1', 'Thena', 'MultiPositionThena'),
-            buildApiVaultEdge('vault-sushi-2', 'Sushi', 'MultiPositionSushiManaged'),
-          ],
-          false,
-          'cursor-2',
-          4
-        )
-      );
+    const paginationFixtureNodes = (fixture.selectedForPagination as VaultNode[]).slice(0, 120).map((vault) => ({
+      ...vault,
+      chainId: ChainId.Polygon,
+    }));
+    const paginationEdges = paginationFixtureNodes.map(toEdge);
+
+    getAllVaultsFromApiSpy.mockResolvedValue({
+      success: true,
+      status: 200,
+      data: paginationEdges,
+    });
+    getAllVaultsFromSubgraphSpy.mockResolvedValue({
+      success: true,
+      status: 200,
+      data: [],
+    });
 
     const response = await vaultClient.getAllVaults(
       {
         chainId: ChainId.Polygon,
         protocol: 'Sushi',
       },
-      2
+      25
     );
 
+    const expectedSushiCount = paginationFixtureNodes.filter((vault) =>
+      String(vault.beaconName || '').toLowerCase().includes('sushi'),
+    ).length;
+
     expect(response.success).toBe(true);
     expect(response.status).toBe(200);
-    expect(response.data).toHaveLength(2);
-    expect(response.data?.map(vault => vault.id)).toEqual(['vault-sushi-1', 'vault-sushi-2']);
-    expect(response.data?.every(vault => vault.protocol === 'Sushi')).toBe(true);
+    expect(response.data).toHaveLength(expectedSushiCount);
+    expect(response.data?.every((vault) => vault.beaconName.toLowerCase().includes('sushi'))).toBe(true);
+    expect(getAllVaultsFromApiSpy).toHaveBeenCalled();
+    expect(getAllVaultsFromSubgraphSpy).toHaveBeenCalled();
   });
 });