@steerprotocol/sdk 1.30.8 → 2.0.0

package/dist/cjs/base/SmartRewardClient.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SmartRewardsClient = void 0;
-const api_sdk_1 = require("@steerprotocol/api-sdk");
-const SmartRewards_js_1 = require("./SmartRewards.js");
-const api_js_1 = require("../const/api.js");
-/**
- * Client for interacting with Steer Protocol's Smart Rewards system.
- * This client provides functionality for managing rewards, claims, and campaigns.
- *
- * @example
- * ```typescript
- * import { createPublicClient, createWalletClient, http } from 'viem';
- * import { mainnet } from 'viem/chains';
- * import { SmartRewardsClient } from '@steerprotocol/sdk';
- *
- * // Create viem clients
- * const publicClient = createPublicClient({
- *   chain: mainnet,
- *   transport: http()
- * });
- *
- * const walletClient = createWalletClient({
- *   chain: mainnet,
- *   transport: http()
- * });
- *
- * // Initialize the Smart Rewards client
- * const rewardsClient = new SmartRewardsClient(publicClient, walletClient, 'production');
- *
- * // Get user's reward summary
- * const summary = await rewardsClient.getRewardSummary(userAddress, chainId);
- *
- * // Claim rewards
- * const tx = await rewardsClient.claimCampaignRewards(userAddress, chainId);
- * ```
- *
- * @group Client
- */
-class SmartRewardsClient extends SmartRewards_js_1.SmartRewards {
-    /**
-     * Creates a new instance of SmartRewardsClient
-     * @param publicClient - The public client for reading from the blockchain
-     * @param walletClient - The wallet client for writing to the blockchain
-     * @param environment - The environment to use ('production' or 'development')
-     * @param version - Optional API version to use (defaults to 'v1')
-     */
-    constructor(publicClient, walletClient, environment, version = 'v1') {
-        const apiUrl = (0, api_js_1.getApiUrl)(environment, version);
-        const apiClient = (0, api_sdk_1.createClient)(apiUrl);
-        super(apiClient, publicClient, walletClient);
-    }
-}
-exports.SmartRewardsClient = SmartRewardsClient;
-//# sourceMappingURL=SmartRewardClient.js.map

package/dist/cjs/base/SmartRewardClient.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SmartRewardClient.js","sourceRoot":"","sources":["../../../src/base/SmartRewardClient.ts"],"names":[],"mappings":";;;AAAA,oDAAsD;AAEtD,uDAAiD;AACjD,4CAA4C;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAa,kBAAmB,SAAQ,8BAAY;IAClD;;;;;;OAMG;IACH,YACE,YAA0B,EAC1B,YAA0B,EAC1B,WAAyC,EACzC,UAAgB,IAAI;QAEpB,MAAM,MAAM,GAAG,IAAA,kBAAS,EAAC,WAAW,EAAE,OAAO,CAAC,CAAC;QAC/C,MAAM,SAAS,GAAG,IAAA,sBAAY,EAAC,MAAM,CAAC,CAAC;QACvC,KAAK,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;IAC/C,CAAC;CACF;AAlBD,gDAkBC","sourcesContent":["import { createClient } from '@steerprotocol/api-sdk';\nimport type { PublicClient, WalletClient } from 'viem';\nimport { SmartRewards } from './SmartRewards.js';\nimport { getApiUrl } from '../const/api.js';\n\n/**\n * Client for interacting with Steer Protocol's Smart Rewards system.\n * This client provides functionality for managing rewards, claims, and campaigns.\n * \n * @example\n * ```typescript\n * import { createPublicClient, createWalletClient, http } from 'viem';\n * import { mainnet } from 'viem/chains';\n * import { SmartRewardsClient } from '@steerprotocol/sdk';\n * \n * // Create viem clients\n * const publicClient = createPublicClient({\n *   chain: mainnet,\n *   transport: http()\n * });\n * \n * const walletClient = createWalletClient({\n *   chain: mainnet,\n *   transport: http()\n * });\n * \n * // Initialize the Smart Rewards client\n * const rewardsClient = new SmartRewardsClient(publicClient, walletClient, 'production');\n * \n * // Get user's reward summary\n * const summary = await rewardsClient.getRewardSummary(userAddress, chainId);\n * \n * // Claim rewards\n * const tx = await rewardsClient.claimCampaignRewards(userAddress, chainId);\n * ```\n * \n * @group Client\n */\nexport class SmartRewardsClient extends SmartRewards {\n  /**\n   * Creates a new instance of SmartRewardsClient\n   * @param publicClient - The public client for reading from the blockchain\n   * @param walletClient - The wallet client for writing to the blockchain\n   * @param environment - The environment to use ('production' or 'development')\n   * @param version - Optional API version to use (defaults to 'v1')\n   */\n  constructor(\n    publicClient: PublicClient, \n    walletClient: WalletClient,\n    environment: 'production' | 'development',\n    version: 'v1' = 'v1'\n  ) {\n    const apiUrl = getApiUrl(environment, version);\n    const apiClient = createClient(apiUrl);\n    super(apiClient, publicClient, walletClient);\n  }\n}"]}

package/dist/cjs/base/SmartRewards.js

@@ -1,560 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SmartRewards = void 0;
-const viem_1 = require("viem");
-const subgraph_js_1 = require("../const/subgraph.js");
-class SmartRewards {
-    constructor(client, publicClient, walletClient) {
-        this.client = client;
-        this.publicClient = publicClient;
-        this.walletClient = walletClient;
-    }
-    async getCampaigns(chainId) {
-        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 || ''
-                })) || []
-            })) || []),
-            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);
-     * ```
-     */
-    async campaignsByPool(poolAddress, chainId) {
-        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 !== null) || []
-                } : null).filter((c) => c !== null) || []),
-                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
-     */
-    async getClaimProofs(user, chainId, campaignId) {
-        try {
-            const normalizedUser = user.toLowerCase();
-            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 = {
-                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 !== 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);
-     * ```
-     */
-    async getClaimedRewardsByPool(chainId, pool, user) {
-        try {
-            const normalizedPool = pool.toLowerCase();
-            const normalizedUser = user ? user.toLowerCase() : 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 = {
-                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);
-     * ```
-     */
-    async getRewardSummary(user, poolAddress, chainId, campaignId, decimals = 18) {
-        try {
-            // Lowercase addresses
-            const normalizedUser = user.toLowerCase();
-            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 = {
-                totalEarned: {
-                    native: totalAmount,
-                    formatted: (0, viem_1.formatUnits)(totalAmount, decimals)
-                },
-                totalClaimed: {
-                    native: claimedAmount,
-                    formatted: (0, viem_1.formatUnits)(claimedAmount, decimals)
-                },
-                claimable: {
-                    native: claimableAmount,
-                    formatted: (0, viem_1.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'
-            };
-        }
-    }
-    async getSmartRewarderContracts() {
-        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
-     */
-    async claimReward(params) {
-        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()),
-                rewarderAddress: params.rewarderAddress.toLowerCase()
-            };
-            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);
-     * }
-     * ```
-     */
-    prepareClaimData(proofs) {
-        return {
-            users: proofs.edges.map(edge => edge.node.user.toLowerCase()),
-            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),
-            rewarderAddress: ''
-        };
-    }
-    /**
-     * 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
-     */
-    async claimCampaignRewards(userAddress, chainId, campaignId) {
-        try {
-            const normalizedUser = userAddress.toLowerCase();
-            // 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;
-            // 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
-     * }
-     * ```
-     */
-    async prepareClaimRewardsCampaign(userAddress, chainId, campaignId) {
-        try {
-            const normalizedUser = userAddress.toLowerCase();
-            // 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,
-                    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
-                    ]
-                },
-                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
-     */
-    supportsChain(chainId) {
-        return (0, subgraph_js_1.getSubgraphUrlByChainId)(chainId) !== undefined;
-    }
-}
-exports.SmartRewards = SmartRewards;
-//# sourceMappingURL=SmartRewards.js.map