@steerprotocol/sdk 1.27.0 → 1.28.0

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

@@ -0,0 +1,465 @@
+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
+  });
+});