@steerprotocol/sdk 1.27.0 → 1.28.0

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

@@ -0,0 +1,772 @@
+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 } from '../../const/protocol.js';
+
+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', () => {
+    // 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 }),
+      // });
+    });
+
+    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);
+    });
+
+    it('should filter pools by chainId', async () => {
+      const response = await client.getStakingPools({
+        chainId: 137
+      });
+      expect(response.success).toBe(true);
+      expect(response.data).toHaveLength(2);
+      expect(response.data!.every(pool => pool.chainId === 137)).toBe(true);
+    });
+
+    it('should filter pools by chainId and protocol', async () => {
+      const response = await client.getStakingPools({
+        chainId: 2222,
+        protocol: StakingProtocol.Kinetix
+      });
+      expect(response.success).toBe(true);
+      expect(response.data).toHaveLength(2);
+      expect(response.data!.every(pool => 
+        pool.chainId === 137 && pool.protocol === StakingProtocol.Forge
+      )).toBe(true);
+    });
+
+    it('should filter live pools', async () => {
+      const response = await client.getStakingPools({
+        isLive: true
+      });
+      expect(response.success).toBe(true);
+      expect(response.data!.length).toBe(2);
+      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 response = await client.getStakingPools({
+        chainId: 2222,
+        isLive: true
+      });
+      expect(response.success).toBe(true);
+      expect(response.data!.length).toBe(2);
+      expect(response.data!.every(pool => {
+        const now = Math.floor(Date.now() / 1000);
+        return pool.chainId === 137 && parseInt(pool.periodFinish) > now;
+      })).toBe(true);
+    });
+
+    it('should filter using multiple criteria', async () => {
+      const response = await client.getStakingPools({
+        chainId: 137,
+        protocol: StakingProtocol.Forge,
+        isLive: true,
+        isDualRewards: true
+      });
+      
+      expect(response.success).toBe(true);
+      expect(response.data!.length).toBe(2);
+      expect(response.data!.every(pool => {
+        const now = Math.floor(Date.now() / 1000);
+        return pool.chainId === 137 &&
+               pool.protocol === StakingProtocol.Forge &&
+               parseInt(pool.periodFinish) > now &&
+               pool.isDualFactory === true;
+      })).toBe(true);
+    });
+
+    it('should filter by minimum daily emissions', async () => {
+      const response = await client.getStakingPools({
+        minDailyEmissionA: 800
+      });
+      
+      expect(response.success).toBe(true);
+      expect(response.data!.length).toBe(1);
+      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, // non-existent chain
+        protocol: StakingProtocol.ArthSwap
+      });
+      
+      expect(response.success).toBe(true);
+      expect(response.data).toHaveLength(0);
+    });
+
+    it('should handle case-insensitive protocol matching', async () => {
+      const response = await client.getStakingPools({
+        protocol: StakingProtocol.Forge
+      });
+      
+      expect(response.success).toBe(true);
+      expect(response.data!.length).toBe(2);
+      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(3);
+      expect(response.data!.find(pool => pool.protocol === StakingProtocol.ArthSwap)).toBeDefined();
+      expect(response.data!.filter(pool => pool.protocol === StakingProtocol.Forge)).toHaveLength(2);
+    });
+  });
+
+  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);
+      expect(poolsResponse.data!.length).toBeGreaterThan(0);
+
+      // 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);
+      expect(poolsResponse.data!.length).toBeGreaterThan(0);
+
+      // 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();
+  });
+});