@steerprotocol/sdk 1.30.8 → 2.0.0

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

@@ -1,465 +0,0 @@
-import { SteerClient } from '../../client.js';
-import { createClient } from '@steerprotocol/api-sdk';
-import { type Address, type Hash, type PublicClient, type WalletClient } from 'viem';
-import { mainnet, polygon } from 'viem/chains';
-import { createPublicClient, http } from 'viem';
-import { createWalletClient } from 'viem';
-
-// Mock data
-const mockUser = '0x1234567890123456789012345678901234567890' as Address;
-const mockChainId = 1;
-const mockCampaignId = 1;
-const mockHash = '0xabcdef1234567890' as Hash;
-const mockPoolAddress = '0x1234567890123456789012345678901234567890' as Address;
-describe('SmartRewards', () => {
-  let steerClient: SteerClient;
-  let mockClient: ReturnType<typeof createClient>;
-  let mockPublicClient: PublicClient;
-  let mockWalletClient: WalletClient;
-
-  beforeEach(() => {
-    // Setup mocks
-    mockClient = {
-      campaigns: jest.fn(),
-      claimProofs: jest.fn(),
-      claimRewards: jest.fn(),
-      smartRewarderContracts: jest.fn(),
-    } as unknown as ReturnType<typeof createClient>;
-
-    mockPublicClient = {
-      simulateContract: jest.fn(),
-      chain: { id: mockChainId }
-    } as unknown as PublicClient;
-
-    mockWalletClient = {
-      getAddresses: jest.fn().mockResolvedValue([mockUser]),
-      writeContract: jest.fn(),
-    } as unknown as WalletClient;
-
-    // Initialize SteerClient with mocked clients
-    steerClient = new SteerClient({
-      environment: 'production',
-      client: mockPublicClient,
-      walletClient: mockWalletClient
-    });
-  });
-
-  describe('getCampaigns', () => {
-    it('should return campaigns for a given chain ID', async () => {
-      const mockResponse = {
-        data: {
-          campaigns: {
-            totalCount: 1,
-            pageInfo: {
-              hasNextPage: false,
-              endCursor: null
-            },
-            edges: [
-              {
-                cursor: 'cursor1',
-                node: {
-                  id: '1',
-                  vaults: [
-                    {
-                      beaconName: 'test',
-                      name: 'Test Vault',
-                      protocol: 'Test',
-                      protocolBaseType: 'Test',
-                      targetProtocol: 'Test'
-                    }
-                  ]
-                }
-              }
-            ]
-          }
-        },
-        status: 200,
-        headers: new Headers(),
-        extensions: {}
-      };
-
-      jest.mocked(mockClient.campaigns).mockResolvedValue(mockResponse as unknown as ReturnType<typeof mockClient.campaigns>);
-
-      const result = await steerClient.rewards.getCampaigns(mockChainId);
-
-      expect(result.success).toBe(true);
-      expect(result.status).toBe(200);
-      expect(result.data).toHaveLength(1);
-      expect(mockClient.campaigns).toHaveBeenCalledWith({
-        filter: { chainId: mockChainId }
-      });
-    });
-  });
-
-  describe('getClaimProofs', () => {
-    it('should return claim proofs for a user', async () => {
-      const mockResponse = {
-        data: {
-          claimProofs: {
-            totalCount: 1,
-            pageInfo: {
-              hasNextPage: false,
-              endCursor: null
-            },
-            edges: [
-              {
-                cursor: 'cursor1',
-                node: {
-                  chainId: mockChainId,
-                  lastBlockUpdatedTo: 1234567,
-                  user: mockUser,
-                  campaignId: mockCampaignId,
-                  amount: '1000000000000000000',
-                  proof: ['0x1234']
-                }
-              }
-            ]
-          }
-        },
-        status: 200,
-        headers: new Headers(),
-        extensions: {}
-      };
-
-      jest.mocked(mockClient.claimProofs).mockResolvedValue(mockResponse as unknown as ReturnType<typeof mockClient.claimProofs>);
-
-      const result = await steerClient.rewards.getClaimProofs(mockUser, mockChainId, mockCampaignId);
-
-      expect(result.success).toBe(true);
-      expect(result.status).toBe(200);
-      expect(result.data?.edges).toHaveLength(1);
-      expect(mockClient.claimProofs).toHaveBeenCalledWith({
-        user: mockUser,
-        filter: { chainId: mockChainId, campaignId: mockCampaignId }
-      });
-    });
-
-    it('should handle errors gracefully', async () => {
-      jest.mocked(mockClient.claimProofs).mockRejectedValue(new Error('API Error'));
-
-      const result = await steerClient.rewards.getClaimProofs(mockUser, mockChainId);
-
-      expect(result.success).toBe(false);
-      expect(result.status).toBe(500);
-      expect(result.error).toBe('API Error');
-    });
-  });
-
-  describe('claimReward', () => {
-    it('should successfully claim rewards', async () => {
-      const mockParams = {
-        users: [mockUser],
-        campaignIds: [BigInt(1)],
-        amounts: [BigInt('1000000000000000000')],
-        proofs: [['0x1234'] as readonly `0x${string}`[]],
-        rewarderAddress: '0x1234' as Address
-      };
-
-      jest.mocked(mockPublicClient.simulateContract).mockResolvedValue({
-        request: {
-          address: mockParams.rewarderAddress,
-          functionName: 'claim',
-          args: [
-            mockParams.users,
-            mockParams.campaignIds,
-            mockParams.amounts,
-            mockParams.proofs
-          ],
-          account: { address: mockUser, type: 'json-rpc' },
-          chain: mainnet
-        }
-      } as unknown as ReturnType<typeof mockPublicClient.simulateContract>);
-
-      jest.mocked(mockWalletClient.writeContract).mockResolvedValue(mockHash);
-
-      const result = await steerClient.rewards.claimReward(mockParams);
-
-      expect(result.success).toBe(true);
-      expect(result.status).toBe(200);
-      expect(result.data).toBe(mockHash);
-    });
-
-    it('should handle missing wallet account', async () => {
-      jest.mocked(mockWalletClient.getAddresses).mockResolvedValue([]);
-
-      const mockParams = {
-        users: [mockUser],
-        campaignIds: [BigInt(1)],
-        amounts: [BigInt('1000000000000000000')],
-        proofs: [['0x1234'] as readonly `0x${string}`[]],
-        rewarderAddress: '0x1234' as Address
-      };
-
-      const result = await steerClient.rewards.claimReward(mockParams);
-
-      expect(result.success).toBe(false);
-      expect(result.status).toBe(500);
-      expect(result.error).toBe('No account found');
-    });
-  });
-
-  describe('getRewardSummary', () => {
-    it('should return reward summary with correct calculations', async () => {
-      // Mock claim proofs response
-      const mockClaimProofsResponse = {
-        data: {
-          claimProofs: {
-            totalCount: 1,
-            pageInfo: { hasNextPage: false, endCursor: null },
-            edges: [{
-              cursor: 'c1',
-              node: {
-                chainId: mockChainId,
-                lastBlockUpdatedTo: 1234567,
-                user: mockUser,
-                campaignId: mockCampaignId,
-                amount: '1000000000000000000',
-                proof: ['0x1234']
-              }
-            }]
-          }
-        },
-        status: 200,
-        headers: new Headers(),
-        extensions: {}
-      };
-
-      // Mock claim rewards response
-      const mockClaimRewardsResponse = {
-        data: {
-          claimRewards: {
-            totalCount: 1,
-            pageInfo: { hasNextPage: false, endCursor: null },
-            edges: [{
-              cursor: 'c1',
-              node: {
-                id: '1',
-                user: mockUser,
-                amount: '500000000000000000',
-                campaign: '1',
-                chainId: mockChainId,
-                timestamp: '1234567890'
-              }
-            }]
-          }
-        },
-        status: 200,
-        headers: new Headers(),
-        extensions: {}
-      };
-
-      jest.mocked(mockClient.claimProofs).mockResolvedValue(mockClaimProofsResponse as unknown as ReturnType<typeof mockClient.claimProofs>);
-      jest.mocked(mockClient.claimRewards).mockResolvedValue(mockClaimRewardsResponse as unknown as ReturnType<typeof mockClient.claimRewards>);
-
-      const result = await steerClient.rewards.getRewardSummary(
-        mockUser,
-        mockPoolAddress,
-        mockChainId,
-        mockCampaignId
-      );
-
-      expect(result.success).toBe(true);
-      expect(result.data?.totalEarned.native).toBe(BigInt('1500000000000000000'));
-      expect(result.data?.claimable.native).toBe(BigInt('1000000000000000000'));
-      expect(result.data?.totalClaimed.native).toBe(BigInt('500000000000000000'));
-    });
-  });
-
-  describe('Integration Tests with Real Chain Data', () => {
-    // Using mainnet for testing
-    const testChainId = 137;
-    const testPool = '0x876Cb5c8898992Be22A43ef815504f1Ea419101D';
-    let realSteerClient: SteerClient;
-
-    beforeAll(() => {
-      // Create real clients for blockchain interaction
-      const publicClient = createPublicClient({
-        chain: polygon,
-        transport: http()
-      });
-
-      const walletClient = createWalletClient({
-        chain: polygon,
-        transport: http(),
-
-      });
-
-      // Initialize SteerClient with real clients
-      realSteerClient = new SteerClient({
-        environment: 'production',
-        client: publicClient,
-        walletClient: walletClient
-      });
-    });
-
-    it('should fetch real campaigns and prepare claim data', async () => {
-      // First, get all campaigns for the chain
-      const campaignsResponse = await realSteerClient.rewards.getCampaigns(testChainId);
-      expect(campaignsResponse.success).toBe(true);
-      expect(Array.isArray(campaignsResponse.data)).toBe(true);
-
-      // Skip test if no campaigns found
-      if (!campaignsResponse.data?.length) {
-        console.log('No campaigns found for testing');
-        return;
-      }
-
-      // Test with the first campaign
-      const testCampaign = campaignsResponse.data[0];
-      console.log(`Testing with campaign ID: ${testCampaign.id}`);
-
-      // Get claim proofs for this campaign
-      const claimProofsResponse = await realSteerClient.rewards.getClaimProofs(
-        mockUser,
-        testChainId,
-        Number(testCampaign.id)
-      );
-      expect(claimProofsResponse.success).toBe(true);
-
-      // Get reward summary
-      const rewardSummary = await realSteerClient.rewards.getRewardSummary(
-        mockUser,
-        testPool,
-        testChainId,
-        Number(testCampaign.id)
-      );``
-      expect(rewardSummary.success).toBe(true);
-
-      // Finally, prepare claim rewards campaign
-      const preparedClaim = await realSteerClient.rewards.prepareClaimRewardsCampaign(
-        mockUser,
-        testChainId,
-        Number(testCampaign.id)
-      );
-
-      // If we have claim proofs, verify the prepared data
-      if (claimProofsResponse.data?.edges.length) {
-        expect(preparedClaim.success).toBe(true);
-        expect(preparedClaim.data).toBeDefined();
-        if (preparedClaim.data) {
-          // Verify structure of prepared data
-          expect(preparedClaim.data.address).toBeDefined();
-          expect(preparedClaim.data.abi).toHaveLength(1);
-          expect(preparedClaim.data.abi[0].name).toBe('claim');
-          expect(preparedClaim.data.functionName).toBe('claim');
-          expect(Array.isArray(preparedClaim.data.args)).toBe(true);
-          expect(preparedClaim.data.args).toHaveLength(4);
-        }
-      } else {
-        // If no claim proofs, expect appropriate error
-        expect(preparedClaim.success).toBe(false);
-        expect(preparedClaim.error).toBe('No claim proofs found');
-      }
-    }, 30000); // Increased timeout for real API calls
-
-    it('should verify smart rewarder contracts for the chain', async () => {
-      const rewarderResponse = await realSteerClient.rewards.getSmartRewarderContracts();
-      expect(rewarderResponse.success).toBe(true);
-      
-      if (rewarderResponse.data) {
-        const chainRewarders = rewarderResponse.data.filter(r => r.chainId === testChainId);
-        expect(chainRewarders.length).toBeGreaterThan(0);
-        
-        // Verify each rewarder contract has required properties
-        chainRewarders.forEach(rewarder => {
-          expect(rewarder.address).toMatch(/^0x[a-fA-F0-9]{40}$/);
-          expect(rewarder.chainId).toBe(testChainId);
-        });
-      }
-    }, 15000);
-
-    it('should fetch reward summary for specific pool and user', async () => {
-      const testPool = '0x169b1f69c1a5d97ffa2d45b9b08b176d078a1b2b';
-      const testUser = '0xa9fdeb97d2acad58ec48d0406ed2eb6bb96cfdb5' as Address;
-      const testChainId = 137;
-      const testCampaignId = 33;
-
-      const rewardSummary = await realSteerClient.rewards.getRewardSummary(
-        testUser,
-        testPool,
-        testChainId,
-        testCampaignId
-      );
-
-      expect(rewardSummary.success).toBe(true);
-      expect(rewardSummary.data).toBeDefined();
-      
-      if (rewardSummary.data) {
-        // Verify the structure of the reward summary
-        expect(rewardSummary.data.totalEarned).toBeDefined();
-        expect(rewardSummary.data.totalClaimed).toBeDefined();
-        expect(rewardSummary.data.claimable).toBeDefined();
-
-        // Each balance should have both native and formatted values
-        expect(typeof rewardSummary.data.totalEarned.native).toBe('bigint');
-        expect(typeof rewardSummary.data.totalEarned.formatted).toBe('string');
-        expect(typeof rewardSummary.data.totalClaimed.native).toBe('bigint');
-        expect(typeof rewardSummary.data.totalClaimed.formatted).toBe('string');
-        expect(typeof rewardSummary.data.claimable.native).toBe('bigint');
-        expect(typeof rewardSummary.data.claimable.formatted).toBe('string');
-
-        // Log the results for verification
-        console.log('Reward Summary:', {
-          totalEarned: rewardSummary.data.totalEarned.formatted,
-          totalClaimed: rewardSummary.data.totalClaimed.formatted,
-          claimable: rewardSummary.data.claimable.formatted
-        });
-      }
-    }, 6000000); // Increased timeout to 60 seconds
-
-    it.only('should fetch campaigns for specific pool', async () => {
-      const testPool = '0x2594c0330545ab4e4b8f63fa1ed1eb53ee307af8';
-      const testChainId = 137;
-
-      const campaignsResponse = await realSteerClient.rewards.campaignsByPool(
-        testPool,
-        testChainId
-      );
-
-      expect(campaignsResponse.success).toBe(true);
-      expect(campaignsResponse.data).toBeDefined();
-      
-      if (campaignsResponse.data) {
-        // Verify it returns an array
-        expect(Array.isArray(campaignsResponse.data)).toBe(true);
-        
-        // If campaigns exist, verify their structure
-        campaignsResponse.data.forEach(campaign => {
-          // Verify campaign structure
-          expect(campaign).toHaveProperty('id');
-          expect(campaign).toHaveProperty('vaults');
-          
-          // Verify vaults array structure
-          expect(Array.isArray(campaign.vaults)).toBe(true);
-          
-          // If vaults exist and is not null, verify their structure
-          if (campaign.vaults) {
-            campaign.vaults.forEach(vault => {
-              expect(vault).toHaveProperty('beaconName');
-              expect(vault).toHaveProperty('name');
-              expect(vault).toHaveProperty('protocol');
-              expect(vault).toHaveProperty('protocolBaseType');
-              expect(vault).toHaveProperty('targetProtocol');
-              
-              // Verify all vault properties are strings
-              expect(typeof vault.beaconName).toBe('string');
-              expect(typeof vault.name).toBe('string');
-              expect(typeof vault.protocol).toBe('string');
-              expect(typeof vault.protocolBaseType).toBe('string');
-              expect(typeof vault.targetProtocol).toBe('string');
-            });
-          }
-        });
-
-        // Log the results for verification
-        console.log('Campaigns found:', campaignsResponse.data.length);
-        if (campaignsResponse.data.length > 0 && campaignsResponse.data[0].vaults) {
-          console.log('First campaign:', {
-            id: campaignsResponse.data[0].id,
-            numberOfVaults: campaignsResponse.data[0].vaults.length
-          });
-        }
-      }
-    }, 30000); // 30 second timeout
-  });
-});