@strkfarm/sdk 1.0.28 → 1.0.30

package/src/strategies/index.ts

@@ -1,3 +1,4 @@
 export * from './autoCompounderStrk';
 export * from './vesu-rebalance';
-export * from './ekubo-cl-vault';
+export * from './ekubo-cl-vault';
+export * from './base-strategy';

package/src/strategies/vesu-rebalance.ts

@@ -1,7 +1,7 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { FlowChartColors, getNoRiskTags, IConfig, IInvestmentFlow, IProtocol, IStrategyMetadata, RiskFactor, RiskType } from "@/interfaces";
-import { Pricer } from "@/modules";
-import { CairoCustomEnum, Contract, num, uint256 } from "starknet";
+import { AvnuWrapper, Pricer, SwapInfo } from "@/modules";
+import { Account, CairoCustomEnum, Contract, num, uint256 } from "starknet";
 import VesuRebalanceAbi from '@/data/vesu-rebalance.abi.json';
 import { Global, logger } from "@/global";
 import { assert } from "@/utils";
@@ -9,6 +9,8 @@ import axios from "axios";
 import { PricerBase } from "@/modules/pricerBase";
 import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
 import { getAPIUsingHeadlessBrowser } from "@/node/headless";
+import { VesuHarvests } from "@/modules/harvests";
+import VesuPoolIDs from "@/data/vesu_pools.json";
 
 interface PoolProps {
     pool_id: ContractAddr;
@@ -83,7 +85,7 @@ export class VesuRebalance extends BaseStrategy<SingleTokenInfo, SingleActionAmo
      * @param receiver - Address that will receive the strategy tokens
      * @returns Populated contract call for deposit
      */
-    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr) {
+    async depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr) {
         // Technically its not erc4626 abi, but we just need approve call
         // so, its ok to use it
         assert(amountInfo.tokenInfo.address.eq(this.asset().address), 'Deposit token mismatch');
@@ -100,7 +102,7 @@ export class VesuRebalance extends BaseStrategy<SingleTokenInfo, SingleActionAmo
      * @param owner - Address that owns the strategy tokens
      * @returns Populated contract call for withdrawal
      */
-    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr) {
+    async withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr) {
         return [this.contract.populate('withdraw', [uint256.bnToUint256(amountInfo.amount.toWei()), receiver.address, owner.address])];
     }
 
@@ -189,9 +191,10 @@ export class VesuRebalance extends BaseStrategy<SingleTokenInfo, SingleActionAmo
         logger.verbose(typeof _pool);
         logger.verbose(`name: ${_pool?.name}`);
         const name = _pool?.name;
-        logger.verbose(`name2: ${name}`);
+        logger.verbose(`name2: ${name}, ${!name ? true : false}, ${name?.length}, ${typeof name}`);
         const assetInfo = _pool?.assets.find((d: any) => this.asset().address.eqString(d.address));
         if (!name) {
+            logger.verbose(`Pool not found`);
             throw new Error(`Pool name ${p.pool_id.address.toString()} not found`);
         }
         if (!assetInfo) {
@@ -302,15 +305,7 @@ export class VesuRebalance extends BaseStrategy<SingleTokenInfo, SingleActionAmo
         }
         
 
-        let isErrorPoolsAPI = false;
-        let pools: any[] = [];
-        try {
-            const data = await getAPIUsingHeadlessBrowser('https://api.vesu.xyz/pools');
-            pools = data.data;
-        } catch (e) {
-            console.error(`${VesuRebalance.name}: Error fetching pools for ${this.address.address}`, e);
-            isErrorPoolsAPI = true;
-        }
+        let { pools, isErrorPoolsAPI } = await this.getVesuPools();
 
         const totalAssets = (await this.getTVL()).amount;
 
@@ -324,6 +319,34 @@ export class VesuRebalance extends BaseStrategy<SingleTokenInfo, SingleActionAmo
         }
     }
 
+    async getVesuPools(retry = 0): Promise<{pools: any[], isErrorPoolsAPI: boolean}> {
+        let isErrorPoolsAPI = false;
+        let pools: any[] = [];
+        try {
+            const data = await getAPIUsingHeadlessBrowser('https://api.vesu.xyz/pools');
+            pools = data.data;
+
+            // Vesu API is unstable sometimes, some Pools may be missing sometimes
+            for (const pool of VesuPoolIDs.data) {
+                const found = pools.find((d: any) => d.id === pool.id);
+                if (!found) {
+                    logger.verbose(`VesuRebalance: pools: ${JSON.stringify(pools)}`);
+                    logger.verbose(`VesuRebalance: Pool ${pool.id} not found in Vesu API, using hardcoded data`);
+                    throw new Error('pool not found [sanity check]')
+                }
+            }
+        } catch (e) {
+            logger.error(`${VesuRebalance.name}: Error fetching pools for ${this.address.address}, retry ${retry}`, e);
+            isErrorPoolsAPI = true;
+            if (retry < 10) {
+                await new Promise((resolve) => setTimeout(resolve, 5000 * (retry + 1)));
+                return await this.getVesuPools(retry + 1);
+            }
+        }
+
+        return { pools, isErrorPoolsAPI };
+    }
+
     /**
      * Calculates the weighted average APY across all pools based on USD value.
      * @returns {Promise<number>} The weighted average APY across all pools
@@ -497,6 +520,46 @@ export class VesuRebalance extends BaseStrategy<SingleTokenInfo, SingleActionAmo
         });
         return [baseFlow];
     }
+
+    async harvest(acc: Account) { 
+        const vesuHarvest = new VesuHarvests(this.config);
+        const harvests = await vesuHarvest.getUnHarvestedRewards(this.address);
+        const harvest = harvests[0];
+        const avnu = new AvnuWrapper();
+        let swapInfo: SwapInfo = {
+            token_from_address: harvest.token.address,
+            token_from_amount: uint256.bnToUint256(harvest.actualReward.toWei()),
+            token_to_address: this.asset().address.address,
+            token_to_amount: uint256.bnToUint256(0),
+            token_to_min_amount: uint256.bnToUint256(0),
+            beneficiary: this.address.address,
+            integrator_fee_amount_bps: 0,
+            integrator_fee_recipient: this.address.address,
+            routes: []
+        }
+        if (!this.asset().address.eqString(harvest.token.address)) {
+            const quote = await avnu.getQuotes(
+                harvest.token.address, 
+                this.asset().address.address,
+                harvest.actualReward.toWei(),
+                this.address.address
+            );
+            swapInfo = await avnu.getSwapInfo(quote, this.address.address, 0, this.address.address);
+        }
+        
+        return [
+            this.contract.populate('harvest', [
+                harvest.rewardsContract.address,
+                {
+                    id: harvest.claim.id,
+                    amount: harvest.claim.amount.toWei(),
+                    claimee: harvest.claim.claimee.address
+                },
+                harvest.proof,
+                swapInfo
+            ])
+        ]
+    }
 }
 
 const _description = 'Automatically diversify {{TOKEN}} holdings into different Vesu pools while reducing risk and maximizing yield. Defi spring STRK Rewards are auto-compounded as well.'