@steerprotocol/sdk 1.31.0 → 2.0.0

package/dist/cjs/base/StakingClient.js

@@ -1,663 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StakingClient = void 0;
-const SubgraphClient_js_1 = require("./SubgraphClient.js");
-const index_js_1 = require("./vault/withdraw/index.js");
-const protocol_js_1 = require("../const/protocol.js");
-const decimal_js_1 = require("decimal.js");
-// ABIs for staking contracts
-const SINGLE_REWARD_ABI = [
-    {
-        "inputs": [],
-        "name": "lastTimeRewardApplicable",
-        "outputs": [{ "type": "uint256" }],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [{ "type": "address" }],
-        "name": "earned",
-        "outputs": [{ "type": "uint256" }],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "totalSupply",
-        "outputs": [{ "type": "uint256" }],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [{ "type": "address" }],
-        "name": "balanceOf",
-        "outputs": [{ "type": "uint256" }],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [{ "type": "uint256" }],
-        "name": "stake",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "inputs": [{ "type": "uint256" }],
-        "name": "withdraw",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "getReward",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "exit",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    }
-];
-const DUAL_REWARD_ABI = [
-    ...SINGLE_REWARD_ABI,
-    {
-        "inputs": [{ "type": "address" }],
-        "name": "earnedA",
-        "outputs": [{ "type": "uint256" }],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [{ "type": "address" }],
-        "name": "earnedB",
-        "outputs": [{ "type": "uint256" }],
-        "stateMutability": "view",
-        "type": "function"
-    }
-];
-const ERC20_ABI = [
-    {
-        "inputs": [],
-        "name": "decimals",
-        "outputs": [{ "type": "uint8" }],
-        "stateMutability": "view",
-        "type": "function"
-    }
-];
-class StakingClient extends SubgraphClient_js_1.SubgraphClient {
-    constructor(client) {
-        super(client);
-        this.stakingPoolsEndpoint = 'https://9i52h964s3.execute-api.us-east-1.amazonaws.com/dev/staking-pools';
-        this.publicClient = client;
-        this.walletClient = client;
-        this.withdrawClient = new index_js_1.VaultWithdrawClient(client, client);
-    }
-    /**
-     * Fetches and filters staking pools based on provided criteria
-     * @param filter Optional filter object to filter the pools
-     */
-    async getStakingPools(filter) {
-        try {
-            const response = await fetch(this.stakingPoolsEndpoint);
-            if (!response.ok) {
-                throw new Error('Failed to fetch staking pools');
-            }
-            const rawPools = (await response.json()).pools;
-            // Convert and validate protocols in the response
-            let pools = rawPools
-                .filter((pool) => (0, protocol_js_1.isValidStakingProtocol)(pool.protocol))
-                .map((pool) => ({
-                ...pool,
-                protocol: (0, protocol_js_1.normalizeProtocol)(pool.protocol)
-            }));
-            // Apply filters if provided
-            if (filter) {
-                pools = this.filterPools(pools, filter);
-            }
-            return {
-                data: pools,
-                status: 200,
-                success: true,
-            };
-        }
-        catch (error) {
-            return {
-                data: null,
-                status: 500,
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred',
-            };
-        }
-    }
-    /**
-     * Gets only currently active staking pools
-     * @param chainId Optional chain ID to filter pools
-     * @param protocol Optional protocol name to filter pools
-     */
-    async getLiveStakingPools(chainId, protocol) {
-        return this.getStakingPools({
-            chainId,
-            protocol,
-            isLive: true,
-            includeExpired: false
-        });
-    }
-    /**
-     * Gets all dual rewards staking pools
-     * @param chainId Optional chain ID to filter pools
-     * @param protocol Optional protocol name to filter pools
-     * @param isLive Optional flag to only get live pools
-     */
-    async getDualRewardsStakingPools(chainId, protocol, isLive) {
-        return this.getStakingPools({
-            chainId,
-            protocol,
-            isLive,
-            isDualRewards: true
-        });
-    }
-    /**
-     * Gets high yield staking pools based on minimum daily emissions
-     * @param minDailyEmissionA Minimum daily emission for reward A
-     * @param minDailyEmissionB Optional minimum daily emission for reward B
-     * @param chainId Optional chain ID to filter pools
-     */
-    async getHighYieldStakingPools(minDailyEmissionA, minDailyEmissionB, chainId) {
-        return this.getStakingPools({
-            chainId,
-            minDailyEmissionA,
-            minDailyEmissionB,
-            isLive: true
-        });
-    }
-    /**
-     * Internal helper to filter pools based on criteria
-     */
-    filterPools(pools, filter) {
-        return pools.filter(pool => {
-            // Chain ID filter
-            if (filter.chainId !== undefined && pool.chainId !== filter.chainId) {
-                return false;
-            }
-            // Protocol filter
-            if (filter.protocol !== undefined && pool.protocol !== filter.protocol) {
-                return false;
-            }
-            // Dual rewards filter
-            if (filter.isDualRewards !== undefined && pool.isDualFactory !== filter.isDualRewards) {
-                return false;
-            }
-            // Daily emission filters
-            if (filter.minDailyEmissionA !== undefined && pool.dailyEmissionRewardA < filter.minDailyEmissionA) {
-                return false;
-            }
-            if (filter.minDailyEmissionB !== undefined && pool.dailyEmissionRewardB !== undefined && pool.dailyEmissionRewardB < filter.minDailyEmissionB) {
-                return false;
-            }
-            // Live/Expired filter
-            if (filter.isLive !== undefined) {
-                const now = Math.floor(Date.now() / 1000);
-                const periodFinish = parseInt(pool.periodFinish);
-                const isPoolLive = periodFinish > now;
-                if (filter.isLive && !isPoolLive) {
-                    return false;
-                }
-                if (!filter.includeExpired && !isPoolLive) {
-                    return false;
-                }
-            }
-            return true;
-        });
-    }
-    /**
-     * Stakes tokens in a staking pool
-     * @param params The staking parameters
-     */
-    async stake(params) {
-        try {
-            const account = await this.walletClient.getAddresses();
-            if (!account[0])
-                throw new Error('No account found');
-            const { request } = await this.publicClient.simulateContract({
-                address: params.stakingPool,
-                abi: SINGLE_REWARD_ABI,
-                functionName: 'stake',
-                args: [params.amount],
-                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',
-            };
-        }
-    }
-    /**
-     * Withdraws tokens from a staking pool
-     * @param params The withdrawal parameters
-     */
-    async withdraw(params) {
-        try {
-            const account = await this.walletClient.getAddresses();
-            if (!account[0])
-                throw new Error('No account found');
-            const { request } = await this.publicClient.simulateContract({
-                address: params.stakingPool,
-                abi: SINGLE_REWARD_ABI,
-                functionName: 'withdraw',
-                args: [params.amount],
-                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',
-            };
-        }
-    }
-    /**
-     * Claims rewards from a staking pool
-     * @param params The reward claim parameters
-     */
-    async getReward(params) {
-        try {
-            const account = await this.walletClient.getAddresses();
-            if (!account[0])
-                throw new Error('No account found');
-            const { request } = await this.publicClient.simulateContract({
-                address: params.stakingPool,
-                abi: SINGLE_REWARD_ABI,
-                functionName: 'getReward',
-                args: [],
-                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',
-            };
-        }
-    }
-    /**
-     * Gets the earned rewards for an account in a staking pool
-     * @param stakingPool The staking pool address
-     * @param account The account to check rewards for
-     */
-    async earned(stakingPool, account) {
-        try {
-            // First try to read as single reward
-            try {
-                const reward = await this.publicClient.readContract({
-                    address: stakingPool,
-                    abi: SINGLE_REWARD_ABI,
-                    functionName: 'earned',
-                    args: [account],
-                });
-                return {
-                    data: { rewardA: reward },
-                    status: 200,
-                    success: true,
-                };
-            }
-            catch {
-                // If single reward fails, try dual rewards
-                const [rewardA, rewardB] = await Promise.all([
-                    this.publicClient.readContract({
-                        address: stakingPool,
-                        abi: DUAL_REWARD_ABI,
-                        functionName: 'earnedA',
-                        args: [account],
-                    }),
-                    this.publicClient.readContract({
-                        address: stakingPool,
-                        abi: DUAL_REWARD_ABI,
-                        functionName: 'earnedB',
-                        args: [account],
-                    }),
-                ]);
-                return {
-                    data: { rewardA, rewardB },
-                    status: 200,
-                    success: true,
-                };
-            }
-        }
-        catch (error) {
-            return {
-                data: null,
-                status: 500,
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred',
-            };
-        }
-    }
-    /**
-     * Gets the total supply of staked tokens in a pool
-     * @param stakingPool The staking pool address
-     */
-    async totalSupply(stakingPool) {
-        try {
-            const totalSupply = await this.publicClient.readContract({
-                address: stakingPool,
-                abi: SINGLE_REWARD_ABI,
-                functionName: 'totalSupply',
-            });
-            return {
-                data: totalSupply,
-                status: 200,
-                success: true,
-            };
-        }
-        catch (error) {
-            return {
-                data: null,
-                status: 500,
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred',
-            };
-        }
-    }
-    /**
-     * Gets the staked balance of an account in a pool
-     * @param stakingPool The staking pool address
-     * @param account The account to check balance for
-     */
-    async balanceOf(stakingPool, account) {
-        try {
-            const balance = await this.publicClient.readContract({
-                address: stakingPool,
-                abi: SINGLE_REWARD_ABI,
-                functionName: 'balanceOf',
-                args: [account],
-            });
-            return {
-                data: balance,
-                status: 200,
-                success: true,
-            };
-        }
-        catch (error) {
-            return {
-                data: null,
-                status: 500,
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred',
-            };
-        }
-    }
-    /**
-     * Calculates the APR for a staking pool
-     * @param pool The staking pool data
-     * @param rewardTokenPriceUSD The price of the reward token in USD
-     * @param totalStakedUSD The total value staked in USD
-     */
-    calculateAPR(pool, rewardTokenPriceUSD, totalStakedUSD) {
-        if (totalStakedUSD === 0) {
-            return 0;
-        }
-        const dailyRewardUSD = pool.dailyEmissionRewardA * rewardTokenPriceUSD;
-        let apr = (dailyRewardUSD * 365 * 100) / totalStakedUSD;
-        if (pool.isDualFactory && pool.dailyEmissionRewardB) {
-            const dailyRewardBUSD = pool.dailyEmissionRewardB * rewardTokenPriceUSD;
-            apr += (dailyRewardBUSD * 365 * 100) / totalStakedUSD;
-        }
-        return apr;
-    }
-    /**
-     * Calculates the USD value of tokens in a staking pool
-     * Handles both regular staking pools and Steer vaults
-     * @param params Parameters for token value calculation
-     */
-    async getSteerLpTokenValue(params) {
-        try {
-            // First, get the staking pool details
-            const pool = params.stakingPool;
-            const chainId = await this.publicClient.getChainId();
-            if (chainId !== pool.chainId) {
-                throw new Error(`Chain ID mismatch| expected ${pool.chainId} but got ${chainId}`);
-            }
-            // Handle Steer vault staking pools
-            if (pool.isSteerVault && pool.staking) {
-                if (!pool.vaultTokens) {
-                    throw new Error('Vault tokens information not found');
-                }
-                // Get underlying token amounts from LP token
-                const tokensResponse = await this.withdrawClient.getTokensFromLp(pool.staking.address, params.amount);
-                if (!tokensResponse.success || !tokensResponse.data) {
-                    throw new Error('Failed to get token amounts from LP');
-                }
-                // Get decimals for both tokens
-                const [token0Decimals, token1Decimals] = await Promise.all([
-                    this.publicClient.readContract({
-                        address: pool.vaultTokens.token0.address,
-                        abi: ERC20_ABI,
-                        functionName: 'decimals'
-                    }),
-                    this.publicClient.readContract({
-                        address: pool.vaultTokens.token1.address,
-                        abi: ERC20_ABI,
-                        functionName: 'decimals'
-                    })
-                ]);
-                // Use Decimal.js for precise calculations
-                const token0Amount = new decimal_js_1.Decimal(tokensResponse.data.token0Val.toString())
-                    .div(new decimal_js_1.Decimal(10).pow(token0Decimals))
-                    .mul(params.token0UsdPrice);
-                const token1Amount = new decimal_js_1.Decimal(tokensResponse.data.token1Val.toString())
-                    .div(new decimal_js_1.Decimal(10).pow(token1Decimals))
-                    .mul(params.token1UsdPrice);
-                const totalValueUsd = token0Amount.plus(token1Amount).toNumber();
-                const token0ValueUsd = token0Amount.toNumber();
-                const token1ValueUsd = token1Amount.toNumber();
-                return {
-                    data: {
-                        totalValueUsd,
-                        token0Value: token0ValueUsd,
-                        token1Value: token1ValueUsd
-                    },
-                    status: 200,
-                    success: true
-                };
-            }
-            // Handle regular staking pools (non-Steer vault)
-            const stakingDecimals = await this.publicClient.readContract({
-                address: pool.staking.address,
-                abi: ERC20_ABI,
-                functionName: 'decimals'
-            });
-            const tokenValueUsd = new decimal_js_1.Decimal(params.amount.toString())
-                .div(new decimal_js_1.Decimal(10).pow(stakingDecimals))
-                .mul(params.token0UsdPrice)
-                .toNumber();
-            return {
-                data: {
-                    totalValueUsd: tokenValueUsd,
-                    tokenValue: tokenValueUsd
-                },
-                status: 200,
-                success: true
-            };
-        }
-        catch (error) {
-            return {
-                data: null,
-                status: 500,
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred'
-            };
-        }
-    }
-    /**
-     * Gets the total staking amount in USD for a pool
-     * @param stakingPool The staking pool
-     * @param token0UsdPrice Price of token0 in USD
-     * @param token1UsdPrice Price of token1 in USD (required for Steer vaults)
-     */
-    async getTotalStakingAmountInUsd(stakingPool, token0UsdPrice, token1UsdPrice) {
-        try {
-            // Get total supply
-            const totalSupplyResponse = await this.totalSupply(stakingPool.stakingPool);
-            if (!totalSupplyResponse.success || !totalSupplyResponse.data) {
-                throw new Error('Failed to get total supply');
-            }
-            // Get value using getSteerLpTokenValue
-            const valueResponse = await this.getSteerLpTokenValue({
-                stakingPool,
-                amount: totalSupplyResponse.data,
-                token0UsdPrice,
-                token1UsdPrice: token1UsdPrice || token0UsdPrice
-            });
-            if (!valueResponse.success || !valueResponse.data) {
-                throw new Error('Failed to calculate token value');
-            }
-            return {
-                data: valueResponse.data.totalValueUsd,
-                status: 200,
-                success: true
-            };
-        }
-        catch (error) {
-            return {
-                data: null,
-                status: 500,
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred'
-            };
-        }
-    }
-    /**
-     * Prepares the transaction data for staking tokens without executing it
-     * @param params The staking parameters
-     */
-    async prepareStakeTx(params) {
-        try {
-            return {
-                data: {
-                    address: params.stakingPool,
-                    abi: [{
-                            type: 'function',
-                            inputs: [
-                                { name: 'amount', internalType: 'uint256', type: 'uint256' }
-                            ],
-                            name: 'stake',
-                            outputs: [],
-                            stateMutability: 'nonpayable'
-                        }],
-                    functionName: 'stake',
-                    args: [params.amount]
-                },
-                status: 200,
-                success: true
-            };
-        }
-        catch (error) {
-            return {
-                data: null,
-                status: 500,
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred'
-            };
-        }
-    }
-    /**
-     * Prepares the transaction data for withdrawing tokens without executing it
-     * @param params The withdrawal parameters
-     */
-    async prepareWithdrawTx(params) {
-        try {
-            return {
-                data: {
-                    address: params.stakingPool,
-                    abi: [{
-                            type: 'function',
-                            inputs: [
-                                { name: 'amount', internalType: 'uint256', type: 'uint256' }
-                            ],
-                            name: 'withdraw',
-                            outputs: [],
-                            stateMutability: 'nonpayable'
-                        }],
-                    functionName: 'withdraw',
-                    args: [params.amount]
-                },
-                status: 200,
-                success: true
-            };
-        }
-        catch (error) {
-            return {
-                data: null,
-                status: 500,
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred'
-            };
-        }
-    }
-    /**
-     * Prepares the transaction data for claiming rewards without executing it
-     * @param params The reward claim parameters
-     */
-    async prepareGetRewardTx(params) {
-        try {
-            return {
-                data: {
-                    address: params.stakingPool,
-                    abi: [{
-                            type: 'function',
-                            inputs: [],
-                            name: 'getReward',
-                            outputs: [],
-                            stateMutability: 'nonpayable'
-                        }],
-                    functionName: 'getReward',
-                    args: []
-                },
-                status: 200,
-                success: true
-            };
-        }
-        catch (error) {
-            return {
-                data: null,
-                status: 500,
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred'
-            };
-        }
-    }
-}
-exports.StakingClient = StakingClient;
-//# sourceMappingURL=StakingClient.js.map