@strkfarm/sdk 1.0.61 → 1.0.63

package/dist/index.mjs

@@ -464,7 +464,8 @@ var Pricer = class extends PricerBase {
     const url = this.EKUBO_API.replace("{{TOKEN_ADDRESS}}", token.address.toString()).replace("{{AMOUNT}}", amountIn.toWei());
     const result = await axios2.get(url);
     const data = result.data;
-    const outputUSDC = Number(Web3Number.fromWei(data.total_calculated, 6).toFixed(6));
+    const multiplier = 1 / amountIn.toNumber();
+    const outputUSDC = Number(Web3Number.fromWei(data.total_calculated, 6).toFixed(6)) * multiplier;
     logger.verbose(`Ekubo: ${token.symbol} -> USDC: ${outputUSDC}, retry: ${retry}`);
     if (outputUSDC === 0 && retry < 3) {
       const amountIn2 = new Web3Number(100, token.decimals);
@@ -3889,11 +3890,12 @@ var EkuboHarvests = class extends Harvests {
     return rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime());
   }
 };
+var VESU_REWARDS_CONTRACT = ContractAddr.from("0x0387f3eb1d98632fbe3440a9f1385Aec9d87b6172491d3Dd81f1c35A7c61048F");
 var VesuHarvests = class _VesuHarvests extends Harvests {
   async getHarvests(addr) {
     const result = await fetch(`https://api.vesu.xyz/users/${addr.address}/strk-rewards/calldata`);
     const data = await result.json();
-    const rewardsContract = ContractAddr.from("0x0387f3eb1d98632fbe3440a9f1385Aec9d87b6172491d3Dd81f1c35A7c61048F");
+    const rewardsContract = VESU_REWARDS_CONTRACT;
     const cls = await this.config.provider.getClassAt(rewardsContract.address);
     const contract = new Contract4(cls.abi, rewardsContract.address, this.config.provider);
     const _claimed_amount = await contract.call("amount_already_claimed", [addr.address]);
@@ -18485,7 +18487,9 @@ var SenseiStrategies = [
 import { hash, num as num6, shortString } from "starknet";
 
 // src/strategies/universal-adapters/adapter-utils.ts
-var SIMPLE_SANITIZER = ContractAddr.from("0x3798dc4f83fdfad199e5236e3656cf2fb79bc50c00504d0dd41522e0f042072");
+var SIMPLE_SANITIZER = ContractAddr.from("0x5a2e3ceb3da368b983a8717898427ab7b6daf04014b70f321e777f9aad940b4");
+var PRICE_ROUTER = ContractAddr.from("0x05e83Fa38D791d2dba8E6f487758A9687FfEe191A6Cf8a6c5761ab0a110DB837");
+var AVNU_MIDDLEWARE = ContractAddr.from("0x4a7972ed3f5d1e74a6d6c4a8f467666953d081c8f2270390cc169d50d17cb0d");
 function toBigInt(value) {
   if (typeof value === "string") {
     return BigInt(value);
@@ -18518,7 +18522,7 @@ var BaseAdapter = class extends CacheClass {
 };
 
 // src/strategies/universal-adapters/common-adapter.ts
-import { hash as hash2, uint256 as uint2566 } from "starknet";
+import { hash as hash2, num as num7, uint256 as uint2566 } from "starknet";
 var CommonAdapter = class extends BaseAdapter {
   constructor(config) {
     super();
@@ -18629,10 +18633,70 @@ var CommonAdapter = class extends BaseAdapter {
       };
     };
   }
+  getAvnuAdapter(fromToken, toToken, id) {
+    return () => ({
+      leaf: this.constructSimpleLeafData({
+        id,
+        target: AVNU_MIDDLEWARE,
+        method: "multi_route_swap",
+        packedArguments: [
+          fromToken.toBigInt(),
+          toToken.toBigInt(),
+          this.config.vaultAllocator.toBigInt()
+        ]
+      }),
+      callConstructor: this.getAvnuCall(fromToken, toToken).bind(this)
+    });
+  }
+  getAvnuCall(fromToken, toToken) {
+    return (params) => {
+      return {
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: AVNU_MIDDLEWARE,
+          selector: hash2.getSelectorFromName("multi_route_swap"),
+          calldata: [
+            fromToken.toBigInt(),
+            // sell_token_address
+            toBigInt(params.props.token_from_amount.low.toString()),
+            // sell_token_amount low
+            toBigInt(params.props.token_from_amount.high.toString()),
+            // sell_token_amount high
+            toToken.toBigInt(),
+            // buy_token_address
+            toBigInt(params.props.token_to_amount.low.toString()),
+            // buy_token_amount low
+            toBigInt(params.props.token_to_amount.high.toString()),
+            // buy_token_amount high
+            toBigInt(params.props.token_to_min_amount.low.toString()),
+            // buy_token_min_amount low
+            toBigInt(params.props.token_to_min_amount.high.toString()),
+            // buy_token_min_amount high
+            this.config.vaultAllocator.toBigInt(),
+            // beneficiary
+            toBigInt(0),
+            // integrator_fee_amount_bps
+            this.config.vaultAllocator.toBigInt(),
+            // integrator_fee_recipient
+            // unpack routes
+            BigInt(params.props.routes.length),
+            ...params.props.routes.map((r) => [
+              BigInt(num7.hexToDecimalString(r.token_from)),
+              BigInt(num7.hexToDecimalString(r.token_to)),
+              BigInt(num7.hexToDecimalString(r.exchange_address)),
+              BigInt(r.percent),
+              BigInt(r.additional_swap_params.length),
+              ...r.additional_swap_params.map((p) => BigInt(num7.hexToDecimalString(p)))
+            ]).flat()
+          ]
+        }
+      };
+    };
+  }
 };
 
 // src/strategies/universal-adapters/vesu-adapter.ts
-import { CairoCustomEnum as CairoCustomEnum2, Contract as Contract8, hash as hash3, RpcProvider as RpcProvider4, uint256 as uint2567 } from "starknet";
+import { CairoCustomEnum as CairoCustomEnum2, Contract as Contract8, hash as hash3, num as num8, RpcProvider as RpcProvider4, shortString as shortString3, uint256 as uint2567 } from "starknet";
 
 // src/data/vesu-singleton.abi.json
 var vesu_singleton_abi_default = [
@@ -20965,6 +21029,40 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
         }
       };
     };
+    this.getDefispringRewardsAdapter = (id) => {
+      return () => {
+        const packedArguments = [];
+        const output = {
+          id: BigInt(num8.getDecimalString(shortString3.encodeShortString(id))),
+          readableId: id,
+          data: [
+            SIMPLE_SANITIZER.toBigInt(),
+            // sanitizer address
+            VESU_REWARDS_CONTRACT.toBigInt(),
+            // contract
+            toBigInt(hash3.getSelectorFromName("claim")),
+            // method name
+            BigInt(packedArguments.length),
+            ...packedArguments
+          ]
+        };
+        return { leaf: output, callConstructor: this.getDefiSpringClaimCall().bind(this) };
+      };
+    };
+    this.getDefiSpringClaimCall = () => {
+      return (params) => ({
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: VESU_REWARDS_CONTRACT,
+          selector: hash3.getSelectorFromName("claim"),
+          calldata: [
+            BigInt(params.amount.toWei()),
+            BigInt(params.proofs.length),
+            ...params.proofs.map((proof) => BigInt(num8.hexToDecimalString(proof)))
+          ]
+        }
+      });
+    };
     this.config = config;
   }
   static getDefaultModifyPositionCallParams(params) {
@@ -23594,7 +23692,7 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     const aumToken = vesuAum.plus(balance.amount);
     logger.verbose(`${this.getTag()} Actual AUM: ${aumToken}`);
     const netAPY = await this.netAPY();
-    const defispringAPY = netAPY.splits.find((s) => s.id === "defispring")?.apy || 0;
+    const defispringAPY = (netAPY.splits.find((s) => s.id === "defispring")?.apy || 0) * 0.8;
     if (!defispringAPY) throw new Error("DefiSpring APY not found");
     const timeDiff = Math.round(Date.now() / 1e3) - Number(lastReportTime);
     const growthRate = timeDiff * defispringAPY / (365 * 24 * 60 * 60);
@@ -23837,6 +23935,51 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     const manageCall = this.getManageCall(["approve_bring_liquidity" /* APPROVE_BRING_LIQUIDITY */, "bring_liquidity" /* BRING_LIQUIDITY */], [manageCall1, manageCall2]);
     return manageCall;
   }
+  async getHarvestCall() {
+    const vesuHarvest = new VesuHarvests(this.config);
+    const harvestInfo = await vesuHarvest.getUnHarvestedRewards(this.metadata.additionalInfo.vaultAllocator);
+    if (harvestInfo.length != 1) {
+      throw new Error(`Expected 1 harvest info, got ${harvestInfo.length}`);
+    }
+    const amount = harvestInfo[0].claim.amount;
+    const actualReward = harvestInfo[0].actualReward;
+    const proofs = harvestInfo[0].proof;
+    if (actualReward.isZero()) {
+      throw new Error(`Expected non-zero actual reward, got ${harvestInfo[0].actualReward}`);
+    }
+    const manage1Info = this.getProofs("defispring_rewards" /* DEFISPRING_REWARDS */);
+    const manageCall1 = manage1Info.callConstructor({
+      amount,
+      proofs
+    });
+    const proofIds = ["defispring_rewards" /* DEFISPRING_REWARDS */];
+    const manageCalls = [manageCall1];
+    const STRK2 = Global.getDefaultTokens().find((t) => t.symbol === "STRK");
+    if (this.asset().symbol != "STRK") {
+      const manage2Info = this.getProofs("approve_swap_token1" /* APPROVE_SWAP_TOKEN1 */);
+      const manageCall2 = manage2Info.callConstructor({
+        amount: actualReward
+      });
+      const avnuModule = new AvnuWrapper();
+      const quote = await avnuModule.getQuotes(
+        STRK2.address.address,
+        this.asset().address.address,
+        actualReward.toWei(),
+        this.address.address
+      );
+      const swapInfo = await avnuModule.getSwapInfo(quote, this.address.address, 0, this.address.address);
+      const manage3Info = this.getProofs("avnu_swap_rewards" /* AVNU_SWAP_REWARDS */);
+      const manageCall3 = manage3Info.callConstructor({
+        props: swapInfo
+      });
+      proofIds.push("approve_swap_token1" /* APPROVE_SWAP_TOKEN1 */);
+      proofIds.push("avnu_swap_rewards" /* AVNU_SWAP_REWARDS */);
+      manageCalls.push(manageCall2);
+      manageCalls.push(manageCall3);
+    }
+    const manageCall = this.getManageCall(proofIds, manageCalls);
+    return { call: manageCall, reward: actualReward, tokenInfo: STRK2 };
+  }
   async getRebalanceCall(params) {
     let callSet1 = this.getVesuModifyPositionCalls({
       isLeg1: true,
@@ -23873,6 +24016,9 @@ var UNIVERSAL_MANAGE_IDS = /* @__PURE__ */ ((UNIVERSAL_MANAGE_IDS2) => {
   UNIVERSAL_MANAGE_IDS2["APPROVE_TOKEN2"] = "approve_token2";
   UNIVERSAL_MANAGE_IDS2["APPROVE_BRING_LIQUIDITY"] = "approve_bring_liquidity";
   UNIVERSAL_MANAGE_IDS2["BRING_LIQUIDITY"] = "bring_liquidity";
+  UNIVERSAL_MANAGE_IDS2["DEFISPRING_REWARDS"] = "defispring_rewards";
+  UNIVERSAL_MANAGE_IDS2["APPROVE_SWAP_TOKEN1"] = "approve_swap_token1";
+  UNIVERSAL_MANAGE_IDS2["AVNU_SWAP_REWARDS"] = "avnu_swap_rewards";
   return UNIVERSAL_MANAGE_IDS2;
 })(UNIVERSAL_MANAGE_IDS || {});
 var UNIVERSAL_ADAPTERS = /* @__PURE__ */ ((UNIVERSAL_ADAPTERS2) => {
@@ -23922,6 +24068,10 @@ function getLooperSettings(token1Symbol, token2Symbol, vaultSettings, pool1, poo
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(ETHToken.address, vesuAdapterETHUSDC.VESU_SINGLETON, "approve_token2" /* APPROVE_TOKEN2 */).bind(commonAdapter));
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(USDCToken.address, vaultSettings.vaultAddress, "approve_bring_liquidity" /* APPROVE_BRING_LIQUIDITY */).bind(commonAdapter));
   vaultSettings.leafAdapters.push(commonAdapter.getBringLiquidityAdapter("bring_liquidity" /* BRING_LIQUIDITY */).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(vesuAdapterUSDCETH.getDefispringRewardsAdapter("defispring_rewards" /* DEFISPRING_REWARDS */).bind(vesuAdapterUSDCETH));
+  const STRKToken = Global.getDefaultTokens().find((token) => token.symbol === "STRK");
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(STRKToken.address, AVNU_MIDDLEWARE, "approve_swap_token1" /* APPROVE_SWAP_TOKEN1 */).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(STRKToken.address, USDCToken.address, "avnu_swap_rewards" /* AVNU_SWAP_REWARDS */).bind(commonAdapter));
   return vaultSettings;
 }
 var _riskFactor4 = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.0.61",
+  "version": "1.0.63",
   "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
   "typings": "dist/index.d.ts",
   "types": "dist/index.d.ts",

package/src/modules/harvests.ts

@@ -83,12 +83,14 @@ export class EkuboHarvests extends Harvests {
     }
 }
 
+export const VESU_REWARDS_CONTRACT = ContractAddr.from('0x0387f3eb1d98632fbe3440a9f1385Aec9d87b6172491d3Dd81f1c35A7c61048F');
+
 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');
-    
+        const rewardsContract = VESU_REWARDS_CONTRACT;
+
         // get already claimed amount
         const cls = await this.config.provider.getClassAt(rewardsContract.address);
         const contract = new Contract(cls.abi, rewardsContract.address, this.config.provider);

package/src/modules/pricer.ts

@@ -187,7 +187,8 @@ export class Pricer extends PricerBase {
         const url = this.EKUBO_API.replace("{{TOKEN_ADDRESS}}", token.address.toString()).replace("{{AMOUNT}}", amountIn.toWei());
         const result = await axios.get(url);
         const data: any = result.data;
-        const outputUSDC = Number(Web3Number.fromWei(data.total_calculated, 6).toFixed(6));
+        const multiplier = 1 / amountIn.toNumber();
+        const outputUSDC = Number(Web3Number.fromWei(data.total_calculated, 6).toFixed(6)) * multiplier;
         logger.verbose(`Ekubo: ${token.symbol} -> USDC: ${outputUSDC}, retry: ${retry}`);
         if (outputUSDC === 0 && retry < 3) {
             // try again with a higher amount

package/src/strategies/universal-adapters/adapter-utils.ts

@@ -1,6 +1,8 @@
 import { ContractAddr } from "@/dataTypes";
 
-export const SIMPLE_SANITIZER = ContractAddr.from('0x3798dc4f83fdfad199e5236e3656cf2fb79bc50c00504d0dd41522e0f042072');
+export const SIMPLE_SANITIZER = ContractAddr.from('0x5a2e3ceb3da368b983a8717898427ab7b6daf04014b70f321e777f9aad940b4');
+export const PRICE_ROUTER = ContractAddr.from('0x05e83Fa38D791d2dba8E6f487758A9687FfEe191A6Cf8a6c5761ab0a110DB837');
+export const AVNU_MIDDLEWARE = ContractAddr.from('0x4a7972ed3f5d1e74a6d6c4a8f467666953d081c8f2270390cc169d50d17cb0d');
 
 export function toBigInt(value: string | number): bigint {
     if (typeof value === 'string') {

package/src/strategies/universal-adapters/common-adapter.ts

@@ -1,8 +1,9 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { LeafData } from "@/utils";
 import { Call, hash, num, shortString, uint256 } from "starknet";
-import { SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
+import { AVNU_MIDDLEWARE, SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
 import { AdapterLeafType, BaseAdapter, GenerateCallFn, LeafAdapterFn, ManageCall } from "./baseAdapter";
+import { SwapInfo } from "@/modules";
 
 export interface FlashloanCallParams {
   amount: Web3Number,
@@ -11,6 +12,9 @@ export interface FlashloanCallParams {
 export interface ApproveCallParams {
   amount: Web3Number,
 }
+export interface AvnuSwapCallParams {
+  props: SwapInfo
+}
 
 export interface CommonAdapterConfig {
   id: string,
@@ -124,4 +128,56 @@ export class CommonAdapter extends BaseAdapter {
       }
     }
   }
+
+  getAvnuAdapter(fromToken: ContractAddr, toToken: ContractAddr, id: string): () => AdapterLeafType<AvnuSwapCallParams> {
+    return () => ({
+      leaf: this.constructSimpleLeafData({
+        id: id,
+        target: AVNU_MIDDLEWARE,
+        method: 'multi_route_swap',
+        packedArguments: [
+          fromToken.toBigInt(),
+          toToken.toBigInt(),
+          this.config.vaultAllocator.toBigInt(),
+        ]
+      }),
+      callConstructor: this.getAvnuCall(fromToken, toToken).bind(this)
+    });
+  }
+
+  getAvnuCall(fromToken: ContractAddr, toToken: ContractAddr): GenerateCallFn<AvnuSwapCallParams> {
+    return (params: AvnuSwapCallParams): ManageCall => {
+      return {
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: AVNU_MIDDLEWARE,
+          selector: hash.getSelectorFromName('multi_route_swap'),
+          calldata: [
+            fromToken.toBigInt(), // sell_token_address
+            toBigInt(params.props.token_from_amount.low.toString()), // sell_token_amount low
+            toBigInt(params.props.token_from_amount.high.toString()), // sell_token_amount high
+            toToken.toBigInt(), // buy_token_address
+            toBigInt(params.props.token_to_amount.low.toString()), // buy_token_amount low
+            toBigInt(params.props.token_to_amount.high.toString()), // buy_token_amount high
+            toBigInt(params.props.token_to_min_amount.low.toString()), // buy_token_min_amount low
+            toBigInt(params.props.token_to_min_amount.high.toString()), // buy_token_min_amount high
+            this.config.vaultAllocator.toBigInt(), // beneficiary
+            toBigInt(0), // integrator_fee_amount_bps
+            this.config.vaultAllocator.toBigInt(), // integrator_fee_recipient
+
+            // unpack routes
+            BigInt(params.props.routes.length),
+            ...params.props.routes.map(r => ([
+              BigInt(num.hexToDecimalString(r.token_from)),
+              BigInt(num.hexToDecimalString(r.token_to)),
+              BigInt(num.hexToDecimalString(r.exchange_address)),
+              BigInt(r.percent),
+              BigInt(r.additional_swap_params.length),
+              ...r.additional_swap_params.map(p => BigInt(num.hexToDecimalString(p)))
+            ])).flat()
+          ]
+        }
+      }
+    }
+  }
 }

package/src/strategies/universal-adapters/vesu-adapter.ts

@@ -9,6 +9,7 @@ import { PricerBase } from "@/modules/pricerBase";
 import VesuPoolIDs from "@/data/vesu_pools.json";
 import { getAPIUsingHeadlessBrowser } from "@/node/headless";
 import { Global } from "@/global";
+import { VESU_REWARDS_CONTRACT } from "@/modules/harvests";
 
 interface VesuPoolsInfo { pools: any[]; isErrorPoolsAPI: boolean };
 
@@ -38,6 +39,11 @@ export interface VesuModifyPositionCallParams {
   debtAmount: VesuAmount
 }
 
+export interface VesuDefiSpringRewardsCallParams {
+  amount: Web3Number,
+  proofs: string[],
+}
+
 export interface VesuAdapterConfig {
   poolId: ContractAddr,
   collateral: TokenInfo,
@@ -156,6 +162,39 @@ export class VesuAdapter extends BaseAdapter {
       }
     }
   }
+  
+  getDefispringRewardsAdapter = (id: string): () => AdapterLeafType<VesuDefiSpringRewardsCallParams> => {
+    return () => {
+      const packedArguments: bigint[] = [];
+      const output = {
+        id: BigInt(num.getDecimalString(shortString.encodeShortString(id))),
+        readableId: id,
+        data: [
+          SIMPLE_SANITIZER.toBigInt(), // sanitizer address
+          VESU_REWARDS_CONTRACT.toBigInt(), // contract
+          toBigInt(hash.getSelectorFromName("claim")), // method name
+          BigInt(packedArguments.length),
+          ...packedArguments
+        ]
+      };
+      return { leaf: output, callConstructor: this.getDefiSpringClaimCall().bind(this) };
+    }
+  }
+
+  getDefiSpringClaimCall = (): GenerateCallFn<VesuDefiSpringRewardsCallParams> => {
+    return (params: VesuDefiSpringRewardsCallParams) => ({
+      sanitizer: SIMPLE_SANITIZER,
+      call: {
+        contractAddress: VESU_REWARDS_CONTRACT,
+        selector: hash.getSelectorFromName('claim'),
+        calldata: [
+          BigInt(params.amount.toWei()),
+          BigInt(params.proofs.length),
+          ...params.proofs.map(proof => BigInt(num.hexToDecimalString(proof)))
+        ]
+      }
+    })
+  }
 
   formatAmountTypeEnum(amountType: VesuAmountType) {
     switch(amountType) {

package/src/strategies/universal-strategy.tsx

@@ -7,9 +7,11 @@ import { VesuRebalanceSettings } from "./vesu-rebalance";
 import { assert, LeafData, logger, StandardMerkleTree } from "@/utils";
 import UniversalVaultAbi from '../data/universal-vault.abi.json';
 import ManagerAbi from '../data/vault-manager.abi.json';
-import { ApproveCallParams, BaseAdapter, CommonAdapter, FlashloanCallParams, GenerateCallFn, LeafAdapterFn, ManageCall, VesuAdapter, VesuModifyPositionCallParams, VesuPools } from "./universal-adapters";
+import { ApproveCallParams, AvnuSwapCallParams, BaseAdapter, CommonAdapter, FlashloanCallParams, GenerateCallFn, LeafAdapterFn, ManageCall, VesuAdapter, VesuDefiSpringRewardsCallParams, VesuModifyPositionCallParams, VesuPools } from "./universal-adapters";
 import { Global } from "@/global";
-import { ERC20 } from "@/modules";
+import { AvnuWrapper, ERC20 } from "@/modules";
+import { AVNU_MIDDLEWARE } from "./universal-adapters/adapter-utils";
+import { VesuHarvests } from "@/modules/harvests";
 
 export interface UniversalStrategySettings {
   vaultAddress: ContractAddr,
@@ -312,7 +314,8 @@ export class UniversalStrategy<
 
     // calculate estimated growth from strk rewards
     const netAPY = await this.netAPY();
-    const defispringAPY = netAPY.splits.find(s => s.id === 'defispring')?.apy || 0;
+    // account only 80% of value
+    const defispringAPY = (netAPY.splits.find(s => s.id === 'defispring')?.apy || 0) * 0.8;
     if (!defispringAPY) throw new Error('DefiSpring APY not found');
 
     const timeDiff = (Math.round(Date.now() / 1000) - Number(lastReportTime));
@@ -605,6 +608,61 @@ export class UniversalStrategy<
     return manageCall;
   }
 
+  async getHarvestCall() {
+    const vesuHarvest = new VesuHarvests(this.config);
+    const harvestInfo = await vesuHarvest.getUnHarvestedRewards(this.metadata.additionalInfo.vaultAllocator);
+    if (harvestInfo.length != 1) {
+      throw new Error(`Expected 1 harvest info, got ${harvestInfo.length}`);
+    }
+
+    const amount = harvestInfo[0].claim.amount;
+    const actualReward = harvestInfo[0].actualReward;
+    const proofs = harvestInfo[0].proof;
+    if (actualReward.isZero()) {
+      throw new Error(`Expected non-zero actual reward, got ${harvestInfo[0].actualReward}`);
+    }
+
+    const manage1Info = this.getProofs<VesuDefiSpringRewardsCallParams>(UNIVERSAL_MANAGE_IDS.DEFISPRING_REWARDS);
+    const manageCall1 = manage1Info.callConstructor({
+        amount,
+        proofs
+    });
+    const proofIds: string[] = [UNIVERSAL_MANAGE_IDS.DEFISPRING_REWARDS];
+    const manageCalls: ManageCall[] = [manageCall1];
+
+    // swap rewards for underlying
+    const STRK = Global.getDefaultTokens().find(t => t.symbol === 'STRK')!;
+    if (this.asset().symbol != 'STRK') {
+      // approve
+      const manage2Info = this.getProofs<ApproveCallParams>(UNIVERSAL_MANAGE_IDS.APPROVE_SWAP_TOKEN1);
+      const manageCall2 = manage2Info.callConstructor({
+          amount: actualReward
+      });
+
+      // swap
+      const avnuModule = new AvnuWrapper();
+      const quote = await avnuModule.getQuotes(
+          STRK.address.address,
+          this.asset().address.address,
+          actualReward.toWei(),
+          this.address.address
+      );
+      const swapInfo = await avnuModule.getSwapInfo(quote, this.address.address, 0, this.address.address);
+      const manage3Info = this.getProofs<AvnuSwapCallParams>(UNIVERSAL_MANAGE_IDS.AVNU_SWAP_REWARDS);
+      const manageCall3 = manage3Info.callConstructor({
+          props: swapInfo
+      });
+      proofIds.push(UNIVERSAL_MANAGE_IDS.APPROVE_SWAP_TOKEN1);
+      proofIds.push(UNIVERSAL_MANAGE_IDS.AVNU_SWAP_REWARDS);
+
+      manageCalls.push(manageCall2);
+      manageCalls.push(manageCall3);
+    }
+
+    const manageCall = this.getManageCall(proofIds, manageCalls);
+    return { call: manageCall, reward: actualReward, tokenInfo: STRK };
+  }
+
   async getRebalanceCall(params: {
     isLeg1toLeg2: boolean,
     amount: Web3Number
@@ -646,7 +704,14 @@ export enum UNIVERSAL_MANAGE_IDS {
   APPROVE_TOKEN1 = 'approve_token1',
   APPROVE_TOKEN2 = 'approve_token2',
   APPROVE_BRING_LIQUIDITY = 'approve_bring_liquidity',
-  BRING_LIQUIDITY = 'bring_liquidity'
+  BRING_LIQUIDITY = 'bring_liquidity',
+
+  // defi spring claim
+  DEFISPRING_REWARDS = 'defispring_rewards',
+
+  // avnu swaps
+  APPROVE_SWAP_TOKEN1 = 'approve_swap_token1',
+  AVNU_SWAP_REWARDS = 'avnu_swap_rewards'
 }
 
 export enum UNIVERSAL_ADAPTERS {
@@ -707,7 +772,15 @@ function getLooperSettings(
   // to bridge liquidity back to vault (used by bring_liquidity)
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(USDCToken.address, vaultSettings.vaultAddress, UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY).bind(commonAdapter));
   vaultSettings.leafAdapters.push(commonAdapter.getBringLiquidityAdapter(UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY).bind(commonAdapter));
-  return vaultSettings; 
+  
+  // claim rewards
+  vaultSettings.leafAdapters.push(vesuAdapterUSDCETH.getDefispringRewardsAdapter(UNIVERSAL_MANAGE_IDS.DEFISPRING_REWARDS).bind(vesuAdapterUSDCETH));
+
+  // avnu swap
+  const STRKToken = Global.getDefaultTokens().find(token => token.symbol === 'STRK')!;
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(STRKToken.address, AVNU_MIDDLEWARE, UNIVERSAL_MANAGE_IDS.APPROVE_SWAP_TOKEN1).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(STRKToken.address, USDCToken.address, UNIVERSAL_MANAGE_IDS.AVNU_SWAP_REWARDS).bind(commonAdapter));
+  return vaultSettings;
 }
 
 const _riskFactor: RiskFactor[] = [