@steerprotocol/sdk 1.31.0 → 2.0.1

package/src/base/SmartRewards.ts

@@ -1,783 +0,0 @@
-import { Campaign, createClient } from '@steerprotocol/api-sdk';
-import type { Address, Hash, PublicClient, WalletClient } from 'viem';
-import { formatUnits } from 'viem';
-import { SteerResponse } from '../types.js';
-import { getSubgraphUrlByChainId } from '../const/subgraph.js';
-
-/**
- * Represents a node in the claim proof data structure
- * @property chainId - The ID of the chain where the claim exists
- * @property lastBlockUpdatedTo - The last block number this claim was updated to
- * @property user - The address of the user who can claim
- * @property campaignId - The ID of the campaign this claim belongs to
- * @property amount - The claimable amount as a string (may include decimals)
- * @property proof - The merkle proof array required for claiming
- */
-export interface ClaimProofNode {
-  chainId: number;
-  lastBlockUpdatedTo: number;
-  user: string;
-  campaignId: number;
-  amount: string;
-  proof: readonly string[];
-}
-
-export interface ClaimProofEdge {
-  node: ClaimProofNode;
-  cursor: string;
-}
-
-/**
- * Represents a historical claim reward record
- * @property id - Unique identifier for the claim
- * @property user - Address of the user who claimed
- * @property amount - Amount that was claimed (may include decimals)
- * @property campaign - Campaign identifier
- * @property chainId - Chain ID where the claim occurred
- * @property timestamp - Unix timestamp of when the claim occurred
- */
-export interface ClaimRewardNode {
-  id: string;
-  user: string;
-  amount: string;
-  campaign: string;
-  chainId: number;
-  timestamp: number;
-}
-
-export interface ClaimRewardEdge {
-  cursor: string;
-  node: ClaimRewardNode;
-}
-
-/**
- * Pagination information for paginated queries
- * @property hasNextPage - Whether there are more results available
- * @property endCursor - Cursor to use for fetching next page, if available
- */
-export interface PageInfo {
-  hasNextPage: boolean;
-  endCursor: string | null | undefined;
-}
-
-/**
- * Connection type for claim rewards, following the Relay specification
- * @property edges - Array of claim reward records with cursors
- * @property pageInfo - Pagination information
- * @property totalCount - Total number of records available
- */
-export interface ClaimRewardsConnection {
-  edges: readonly ClaimRewardEdge[];
-  pageInfo: PageInfo;
-  totalCount: number;
-}
-
-export interface ClaimProofsPageInfo {
-  hasNextPage: boolean;
-  endCursor?: string;
-}
-
-export interface ClaimProofsResponse {
-  totalCount: number;
-  edges: readonly ClaimProofEdge[];
-  pageInfo: ClaimProofsPageInfo;
-}
-
-export interface SmartRewarderContract {
-  chainId: number;
-  address: string;
-}
-
-/**
- * Parameters required for claiming rewards
- * @property users - Array of user addresses who are claiming
- * @property campaignIds - Array of campaign IDs corresponding to each claim
- * @property amounts - Array of amounts to claim
- * @property proofs - Array of merkle proofs for verification
- * @property rewarderAddress - Address of the smart rewarder contract
- */
-export interface ClaimRewardParams {
-  users: readonly Address[];
-  campaignIds: readonly bigint[];
-  amounts: readonly bigint[];
-  proofs: readonly (readonly `0x${string}`[])[];
-  rewarderAddress: Address;
-}
-
-/**
- * Represents a reward balance with both native and formatted values
- * @property formatted - Human-readable string format with proper decimals
- * @property native - Raw bigint value
- */
-export interface RewardBalance {
-  formatted: string;
-  native: bigint;
-}
-
-/**
- * Comprehensive summary of a user's reward status
- * @property totalEarned - Total rewards earned (claimed + claimable)
- * @property totalClaimed - Total rewards already claimed
- * @property claimable - Rewards available to claim
- */
-export interface RewardSummary {
-  totalEarned: RewardBalance;
-  totalClaimed: RewardBalance;
-  claimable: RewardBalance;
-}
-
-export abstract class SmartRewards {
-  protected readonly client: ReturnType<typeof createClient>;
-  protected readonly publicClient: PublicClient;
-  protected readonly walletClient: WalletClient;
-
-  constructor(
-    client: ReturnType<typeof createClient>,
-    publicClient: PublicClient,
-    walletClient: WalletClient
-  ) {
-    this.client = client;
-    this.publicClient = publicClient;
-    this.walletClient = walletClient;
-  }
-
-  public async getCampaigns(chainId: number): Promise<SteerResponse<Campaign[]>> {
-    const campaigns = await this.client.campaigns({
-      filter: {
-        chainId,
-      },
-    });
-
-    return {
-      data: (campaigns.data?.campaigns.edges.map((edge) => ({
-        ...edge.node,
-        vaults: edge.node.vaults?.map(vault => ({
-          ...vault,
-          beaconName: vault.beaconName || '',
-          name: vault.name || '',
-          protocol: vault.protocol || '',
-          protocolBaseType: vault.protocolBaseType || '',
-          targetProtocol: vault.targetProtocol || ''
-        })) || []
-      })) || []) as Campaign[],
-      status: campaigns.status,
-      success: true,
-    };
-  }
-
-  /**
-   * Retrieves campaigns associated with a specific pool address
-   * @param poolAddress - The address of the pool to get campaigns for
-   * @param chainId - Chain ID where the pool exists
-   * @returns Promise resolving to an array of campaigns associated with the pool
-   * 
-   * @example
-   * ```typescript
-   * // Get campaigns for a pool on a specific chain
-   * const campaigns = await smartRewards.campaignsByPool('0x...', 1);
-   * ```
-   */
-  public async campaignsByPool(
-    poolAddress: string,
-    chainId: number
-  ): Promise<SteerResponse<Campaign[]>> {
-    try {
-      const campaigns = await this.client.campaignsByPool({
-        pool: poolAddress,
-        chainId
-      });
-
-      return {
-        data: (campaigns.data?.campaignsByPool?.map(campaign => campaign ? {
-          ...campaign,
-          vaults: campaign.vaults?.map(vault => vault ? {
-            ...vault,
-            beaconName: vault.beaconName || '',
-            name: vault.name || '',
-            protocol: vault.protocol || '',
-            protocolBaseType: vault.protocolBaseType || '',
-            targetProtocol: vault.targetProtocol || ''
-          } : null).filter((v): v is NonNullable<typeof v> => v !== null) || []
-        } : null).filter((c): c is NonNullable<typeof c> => c !== null) || []) as Campaign[],
-        status: campaigns.status,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Retrieves claim proofs for a user that can be used to claim rewards
-   * @param user - Address of the user to get proofs for
-   * @param chainId - Chain ID where the claims exist
-   * @param campaignId - Optional campaign ID to filter claims
-   * @returns Promise resolving to claim proof data with pagination support
-   */
-  public async getClaimProofs(
-    user: Address,
-    chainId: number,
-    campaignId?: number
-  ): Promise<SteerResponse<ClaimProofsResponse>> {
-    try {
-      const normalizedUser = user.toLowerCase() as Address;
-      const response = await this.client.claimProofs({
-        user: normalizedUser,
-        filter: {
-          chainId,
-          campaignId
-        }
-      });
-
-      if (!response.data?.claimProofs) {
-        return {
-          data: null,
-          status: response.status,
-          success: true
-        };
-      }
-
-      const transformedResponse: ClaimProofsResponse = {
-        totalCount: response.data.claimProofs.totalCount,
-        pageInfo: {
-          hasNextPage: response.data.claimProofs.pageInfo.hasNextPage,
-          endCursor: response.data.claimProofs.pageInfo.endCursor || undefined
-        },
-        edges: response.data.claimProofs.edges.map(edge => ({
-          cursor: edge.cursor,
-          node: {
-            ...edge.node,
-            proof: edge.node.proof?.filter((p): p is string => p !== null) || []
-          }
-        }))
-      };
-
-      return {
-        data: transformedResponse,
-        status: response.status,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Retrieves historical claim data for a specific pool
-   * @param chainId - Chain ID where the pool exists
-   * @param pool - Address or identifier of the pool
-   * @param user - Optional user address to filter claims
-   * @returns Promise resolving to paginated claim history data
-   * 
-   * @example
-   * ```typescript
-   * // Get all claims for a pool
-   * const allClaims = await smartRewards.getClaimRewardsByPool(1, poolAddress);
-   * 
-   * // Get claims for a specific user in a pool
-   * const userClaims = await smartRewards.getClaimRewardsByPool(1, poolAddress, userAddress);
-   * ```
-   */
-  public async getClaimedRewardsByPool(
-    chainId: number,
-    pool: string,
-    user?: Address
-  ): Promise<SteerResponse<ClaimRewardsConnection>> {
-    try {
-      const normalizedPool = pool.toLowerCase();
-      const normalizedUser = user ? user.toLowerCase() as Address : undefined;
-      
-      const response = await this.client.claimRewards({
-        poolId: normalizedPool,
-        chainId,
-        filter: normalizedUser ? { user: normalizedUser } : undefined
-      });
-
-      if (!response.data?.claimRewards) {
-        return {
-          data: null,
-          status: response.status,
-          success: true
-        };
-      }
-
-      const transformedResponse: ClaimRewardsConnection = {
-        totalCount: response.data.claimRewards.totalCount,
-        pageInfo: {
-          hasNextPage: response.data.claimRewards.pageInfo.hasNextPage,
-          endCursor: response.data.claimRewards.pageInfo.endCursor
-        },
-        edges: response.data.claimRewards.edges.map(edge => ({
-          cursor: edge.cursor,
-          node: {
-            ...edge.node,
-            timestamp: Number(edge.node.timestamp)
-          }
-        }))
-      };
-
-      return {
-        data: transformedResponse,
-        status: response.status,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  
-
-  /**
-   * Gets a comprehensive summary of a user's reward status
-   * @param user - Address of the user
-   * @param chainId - Chain ID to check rewards on
-   * @param campaignId - Optional campaign ID to filter rewards
-   * @param decimals - Number of decimals for formatting (default: 18)
-   * @returns Promise resolving to reward summary with both native and formatted values
-   * 
-   * @example
-   * ```typescript
-   * const summary = await smartRewards.getRewardSummary(userAddress, chainId);
-   * console.log('Total earned:', summary.data.totalEarned.formatted);
-   * console.log('Available to claim:', summary.data.claimable.formatted);
-   * ```
-   */
-  public async getRewardSummary(
-    user: Address,
-    poolAddress: string,
-    chainId: number,
-    campaignId: number,
-    decimals: number = 18
-  ): Promise<SteerResponse<RewardSummary>> {
-    try {
-      // Lowercase addresses
-      const normalizedUser = user.toLowerCase() as Address;
-      const normalizedPoolAddress = poolAddress.toLowerCase();
-
-      // Get claimable rewards
-      const claimProofs = await this.getClaimProofs(normalizedUser, chainId, campaignId);
-
-      // Filter claim proofs by campaignId for additional safety
-      const filteredClaimProofs = claimProofs.data?.edges.filter(
-        edge => edge.node.campaignId === campaignId
-      ) || [];
-
-      const totalAmount = filteredClaimProofs.reduce(
-        (sum, edge) => sum + BigInt(edge.node.amount.split('.')[0]),
-        0n
-      ) || 0n;
-
-      // Get claimed rewards
-      const claimedRewards = await this.getClaimedRewardsByPool(chainId, normalizedPoolAddress, normalizedUser);
-
-      // Filter claimed rewards by campaign ID
-      const filteredClaimedRewards = claimedRewards.data?.edges.filter(
-        edge => Number(edge.node.campaign) === campaignId
-      ) || [];
-
-      const claimedAmount = filteredClaimedRewards.reduce(
-        (sum, edge) => sum + BigInt(edge.node.amount.split('.')[0]),
-        0n
-      ) || 0n;
-
-      // Calculate totals
-      const claimableAmount = totalAmount - claimedAmount;
-
-      const summary: RewardSummary = {
-        totalEarned: {
-          native: totalAmount,
-          formatted: formatUnits(totalAmount, decimals)
-        },
-        totalClaimed: {
-          native: claimedAmount,
-          formatted: formatUnits(claimedAmount, decimals)
-        },
-        claimable: {
-          native: claimableAmount,
-          formatted: formatUnits(claimableAmount, decimals)
-        }
-      };
-
-      return {
-        data: summary,
-        status: 200,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  public async getSmartRewarderContracts(): Promise<SteerResponse<readonly SmartRewarderContract[]>> {
-    try {
-      const response = await this.client.smartRewarderContracts();
-
-      return {
-        data: response.data?.smartRewarderContracts || [],
-        status: response.status,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Claims rewards from the smart rewarder contract
-   * @param params - Parameters required for claiming rewards
-   * @returns Promise resolving to transaction hash if successful
-   * 
-   * @remarks
-   * This method handles the low-level interaction with the smart contract.
-   * For a higher-level interface, consider using {@link claimCampaignRewards} instead.
-   * 
-   * @example
-   * ```typescript
-   * // Get claim proofs
-   * const claimProofs = await smartRewards.getClaimProofs(userAddress, chainId, campaignId);
-   * 
-   * // Get smart rewarder contract
-   * const rewarders = await smartRewards.getSmartRewarderContracts();
-   * const rewarder = rewarders.data?.find(r => r.chainId === chainId);
-   * 
-   * if (claimProofs.data && rewarder) {
-   *   // Prepare claim data
-   *   const claimData = smartRewards.prepareClaimData(claimProofs.data);
-   *   claimData.rewarderAddress = rewarder.address as Address;
-   *   
-   *   // Claim rewards
-   *   const tx = await smartRewards.claimReward(claimData);
-   * }
-   * ```
-   * 
-   * @throws Will throw an error if no wallet account is found
-   * @throws Will throw an error if contract simulation fails
-   */
-  public async claimReward(params: ClaimRewardParams): Promise<SteerResponse<Hash>> {
-    try {
-      const account = await this.walletClient.getAddresses();
-      if (!account[0]) throw new Error('No account found');
-
-      // Normalize addresses
-      const normalizedParams = {
-        ...params,
-        users: params.users.map(user => user.toLowerCase() as Address),
-        rewarderAddress: params.rewarderAddress.toLowerCase() as Address
-      };
-
-      const { request } = await this.publicClient.simulateContract({
-        address: normalizedParams.rewarderAddress,
-        abi: [{
-          type: 'function',
-          inputs: [
-            { name: 'users', internalType: 'address[]', type: 'address[]' },
-            { name: 'campaignIds', internalType: 'uint256[]', type: 'uint256[]' },
-            { name: 'amounts', internalType: 'uint256[]', type: 'uint256[]' },
-            { name: 'proofs', internalType: 'bytes32[][]', type: 'bytes32[][]' }
-          ],
-          name: 'claim',
-          outputs: [],
-          stateMutability: 'nonpayable'
-        }],
-        functionName: 'claim',
-        args: [
-          normalizedParams.users,
-          normalizedParams.campaignIds,
-          normalizedParams.amounts,
-          normalizedParams.proofs
-        ],
-        account: account[0]
-      });
-
-      const hash = await this.walletClient.writeContract(request);
-
-      return {
-        data: hash,
-        status: 200,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Helper function to prepare claim data from claim proofs
-   * @param proofs - The claim proofs response from getClaimProofs
-   * @returns ClaimRewardParams object ready for use with claimReward
-   * 
-   * @remarks
-   * This helper function transforms the claim proofs into the format required by the smart contract.
-   * Note that the returned object's rewarderAddress is empty and must be set before using with claimReward.
-   * 
-   * @example
-   * ```typescript
-   * // Get claim proofs and rewarder contract
-   * const proofs = await smartRewards.getClaimProofs(userAddress, chainId);
-   * const rewarders = await smartRewards.getSmartRewarderContracts();
-   * const rewarder = rewarders.data?.find(r => r.chainId === chainId);
-   * 
-   * if (proofs.data && rewarder) {
-   *   // Prepare the claim data
-   *   const claimData = smartRewards.prepareClaimData(proofs.data);
-   *   
-   *   // Set the rewarder address (required)
-   *   claimData.rewarderAddress = rewarder.address as Address;
-   *   
-   *   // Now the data is ready for claiming
-   *   const tx = await smartRewards.claimReward(claimData);
-   * }
-   * ```
-   */
-  public prepareClaimData(proofs: ClaimProofsResponse): ClaimRewardParams {
-    return {
-      users: proofs.edges.map(edge => edge.node.user.toLowerCase() as Address),
-      campaignIds: proofs.edges.map(edge => BigInt(edge.node.campaignId)),
-      amounts: proofs.edges.map(edge => BigInt(edge.node.amount.split('.')[0])),
-      proofs: proofs.edges.map(edge => edge.node.proof as readonly `0x${string}`[]),
-      rewarderAddress: '' as Address
-    };
-  }
-
-  /**
-   * Convenience function to handle the entire claim process
-   * @param userAddress The address of the user claiming rewards
-   * @param chainId The chain ID where the campaign exists
-   * @param campaignId Optional campaign ID to filter claims
-   * @returns Transaction hash if successful, or error details if failed
-   */
-  public async claimCampaignRewards(
-    userAddress: Address,
-    chainId: number,
-    campaignId?: number
-  ): Promise<SteerResponse<Hash>> {
-    try {
-      const normalizedUser = userAddress.toLowerCase() as Address;
-      
-      // Get claim proofs
-      const claimProofsResponse = await this.getClaimProofs(normalizedUser, chainId, campaignId);
-      if (!claimProofsResponse.data || claimProofsResponse.data.edges.length === 0) {
-        return {
-          data: null,
-          status: 400,
-          success: false,
-          error: 'No claim proofs found'
-        };
-      }
-
-      // Filter claim proofs by campaignId if specified
-      let filteredClaimProofs = claimProofsResponse.data;
-      if (campaignId !== undefined) {
-        filteredClaimProofs = {
-          ...claimProofsResponse.data,
-          edges: claimProofsResponse.data.edges.filter(edge => edge.node.campaignId === campaignId)
-        };
-        
-        // If no matching campaign proofs found after filtering
-        if (filteredClaimProofs.edges.length === 0) {
-          return {
-            data: null,
-            status: 400,
-            success: false,
-            error: `No claim proofs found for campaign ID ${campaignId}`
-          };
-        }
-      }
-
-      // Get smart rewarder contract
-      const rewarderResponse = await this.getSmartRewarderContracts();
-      const rewarder = rewarderResponse.data?.find(r => r.chainId === chainId);
-      if (!rewarder) {
-        return {
-          data: null,
-          status: 400,
-          success: false,
-          error: `No smart rewarder contract found for chain ${chainId}`
-        };
-      }
-
-      // Prepare claim data
-      const claimData = this.prepareClaimData(filteredClaimProofs);
-      claimData.rewarderAddress = rewarder.address as Address;
-
-      // Execute claim
-      return await this.claimReward(claimData);
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Prepares the claim rewards campaign object with all necessary data for contract interaction
-   * @param userAddress The address of the user claiming rewards
-   * @param chainId The chain ID where the campaign exists
-   * @param campaignId Optional campaign ID to filter claims
-   * @returns Promise resolving to an object containing all necessary data for claiming rewards
-   * 
-   * @example
-   * ```typescript
-   * // Get the prepared claim data
-   * const claimData = await smartRewards.prepareClaimRewardsCampaign(userAddress, chainId, campaignId);
-   * 
-   * if (claimData.success) {
-   *   // Use the data with your own contract interaction methods
-   *   const { address, abi, functionName, args } = claimData.data;
-   *   // Execute the contract call using your preferred method
-   * }
-   * ```
-   */
-  public async prepareClaimRewardsCampaign(
-    userAddress: Address,
-    chainId: number,
-    campaignId?: number
-  ): Promise<SteerResponse<{
-    address: Address;
-    abi: {
-      type: string;
-      inputs: {
-        name: string;
-        internalType: string;
-        type: string;
-      }[];
-      name: string;
-      outputs: never[];
-      stateMutability: string;
-    }[];
-    functionName: string;
-    args: readonly [
-      readonly Address[],
-      readonly bigint[],
-      readonly bigint[],
-      readonly (readonly `0x${string}`[])[]
-    ];
-  }>> {
-    try {
-      const normalizedUser = userAddress.toLowerCase() as Address;
-      
-      // Get claim proofs
-      const claimProofsResponse = await this.getClaimProofs(normalizedUser, chainId, campaignId);
-      if (!claimProofsResponse.data || claimProofsResponse.data.edges.length === 0) {
-        return {
-          data: null,
-          status: 400,
-          success: false,
-          error: 'No claim proofs found'
-        };
-      }
-
-      // Filter claim proofs by campaignId if specified
-      let filteredClaimProofs = claimProofsResponse.data;
-      if (campaignId !== undefined) {
-        filteredClaimProofs = {
-          ...claimProofsResponse.data,
-          edges: claimProofsResponse.data.edges.filter(edge => edge.node.campaignId === campaignId)
-        };
-        
-        // If no matching campaign proofs found after filtering
-        if (filteredClaimProofs.edges.length === 0) {
-          return {
-            data: null,
-            status: 400,
-            success: false,
-            error: `No claim proofs found for campaign ID ${campaignId}`
-          };
-        }
-      }
-
-      // Get smart rewarder contract
-      const rewarderResponse = await this.getSmartRewarderContracts();
-      const rewarder = rewarderResponse.data?.find(r => r.chainId === chainId);
-      if (!rewarder) {
-        return {
-          data: null,
-          status: 400,
-          success: false,
-          error: `No smart rewarder contract found for chain ${chainId}`
-        };
-      }
-
-      // Prepare claim data
-      const claimData = this.prepareClaimData(filteredClaimProofs);
-
-      // Prepare the complete contract interaction data
-      return {
-        data: {
-          address: rewarder.address as Address,
-          abi: [{
-            type: 'function',
-            inputs: [
-              { name: 'users', internalType: 'address[]', type: 'address[]' },
-              { name: 'campaignIds', internalType: 'uint256[]', type: 'uint256[]' },
-              { name: 'amounts', internalType: 'uint256[]', type: 'uint256[]' },
-              { name: 'proofs', internalType: 'bytes32[][]', type: 'bytes32[][]' }
-            ],
-            name: 'claim',
-            outputs: [],
-            stateMutability: 'nonpayable'
-          }],
-          functionName: 'claim',
-          args: [
-            claimData.users,
-            claimData.campaignIds,
-            claimData.amounts,
-            claimData.proofs
-          ] as const
-        },
-        status: 200,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Checks if a chain is supported by checking if it has a subgraph URL
-   * @param chainId The chain ID to check
-   * @returns boolean indicating if the chain is supported
-   */
-  public supportsChain(chainId: number): boolean {
-    return getSubgraphUrlByChainId(chainId) !== undefined;
-  }
-}