@steerprotocol/sdk 1.30.8 → 2.0.0

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

@@ -1,99 +0,0 @@
-import { createPublicClient, http } from 'viem';
-import { polygon } from 'viem/chains';
-import { SubgraphClient } from '../../base/SubgraphClient.js';
-import { SteerResponse } from '../../types.js';
-
-// Create a concrete implementation for testing
-class TestSubgraphClient extends SubgraphClient {
-  public async testQuery<T>(query: string, variables?: Record<string, unknown>): Promise<SteerResponse<T>> {
-    return this.executeSubgraphQuery<T>(query, variables);
-  }
-
-  public getTestSubgraphUrl(chainId: number): string | undefined {
-    return this.getSubgraphUrl(chainId);
-  }
-}
-
-
-const RPC_URL = 'https://polygon-mainnet.g.alchemy.com/v2/VjQCxdNfXfyvPacuKwjsrhOsWc_g6X27'
-
-describe('SubgraphClient', () => {
-  let client: TestSubgraphClient;
-  
-  beforeEach(() => {
-    const viemClient = createPublicClient({
-      chain: polygon,
-      transport: http(RPC_URL)
-    });
-    client = new TestSubgraphClient(viemClient);
-  });
-
-  describe('supportsChain', () => {
-    it('should return true for supported chains', () => {
-      const result = client.supportsChain(137);
-      expect(result).toBe(true);
-    });
-
-    it('should return false for unsupported chains', () => {
-      const result = client.supportsChain(999999);
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('executeSubgraphQuery', () => {
-    it('should throw error when no active chain is found', async () => {
-      const clientWithNoChain = new TestSubgraphClient(createPublicClient({
-        transport: http(RPC_URL)
-      }));
-
-      await expect(clientWithNoChain.testQuery('{ test }'))
-        .rejects
-        .toThrow('No active chain found');
-    });
-
-    it('should handle GraphQL errors gracefully', async () => {
-      global.fetch = jest.fn().mockImplementationOnce(() =>
-        Promise.resolve({
-          ok: true,
-          status: 200,
-          json: () => Promise.resolve({ errors: [{ message: 'GraphQL Error' }] }),
-        })
-      );
-
-      const response = await client.testQuery('{ test }');
-      expect(response.success).toBe(false);
-      expect(response.error).toBeDefined();
-      expect(response.status).toBe(500);
-    });
-
-    it('should handle network errors gracefully', async () => {
-      global.fetch = jest.fn().mockImplementationOnce(() =>
-        Promise.resolve({
-          ok: false,
-          status: 404,
-        })
-      );
-
-      const response = await client.testQuery('{ test }');
-      expect(response.success).toBe(false);
-      expect(response.error).toContain('HTTP error');
-      expect(response.status).toBe(500);
-    });
-
-    it('should handle successful queries', async () => {
-      const mockData = { protocol: { id: '1', totalValueLockedUSD: '1000000' } };
-      global.fetch = jest.fn().mockImplementationOnce(() =>
-        Promise.resolve({
-          ok: true,
-          status: 200,
-          json: () => Promise.resolve({ data: mockData }),
-        })
-      );
-
-      const response = await client.testQuery('{ protocol { id } }');
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toEqual(mockData);
-    });
-  });
-}); 

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

@@ -1,179 +0,0 @@
-import type { PublicClient, WalletClient } from 'viem';
-import { VaultClient } 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 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,
-    },
-  },
-});
-
-describe('VaultClient protocol filtering', () => {
-  let vaultClient: VaultClient;
-  let vaultsMock: jest.Mock;
-
-  beforeEach(() => {
-    vaultClient = new VaultClient(
-      {} as PublicClient,
-      {} as WalletClient,
-      'production'
-    );
-
-    vaultsMock = jest.fn();
-    (vaultClient as unknown as { apiClient: { vaults: jest.Mock } }).apiClient = {
-      vaults: vaultsMock,
-    };
-  });
-
-  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 response = await vaultClient.getVaults({
-      chainId: ChainId.Polygon,
-      protocol: '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');
-  });
-
-  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 response = await vaultClient.getAllVaults(
-      {
-        chainId: ChainId.Polygon,
-        protocol: 'Sushi',
-      },
-      2
-    );
-
-    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);
-  });
-});