@steerprotocol/sdk 1.31.0 → 2.0.1

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

@@ -1,772 +0,0 @@
-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';
-import { privateKeyToAccount } from 'viem/accounts';
-import { createPublicClient, createWalletClient } from 'viem';
-import { kava } from 'viem/chains';
-import { SteerClient } from '../../client.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;
-
-  beforeEach(() => {
-    const testClient = createTestClient({
-      account: privateKeyToAccount("0x40199ba8875ac583658a7e936e16354f4bf1ea54dac73a2bc24fd17159ceb820"),
-      chain: {
-        ...foundry,
-        id: 137
-      },
-      mode: 'anvil',      
-      transport: http(),
-    })
-      .extend(publicActions)
-      .extend(walletActions);
-
-    // @ts-expect-error test client is not a PublicClient
-    client = new StakingClient(testClient);
-  });
-
-  describe('getStakingPools', () => {
-    beforeEach(() => {
-      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(normalizedFixturePools.length);
-    });
-
-    it('should filter pools by chainId', async () => {
-      const expected = normalizedFixturePools.filter((pool) => pool.chainId === 2222);
-      const response = await client.getStakingPools({
-        chainId: 2222
-      });
-      expect(response.success).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(expected.length);
-      expect(response.data!.every(pool => 
-        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(expected.length);
-      expect(response.data!.every(pool => {
-        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: 8453,
-        isLive: true
-      });
-      expect(response.success).toBe(true);
-      expect(response.data!.length).toBe(expected.length);
-      expect(response.data!.every(pool => {
-        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: 2222,
-        protocol: StakingProtocol.Kinetix,
-        isDualRewards: true
-      });
-      
-      expect(response.success).toBe(true);
-      expect(response.data!.length).toBe(expected.length);
-      expect(response.data!.every(pool => {
-        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(expected.length);
-      expect(response.data!.every(pool => pool.dailyEmissionRewardA >= 800)).toBe(true);
-    });
-
-    it('should handle API errors gracefully', async () => {
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: false,
-        status: 500,
-      });
-
-      const response = await client.getStakingPools();
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-    });
-
-    it('should return empty array when no pools match filters', async () => {
-      const response = await client.getStakingPools({
-        chainId: 999,
-        protocol: StakingProtocol.ArthSwap
-      });
-      
-      expect(response.success).toBe(true);
-      expect(response.data).toHaveLength(0);
-    });
-
-    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(expected.length);
-      expect(response.data!.every(pool => pool.protocol === StakingProtocol.Forge)).toBe(true);
-    });
-
-    it('should normalize protocols in response', async () => {
-      const response = await client.getStakingPools();
-      
-      expect(response.success).toBe(true);
-      expect(response.data!.length).toBe(normalizedFixturePools.length);
-      expect(response.data!.find(pool => pool.protocol === StakingProtocol.ArthSwap)).toBeDefined();
-      expect(response.data!.find(pool => pool.protocol === StakingProtocol.Kinetix)).toBeDefined();
-      expect(response.data!.find(pool => pool.protocol === StakingProtocol.QuickSwapV3)).toBeDefined();
-    });
-  });
-
-  describe('earned', () => {
-    const testPool = '0x1234567890123456789012345678901234567890';
-    const testAccount = '0x2234567890123456789012345678901234567890';
-    const mockRewardA = BigInt(1000);
-    const mockRewardB = BigInt(2000);
-
-    it('should get earned rewards for single reward pool', async () => {
-      // Mock earned call succeeding for single reward
-      jest.spyOn(client['publicClient'], 'readContract')
-        .mockResolvedValueOnce(mockRewardA);
-
-      const response = await client.earned(
-        testPool as `0x${string}`,
-        testAccount as `0x${string}`
-      );
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-      expect(response.data!.rewardA).toBe(mockRewardA);
-      expect(response.data!.rewardB).toBeUndefined();
-    });
-
-    it('should get earned rewards for dual reward pool', async () => {
-      // Mock single reward failing and dual rewards succeeding
-      jest.spyOn(client['publicClient'], 'readContract')
-        .mockRejectedValueOnce(new Error('Not a single reward pool'))
-        .mockResolvedValueOnce(mockRewardA)  // earnedA
-        .mockResolvedValueOnce(mockRewardB); // earnedB
-
-      const response = await client.earned(
-        testPool as `0x${string}`,
-        testAccount as `0x${string}`
-      );
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-      expect(response.data!.rewardA).toBe(mockRewardA);
-      expect(response.data!.rewardB).toBe(mockRewardB);
-    });
-
-    it('should handle errors when getting earned rewards', async () => {
-      jest.spyOn(client['publicClient'], 'readContract')
-        .mockRejectedValue(new Error('Contract call failed'));
-
-      const response = await client.earned(
-        '0x0000000000000000000000000000000000000000',
-        '0x0000000000000000000000000000000000000000'
-      );
-
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-    });
-  });
-
-  describe('totalSupply', () => {
-    const testPool = '0x1234567890123456789012345678901234567890';
-    const mockTotalSupply = BigInt(1000000);
-
-    it('should get total supply successfully', async () => {
-      jest.spyOn(client['publicClient'], 'readContract')
-        .mockResolvedValueOnce(mockTotalSupply);
-
-      const response = await client.totalSupply(testPool as `0x${string}`);
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBe(mockTotalSupply);
-    });
-
-    it('should handle errors when getting total supply', async () => {
-      jest.spyOn(client['publicClient'], 'readContract')
-        .mockRejectedValue(new Error('Contract call failed'));
-
-      const response = await client.totalSupply('0x0000000000000000000000000000000000000000');
-
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-    });
-  });
-
-  describe('balanceOf', () => {
-    const testPool = '0x1234567890123456789012345678901234567890';
-    const testAccount = '0x2234567890123456789012345678901234567890';
-    const mockBalance = BigInt(5000);
-
-    it('should get balance successfully', async () => {
-      jest.spyOn(client['publicClient'], 'readContract')
-        .mockResolvedValueOnce(mockBalance);
-
-      const response = await client.balanceOf(
-        testPool as `0x${string}`,
-        testAccount as `0x${string}`
-      );
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBe(mockBalance);
-    });
-
-    it('should handle errors when getting balance', async () => {
-      jest.spyOn(client['publicClient'], 'readContract')
-        .mockRejectedValue(new Error('Contract call failed'));
-
-      const response = await client.balanceOf(
-        '0x0000000000000000000000000000000000000000',
-        '0x0000000000000000000000000000000000000000'
-      );
-
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-    });
-  });
-
-  describe('calculateAPR', () => {
-    const mockPool = {
-      chainId: 137,
-      stakingPool: '0x1234567890123456789012345678901234567890',
-      protocol: StakingProtocol.Forge,
-      isDualFactory: true,
-      dailyEmissionRewardA: 100,
-      dailyEmissionRewardB: 200,
-      rewardToken: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-      rewardTokenA: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-      rewardTokenADetail: {
-        symbol: 'TEST',
-        name: 'Test Token',
-        address: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-        decimals: 18
-      },
-      stakingToken: '0x0000000000000000000000000000000000000000',
-      staking: {
-        symbol: 'TEST',
-        name: 'Test Token',
-        address: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-        decimals: 18
-      },
-      reward: {
-        symbol: 'TEST',
-        name: 'Test Token',
-        address: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-        decimals: 18
-      },
-      periodFinish: '1708019265',
-      rewardsDuration: '604800',
-      isSteerVault: false
-    };
-
-    it('should calculate APR for dual reward pool', () => {
-      const rewardTokenPrice = 1; // $1 per token
-      const totalStakedUSD = 1000000; // $1M staked
-
-      const apr = client.calculateAPR(
-        mockPool,
-        rewardTokenPrice,
-        totalStakedUSD
-      );
-
-      // Expected APR = ((dailyRewardA * 365 * 100) / totalStaked) + ((dailyRewardB * 365 * 100) / totalStaked)
-      const expectedAPR = ((100 * 365 * 100) / 1000000) + ((200 * 365 * 100) / 1000000);
-      expect(apr).toBe(expectedAPR);
-    });
-
-    it('should calculate APR for single reward pool', () => {
-      const singleRewardPool = { ...mockPool, isDualFactory: false };
-      const rewardTokenPrice = 1;
-      const totalStakedUSD = 1000000;
-
-      const apr = client.calculateAPR(
-        singleRewardPool,
-        rewardTokenPrice,
-        totalStakedUSD
-      );
-
-      // Expected APR = (dailyRewardA * 365 * 100) / totalStaked
-      const expectedAPR = (100 * 365 * 100) / 1000000;
-      expect(apr).toBe(expectedAPR);
-    });
-
-    it('should return 0 APR when total staked is 0', () => {
-      const apr = client.calculateAPR(
-        mockPool,
-        1, // reward token price
-        0  // total staked USD
-      );
-
-      expect(apr).toBe(0);
-    });
-  });
-
-  describe('Integration Tests with Real Chain Data', () => {
-    let realSteerClient: SteerClient;
-    const testAccount = '0x40199ba8875ac583658a7e936e16354f4bf1ea54dac73a2bc24fd17159ceb820';
-
-    beforeAll(() => {
-      // Create real clients for blockchain interaction
-      const publicClient = createPublicClient({
-        chain: kava,
-        transport: http()
-      });
-
-      const walletClient = createWalletClient({
-        chain: kava,
-        transport: http(),
-        account: privateKeyToAccount(testAccount)
-      });
-
-      // Initialize SteerClient with real clients
-      realSteerClient = new SteerClient({
-        environment: 'production',
-        client: publicClient,
-        walletClient: walletClient
-      });
-    });
-
-    it('should fetch active staking pools and check rewards', async () => {
-      // Step 1: Get active staking pools for Polygon chain
-      const poolsResponse = await realSteerClient.staking.getStakingPools({
-        chainId: 137,
-        isLive: true
-      });
-
-      expect(poolsResponse.success).toBe(true);
-      expect(poolsResponse.data).toBeDefined();
-      expect(Array.isArray(poolsResponse.data)).toBe(true);
-      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`);
-
-      // Step 2: Check rewards for each pool
-      for (const pool of poolsResponse.data!.slice(0, 3)) { // Test first 3 pools
-        const earnedResponse = await realSteerClient.staking.earned(
-          pool.stakingPool as `0x${string}`,
-          testAccount as `0x${string}`
-        );
-
-        expect(earnedResponse.success).toBe(true);
-        expect(earnedResponse.data).toBeDefined();
-
-        console.log(`\nPool ${pool.stakingPool}:`);
-        console.log(`- Token A Rewards: ${earnedResponse.data!.rewardA.toString()}`);
-        if (pool.isDualFactory) {
-          console.log(`- Token B Rewards: ${earnedResponse.data!.rewardB?.toString() || '0'}`);
-        }
-
-        // Step 3: If rewards are available, try to claim them
-        if (earnedResponse.data!.rewardA > BigInt(0) || 
-            (pool.isDualFactory && earnedResponse.data!.rewardB && earnedResponse.data!.rewardB > BigInt(0))) {
-          
-          const claimResponse = await realSteerClient.staking.getReward({
-            stakingPool: pool.stakingPool as `0x${string}`
-          });
-
-          expect(claimResponse.success).toBe(true);
-          expect(claimResponse.data).toBeDefined();
-          console.log(`- Claim transaction hash: ${claimResponse.data}`);
-        }
-      }
-    }, 60000);
-
-    it('should handle dual reward pools correctly', async () => {
-      // Get only dual reward pools
-      const dualPoolsResponse = await realSteerClient.staking.getStakingPools({
-        chainId: 137,
-        isLive: true,
-        isDualRewards: true
-      });
-
-      expect(dualPoolsResponse.success).toBe(true);
-      expect(dualPoolsResponse.data).toBeDefined();
-      expect(Array.isArray(dualPoolsResponse.data)).toBe(true);
-
-      if (dualPoolsResponse.data!.length > 0) {
-        const testPool = dualPoolsResponse.data![0];
-        console.log(`Testing dual reward pool: ${testPool.stakingPool}`);
-
-        // Check rewards for both tokens
-        const earnedResponse = await realSteerClient.staking.earned(
-          testPool.stakingPool as `0x${string}`,
-          testAccount as `0x${string}`
-        );
-
-        expect(earnedResponse.success).toBe(true);
-        expect(earnedResponse.data).toBeDefined();
-        expect(earnedResponse.data!.rewardB).toBeDefined();
-
-        console.log(`- Token A Rewards: ${earnedResponse.data!.rewardA.toString()}`);
-        console.log(`- Token B Rewards: ${earnedResponse.data!.rewardB?.toString()}`);
-      } else {
-        console.log('No active dual reward pools found');
-      }
-    }, 30000);
-
-    it('should check total supply and user balance for active pools', async () => {
-      // Get active pools
-      const poolsResponse = await realSteerClient.staking.getStakingPools({
-        chainId: 137,
-        isLive: true
-      });
-
-      expect(poolsResponse.success).toBe(true);
-      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];
-      console.log(`\nChecking pool ${testPool.stakingPool}:`);
-
-      // Get total supply
-      const totalSupplyResponse = await realSteerClient.staking.totalSupply(
-        testPool.stakingPool as `0x${string}`
-      );
-
-      expect(totalSupplyResponse.success).toBe(true);
-      expect(totalSupplyResponse.data).toBeDefined();
-      console.log(`- Total Supply: ${totalSupplyResponse.data!.toString()}`);
-
-      // Get user balance
-      const balanceResponse = await realSteerClient.staking.balanceOf(
-        testPool.stakingPool as `0x${string}`,
-        testAccount as `0x${string}`
-      );
-
-      expect(balanceResponse.success).toBe(true);
-      expect(balanceResponse.data).toBeDefined();
-      console.log(`- User Balance: ${balanceResponse.data!.toString()}`);
-    }, 30000);
-
-    it('should calculate LP token value for Steer vault staking pool', async () => {
-      // Get active staking pools
-      const poolsResponse = await realSteerClient.staking.getStakingPools({
-        chainId: 2222,
-        isLive: true
-      });
-
-      expect(poolsResponse.success).toBe(true);
-      expect(poolsResponse.data).toBeDefined();
-
-      // Find a Steer vault staking pool
-      const steerVaultPool = poolsResponse.data!.find(pool => pool.isSteerVault && pool.staking.address);
-      
-      if (steerVaultPool) {
-        console.log(`Testing Steer vault pool: ${steerVaultPool.stakingPool}`);
-        
-        const lpTokenAmount = BigInt('1000000000000000000'); // 1 LP token
-        const response = await realSteerClient.staking.getSteerLpTokenValue({
-          stakingPool: steerVaultPool,
-          amount: lpTokenAmount,
-          token0UsdPrice: 1, // Using 1 USD for testing
-          token1UsdPrice: 1  // Using 1 USD for testing
-        });
-
-        expect(response.success).toBe(true);
-        expect(response.data).toBeDefined();
-        expect(response.data!.totalValueUsd).toBeGreaterThan(0);
-        expect(response.data!.token0Value).toBeDefined();
-        expect(response.data!.token1Value).toBeDefined();
-
-        console.log('LP Token Value Results:');
-        console.log(`- Total Value USD: ${response.data!.totalValueUsd}`);
-        console.log(`- Token0 Value: ${response.data!.token0Value}`);
-        console.log(`- Token1 Value: ${response.data!.token1Value}`);
-      } else {
-        console.log('No Steer vault staking pools found for testing');
-      }
-    }, 30000);
-
-    it('should calculate token value for regular staking pool', async () => {
-      // Get active staking pools
-      const poolsResponse = await realSteerClient.staking.getStakingPools({
-        chainId: 2222,
-        isLive: true
-      });
-
-      expect(poolsResponse.success).toBe(true);
-      expect(poolsResponse.data).toBeDefined();
-
-      // Find a regular (non-Steer vault) staking pool
-      const regularPool = poolsResponse.data!.find(pool => pool.isSteerVault);
-      
-      if (regularPool) {
-        console.log(`Testing regular staking pool: ${regularPool.stakingPool}`);
-        
-        const tokenAmount = BigInt('1000000000000000000'); // 1 token
-        const response = await realSteerClient.staking.getSteerLpTokenValue({
-          stakingPool: regularPool,
-          amount: tokenAmount,
-          token0UsdPrice: 1, // Using 1 USD for testing
-          token1UsdPrice: 1  // Using 1 USD for testing
-        });
-
-        expect(response.success).toBe(true);
-        expect(response.data).toBeDefined();
-        expect(response.data!.totalValueUsd).toBe(1); // Should be 1 USD for 1 token at $1 price
-        expect(response.data!.tokenValue).toBe(1);
-        expect(response.data!.token0Value).toBeUndefined();
-        expect(response.data!.token1Value).toBeUndefined();
-
-        console.log('Token Value Results:');
-        console.log(`- Total Value USD: ${response.data!.totalValueUsd}`);
-        console.log(`- Token Value: ${response.data!.tokenValue}`);
-      } else {
-        console.log('No regular staking pools found for testing');
-      }
-    }, 30000);
-
-    it('should handle errors for invalid staking pool', async () => {
-      const invalidPool = {
-        chainId: 137,
-        stakingPool: '0x1234567890123456789012345678901234567890',
-        protocol: StakingProtocol.Forge,
-        isDualFactory: false,
-        dailyEmissionRewardA: 100,
-        dailyEmissionRewardB: 0,
-        rewardToken: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-        rewardTokenA: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-        rewardTokenADetail: {
-          symbol: 'TEST',
-          name: 'Test Token',
-          address: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-          decimals: 18
-        },
-        stakingToken: '0x0000000000000000000000000000000000000000',
-        staking: {
-          symbol: 'TEST',
-          name: 'Test Token',
-          address: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-          decimals: 18
-        },
-        reward: {
-          symbol: 'TEST',
-          name: 'Test Token',
-          address: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-          decimals: 18
-        },
-        periodFinish: '0',
-        rewardsDuration: '0',
-        isSteerVault: true
-      };
-
-      const response = await realSteerClient.staking.getSteerLpTokenValue({
-        stakingPool: invalidPool,
-        amount: BigInt('1000000000000000000'),
-        token0UsdPrice: 1,
-        token1UsdPrice: 1
-      });
-
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-    }, 30000);
-
-    it('should calculate total staking amount in USD for Steer vault pool', async () => {
-      // Get active staking pools
-      const poolsResponse = await realSteerClient.staking.getStakingPools({
-        chainId: 2222,
-        isLive: true
-      });
-
-      expect(poolsResponse.success).toBe(true);
-      expect(poolsResponse.data).toBeDefined();
-
-      // Find a Steer vault staking pool
-      const steerVaultPool = poolsResponse.data!.find(pool => pool.isSteerVault && pool.staking.address);
-      
-      if (steerVaultPool) {
-        console.log(`Testing total staking amount for Steer vault pool: ${steerVaultPool.stakingPool}`);
-        
-        const response = await realSteerClient.staking.getTotalStakingAmountInUsd(
-          steerVaultPool,
-          1, // Using 1 USD for token0 price
-          1  // Using 1 USD for token1 price
-        );
-
-        expect(response.success).toBe(true);
-        expect(response.data).toBeDefined();
-        expect(typeof response.data).toBe('number');
-        expect(response.data).toBeGreaterThanOrEqual(0);
-
-        console.log('Total Staking Amount Results:');
-        console.log(`- Total Value USD: ${response.data}`);
-      } else {
-        console.log('No Steer vault staking pools found for testing');
-      }
-    }, 30000);
-
-    it('should calculate total staking amount in USD for regular staking pool', async () => {
-      // Get active staking pools
-      const poolsResponse = await realSteerClient.staking.getStakingPools({
-        chainId: 2222,
-        isLive: true
-      });
-
-      expect(poolsResponse.success).toBe(true);
-      expect(poolsResponse.data).toBeDefined();
-
-      // Find a regular (non-Steer vault) staking pool
-      const regularPool = poolsResponse.data!.find(pool => !pool.isSteerVault);
-      
-      if (regularPool) {
-        console.log(`Testing total staking amount for regular pool: ${regularPool.stakingPool}`);
-        
-        const response = await realSteerClient.staking.getTotalStakingAmountInUsd(
-          regularPool,
-          1  // Using 1 USD for token price
-        );
-
-        expect(response.success).toBe(true);
-        expect(response.data).toBeDefined();
-        expect(typeof response.data).toBe('number');
-        expect(response.data).toBeGreaterThanOrEqual(0);
-
-        console.log('Total Staking Amount Results:');
-        console.log(`- Total Value USD: ${response.data}`);
-      } else {
-        console.log('No regular staking pools found for testing');
-      }
-    }, 30000);
-
-    it('should handle errors when calculating total staking amount for invalid pool', async () => {
-      const invalidPool = {
-        chainId: 137,
-        stakingPool: '0x0000000000000000000000000000000000000000',
-        protocol: StakingProtocol.Forge,
-        isDualFactory: false,
-        dailyEmissionRewardA: 100,
-        dailyEmissionRewardB: 0,
-        rewardToken: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-        rewardTokenA: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-        rewardTokenADetail: {
-          symbol: 'TEST',
-          name: 'Test Token',
-          address: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-          decimals: 18
-        },
-        stakingToken: '0x0000000000000000000000000000000000000000',
-        staking: {
-          symbol: 'TEST',
-          name: 'Test Token',
-          address: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-          decimals: 18
-        },
-        reward: {
-          symbol: 'TEST',
-          name: 'Test Token',
-          address: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-          decimals: 18
-        },
-        periodFinish: '0',
-        rewardsDuration: '0',
-        isSteerVault: false
-      };
-
-      const response = await realSteerClient.staking.getTotalStakingAmountInUsd(
-        invalidPool,
-        1
-      );
-
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-    }, 30000);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-});