@strkfarm/sdk 1.0.29 → 1.0.30

package/src/modules/avnu.ts

@@ -62,7 +62,7 @@ export class AvnuWrapper {
     taker: string,
     integratorFeeBps: number,
     integratorFeeRecipient: string,
-    minAmount: string
+    minAmount?: string
   ) {
     const calldata = await fetchBuildExecuteTransaction(quote.quoteId);
     // its the multi swap function call
@@ -91,12 +91,16 @@ export class AvnuWrapper {
     }
 
     // swapInfo as expected by the strategy
+    // fallback, max 1% slippage
+    const _minAmount = minAmount || (quote.buyAmount * 95n / 100n).toString();
+    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
+    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
     const swapInfo: SwapInfo = {
       token_from_address: quote.sellTokenAddress,
       token_from_amount: uint256.bnToUint256(quote.sellAmount),
       token_to_address: quote.buyTokenAddress,
-      token_to_amount: uint256.bnToUint256(quote.buyAmount),
-      token_to_min_amount: uint256.bnToUint256(minAmount),
+      token_to_amount: uint256.bnToUint256(_minAmount),
+      token_to_min_amount: uint256.bnToUint256(_minAmount),
       beneficiary: taker,
       integrator_fee_amount_bps: integratorFeeBps,
       integrator_fee_recipient: integratorFeeRecipient,

package/src/modules/harvests.ts

@@ -2,7 +2,7 @@ import { ContractAddr, Web3Number } from "@/dataTypes";
 import { logger } from "@/global";
 import { IConfig } from "@/interfaces";
 import { assert } from "@/utils";
-import { Contract } from "starknet";
+import { Contract, num } from "starknet";
 
 export interface HarvestInfo {
     rewardsContract: ContractAddr,
@@ -14,13 +14,12 @@ export interface HarvestInfo {
         amount: Web3Number,
         claimee: ContractAddr
     },
+    actualReward: Web3Number,
     proof: string[]
 }
 
 export class Harvests {   
-    constructor(private readonly config: IConfig) {
-
-    }
+    constructor(protected readonly config: IConfig) {}
 
     getHarvests(addr: ContractAddr): Promise<HarvestInfo[]> {
         throw new Error("Not implemented");
@@ -45,9 +44,10 @@ export class Harvests {
     }
 }
 
+const STRK = '0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d';
+
 export class EkuboHarvests extends Harvests {
     async getHarvests(addr: ContractAddr) {
-        const STRK = '0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d';
         const EKUBO_API = `https://starknet-mainnet-api.ekubo.org/airdrops/${addr.address}?token=${STRK}`
         const resultEkubo = await fetch(EKUBO_API);
         const items = (await resultEkubo.json());
@@ -66,9 +66,46 @@ export class EkuboHarvests extends Harvests {
                     amount: Web3Number.fromWei(info.claim.amount, 18),
                     claimee: ContractAddr.from(info.claim.claimee)
                 },
+                actualReward: Web3Number.fromWei(info.claim.amount, 18),
                 proof: info.proof
             });
         }
         return rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime());
     }
+}
+
+export class VesuHarvests extends Harvests {
+    async getHarvests(addr: ContractAddr): Promise<HarvestInfo[]> {
+        const result = await fetch(`https://api.vesu.xyz/users/${addr.address}/strk-rewards/calldata`);
+        const data = await result.json();
+        const rewardsContract = ContractAddr.from('0x0387f3eb1d98632fbe3440a9f1385Aec9d87b6172491d3Dd81f1c35A7c61048F');
+    
+        // get already claimed amount
+        const cls = await this.config.provider.getClassAt(rewardsContract.address);
+        const contract = new Contract(cls.abi, rewardsContract.address, this.config.provider);
+        const _claimed_amount: any = await contract.call('amount_already_claimed', [addr.address]);
+        const claimed_amount = Web3Number.fromWei(_claimed_amount.toString(), 18);
+        logger.verbose(`${VesuHarvests.name}: claimed_amount: ${claimed_amount.toString()}`);
+        
+        // get the actual reward
+        const actualReward = Web3Number.fromWei(data.data.amount, 18).minus(claimed_amount);
+        logger.verbose(`${VesuHarvests.name}: actualReward: ${actualReward.toString()}`);
+        return [{
+            rewardsContract,
+            token: ContractAddr.from(STRK),
+            startDate: new Date(0),
+            endDate: new Date(0),
+            claim: {
+                id: 0,
+                amount: Web3Number.fromWei(num.getDecimalString(data.data.amount), 18),
+                claimee: addr
+            },
+            actualReward,
+            proof: data.data.proof
+        }]
+    }
+
+    async getUnHarvestedRewards(addr: ContractAddr) {
+        return await this.getHarvests(addr);
+    }
 }

package/src/strategies/ekubo-cl-vault.ts

@@ -275,7 +275,7 @@ export class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
         }
     }
 
-    private async _getTVL(blockIdentifier: BlockIdentifier = 'pending') {
+    async _getTVL(blockIdentifier: BlockIdentifier = 'pending') {
         const result = await this.contract.call('total_liquidity', [], {
             blockIdentifier
         }); 

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;
@@ -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.'