@strkfarm/sdk 1.0.62 → 1.1.0

package/src/interfaces/common.tsx

@@ -1,5 +1,5 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
-import { BlockIdentifier, constants, RpcProvider } from "starknet";
+import { BlockIdentifier, BlockTag, constants, RpcProvider } from "starknet";
 import React, { ReactNode } from "react";
 
 export enum RiskType {
@@ -107,7 +107,7 @@ export interface IInvestmentFlow {
 
 export function getMainnetConfig(
   rpcUrl: string = 'https://starknet-mainnet.public.blastapi.io',
-  blockIdentifier: BlockIdentifier = "pending",
+  blockIdentifier: BlockIdentifier = BlockTag.LATEST
   // specVersion = constants.SupportedRpcVersion.v0_8_1
 ): IConfig {
   return {

package/src/modules/erc20.ts

@@ -12,7 +12,7 @@ export class ERC20 {
 
     contract(addr: string | ContractAddr) {
         const _addr = typeof addr === 'string' ? addr : addr.address;
-        return new Contract(ERC20Abi, _addr, this.config.provider);
+        return new Contract({abi: ERC20Abi, address: _addr, providerOrAccount: this.config.provider});
     }
 
     async balanceOf(token: string | ContractAddr, address: string | ContractAddr, tokenDecimals: number) {

package/src/modules/harvests.ts

@@ -34,7 +34,7 @@ export class Harvests {
 
         const cls = await this.config.provider.getClassAt(rewards[0].rewardsContract.address);
         for (let reward of rewards) {
-            const contract = new Contract(cls.abi, reward.rewardsContract.address, this.config.provider);
+            const contract = new Contract({abi: cls.abi, address: reward.rewardsContract.address, providerOrAccount: this.config.provider});
             const isClaimed = await contract.call('is_claimed', [reward.claim.id]);
             logger.verbose(`${Harvests.name}: isClaimed: ${isClaimed}`);
             if (isClaimed) {
@@ -83,15 +83,17 @@ 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);
+        const contract = new Contract({abi: cls.abi, address: rewardsContract.address, providerOrAccount: 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()}`);

package/src/modules/pragma.ts

@@ -7,7 +7,7 @@ export class Pragma {
     readonly contract: Contract;
 
     constructor(provider: RpcProvider) {
-        this.contract = new Contract(PragmaAbi, this.contractAddr, provider);
+        this.contract = new Contract({abi: PragmaAbi, address: this.contractAddr, providerOrAccount: provider});
     }
 
     async getPrice(tokenAddr: string) {

package/src/modules/pricer.ts

@@ -127,7 +127,7 @@ export class Pricer extends PricerBase {
 
     async _getPrice(token: TokenInfo, defaultMethod = 'all'): Promise<number> {
         const methodToUse: string = this.methodToUse[token.symbol] || defaultMethod; // default start with coinbase
-        logger.info(`Fetching price of ${token.symbol} using ${methodToUse}`);
+        logger.verbose(`Fetching price of ${token.symbol} using ${methodToUse}`);
         switch (methodToUse) {
             case 'Coinbase':
                 try {

package/src/node/deployer.ts

@@ -1,5 +1,5 @@
 import assert from 'assert'
-import {Account, Call, RawArgs, RpcProvider, TransactionExecutionStatus, constants, extractContractHashes, hash, json, num, provider, transaction} from 'starknet'
+import {Account, Call, RawArgs, Deployer as SnDeployer, RpcProvider, TransactionExecutionStatus, constants, extractContractHashes, hash, json, num, provider, transaction} from 'starknet'
 import { readFileSync, existsSync, writeFileSync } from 'fs'
 import { IConfig } from '../interfaces';
 import { Store, getDefaultStoreConfig } from '../utils/store';
@@ -136,7 +136,7 @@ async function prepareMultiDeployContracts(
         const declaredInfo = await myDeclare(contract_name, package_name, config, acc);
         const classHash = declaredInfo.class_hash;
 
-        const {calls, addresses} = transaction.buildUDCCall({
+        const {calls, addresses} = (new SnDeployer()).buildDeployerCall({
             classHash,
             constructorCalldata: constructorData,
         }, acc.address);

package/src/strategies/autoCompounderStrk.ts

@@ -31,7 +31,7 @@ export class AutoCompounderSTRK {
     async init() {
         const provider: RpcProvider = this.config.provider;
         const cls = await provider.getClassAt(this.addr.address);
-        this.contract = new Contract(cls.abi, this.addr.address, provider);
+        this.contract = new Contract({abi: cls.abi, address: this.addr.address, providerOrAccount: provider});
         this.initialized = true;
     }
 

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

@@ -113,17 +113,17 @@ export class EkuboCLVault extends BaseStrategy<
     this.metadata = metadata;
     this.address = metadata.address;
 
-    this.contract = new Contract(
-      CLVaultAbi,
-      this.address.address,
-      this.config.provider
-    );
+    this.contract = new Contract({
+      abi: CLVaultAbi,
+      address: this.address.address,
+      providerOrAccount: this.config.provider
+    });
     if (this.metadata.additionalInfo.lstContract) {
-      this.lstContract = new Contract(
-        ERC4626Abi,
-        this.metadata.additionalInfo.lstContract.address,
-        this.config.provider
-      );
+      this.lstContract = new Contract({
+        abi: ERC4626Abi,
+        address: this.metadata.additionalInfo.lstContract.address,
+        providerOrAccount: this.config.provider
+      });
     } else {
       this.lstContract = null;
     }
@@ -131,18 +131,18 @@ export class EkuboCLVault extends BaseStrategy<
     // ekubo positions contract
     const EKUBO_POSITION =
       "0x02e0af29598b407c8716b17f6d2795eca1b471413fa03fb145a5e33722184067";
-    this.ekuboPositionsContract = new Contract(
-      EkuboPositionsAbi,
-      EKUBO_POSITION,
-      this.config.provider
-    );
+    this.ekuboPositionsContract = new Contract({
+      abi: EkuboPositionsAbi,
+      address: EKUBO_POSITION,
+      providerOrAccount: this.config.provider
+    });
     const EKUBO_MATH =
       "0x04a72e9e166f6c0e9d800af4dc40f6b6fb4404b735d3f528d9250808b2481995";
-    this.ekuboMathContract = new Contract(
-      EkuboMathAbi,
-      EKUBO_MATH,
-      this.config.provider
-    );
+    this.ekuboMathContract = new Contract({
+      abi: EkuboMathAbi,
+      address: EKUBO_MATH,
+      providerOrAccount: this.config.provider
+    });
 
     this.avnu = new AvnuWrapper();
   }
@@ -207,16 +207,16 @@ export class EkuboCLVault extends BaseStrategy<
     const updateAmountInfo = await this.getMinDepositAmounts(amountInfo);
     // Technically its not erc4626 abi, but we just need approve call
     // so, its ok to use it
-    const token0Contract = new Contract(
-      ERC4626Abi,
-      amountInfo.token0.tokenInfo.address.address,
-      this.config.provider
-    );
-    const token1Contract = new Contract(
-      ERC4626Abi,
-      amountInfo.token1.tokenInfo.address.address,
-      this.config.provider
-    );
+    const token0Contract = new Contract({
+      abi: ERC4626Abi,
+      address: amountInfo.token0.tokenInfo.address.address,
+      providerOrAccount: this.config.provider
+    });
+    const token1Contract = new Contract({
+      abi: ERC4626Abi,
+      address: amountInfo.token1.tokenInfo.address.address,
+      providerOrAccount: this.config.provider
+    });
     const call1 = token0Contract.populate("approve", [
       this.address.address,
       uint256.bnToUint256(updateAmountInfo.token0.amount.toWei()),
@@ -286,7 +286,7 @@ export class EkuboCLVault extends BaseStrategy<
    * @returns {Promise<number>} The weighted average APY across all pools
    */
   async netAPY(
-    blockIdentifier: BlockIdentifier = "pending",
+    blockIdentifier: BlockIdentifier = "pre_confirmed",
     sinceBlocks = 20000
   ): Promise<number> {
     // no special provisions required to account for defi spring rewards
@@ -376,7 +376,7 @@ export class EkuboCLVault extends BaseStrategy<
 
   async balanceOf(
     user: ContractAddr,
-    blockIdentifier: BlockIdentifier = "pending"
+    blockIdentifier: BlockIdentifier = "pre_confirmed"
   ): Promise<Web3Number> {
     let bal = await this.contract.call("balance_of", [user.address], {
       blockIdentifier,
@@ -386,7 +386,7 @@ export class EkuboCLVault extends BaseStrategy<
 
   async getUserTVL(
     user: ContractAddr,
-    blockIdentifier: BlockIdentifier = "pending"
+    blockIdentifier: BlockIdentifier = "pre_confirmed"
   ): Promise<DualTokenInfo> {
     let bal = await this.balanceOf(user, blockIdentifier);
     const assets: any = await this.contract.call(
@@ -428,7 +428,7 @@ export class EkuboCLVault extends BaseStrategy<
     };
   }
 
-  async _getTVL(blockIdentifier: BlockIdentifier = "pending") {
+  async _getTVL(blockIdentifier: BlockIdentifier = "pre_confirmed") {
     const result = await this.contract.call("total_liquidity", [], {
       blockIdentifier,
     });
@@ -443,7 +443,7 @@ export class EkuboCLVault extends BaseStrategy<
   }
 
   async totalSupply(
-    blockIdentifier: BlockIdentifier = "pending"
+    blockIdentifier: BlockIdentifier = "pre_confirmed"
   ): Promise<Web3Number> {
     const res = await this.contract.call("total_supply", [], {
       blockIdentifier,
@@ -464,7 +464,7 @@ export class EkuboCLVault extends BaseStrategy<
   }
 
   async getTVL(
-    blockIdentifier: BlockIdentifier = "pending"
+    blockIdentifier: BlockIdentifier = "pre_confirmed"
   ): Promise<DualTokenInfo> {
     const { amount0, amount1 } = await this._getTVL(blockIdentifier);
     const poolKey = await this.getPoolKey(blockIdentifier);
@@ -561,14 +561,14 @@ export class EkuboCLVault extends BaseStrategy<
     throw new Error("No true price available");
   }
 
-  async getCurrentPrice(blockIdentifier: BlockIdentifier = "pending") {
+  async getCurrentPrice(blockIdentifier: BlockIdentifier = "pre_confirmed") {
     const poolKey = await this.getPoolKey(blockIdentifier);
     return this._getCurrentPrice(poolKey, blockIdentifier);
   }
 
   async _getCurrentPrice(
     poolKey: EkuboPoolKey,
-    blockIdentifier: BlockIdentifier = "pending"
+    blockIdentifier: BlockIdentifier = "pre_confirmed"
   ) {
     const priceInfo: any = await this.ekuboPositionsContract.call(
       "get_pool_price",
@@ -606,7 +606,7 @@ export class EkuboCLVault extends BaseStrategy<
   }
 
   async getCurrentBounds(
-    blockIdentifier: BlockIdentifier = "pending"
+    blockIdentifier: BlockIdentifier = "pre_confirmed"
   ): Promise<EkuboBounds> {
     const result: any = await this.contract.call("get_position_key", [], {
       blockIdentifier,
@@ -632,7 +632,7 @@ export class EkuboCLVault extends BaseStrategy<
   }
 
   async getPoolKey(
-    blockIdentifier: BlockIdentifier = "pending"
+    blockIdentifier: BlockIdentifier = "pre_confirmed"
   ): Promise<EkuboPoolKey> {
     if (this.poolKey) {
       return this.poolKey;
@@ -1345,7 +1345,7 @@ export class EkuboCLVault extends BaseStrategy<
   async getLiquidityToAmounts(
     liquidity: Web3Number,
     bounds: EkuboBounds,
-    blockIdentifier: BlockIdentifier = "pending",
+    blockIdentifier: BlockIdentifier = "pre_confirmed",
     _poolKey: EkuboPoolKey | null = null,
     _currentPrice: {
       price: number;

package/src/strategies/sensei.ts

@@ -30,7 +30,7 @@ export class SenseiVault extends BaseStrategy<
     this.address = metadata.address;
     this.pricer = pricer;
     this.metadata = metadata;
-    this.contract = new Contract(SenseiABI, this.address.address, this.config.provider);
+    this.contract = new Contract({abi: SenseiABI, address: this.address.address, providerOrAccount: this.config.provider});
 
     if (metadata.depositTokens.length === 0) {
       throw new Error("Deposit tokens are not defined in metadata");
@@ -90,11 +90,11 @@ export class SenseiVault extends BaseStrategy<
   }   
 
   async depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]> {
-    const mainTokenContract = new Contract(
-      ERC20ABI,
-      this.metadata.depositTokens[0].address.address,
-      this.config.provider,
-    );  
+    const mainTokenContract = new Contract({
+      abi: ERC20ABI,
+      address: this.metadata.depositTokens[0].address.address,
+      providerOrAccount: this.config.provider,
+    });
     const call1 = mainTokenContract.populate('approve', [
       this.address.address,
       uint256.bnToUint256(amountInfo.amount.toWei()),

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,
@@ -133,7 +139,7 @@ export class VesuAdapter extends BaseAdapter {
       }
     };
     logger.verbose(`VesuAdapter::ConstructingModify::Debt::${JSON.stringify(_debt)}`)
-    const singletonContract = new Contract(VesuSingletonAbi, this.VESU_SINGLETON.toString(), new RpcProvider({nodeUrl: ''}));
+    const singletonContract = new Contract({abi: VesuSingletonAbi, address: this.VESU_SINGLETON.toString(), providerOrAccount: new RpcProvider({nodeUrl: ''})});
     const call = singletonContract.populate('modify_position', {
       params: {
         pool_id: this.config.poolId.toBigInt(),
@@ -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) {
@@ -178,7 +217,7 @@ export class VesuAdapter extends BaseAdapter {
   }
 
   getVesuSingletonContract(config: IConfig) {
-    return new Contract(VesuSingletonAbi, this.VESU_SINGLETON.address, config.provider);
+    return new Contract({abi: VesuSingletonAbi, address: this.VESU_SINGLETON.address, providerOrAccount: config.provider});
   }
 
   async getLTVConfig(config: IConfig) {

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,
@@ -61,16 +63,16 @@ export class UniversalStrategy<
       this.metadata = metadata;
       this.address = metadata.address;
   
-      this.contract = new Contract(
-        UniversalVaultAbi,
-        this.address.address,
-        this.config.provider
-      );
-      this.managerContract = new Contract(
-        ManagerAbi,
-        this.metadata.additionalInfo.manager.address,
-        this.config.provider
-      );
+      this.contract = new Contract({
+        abi: UniversalVaultAbi,
+        address: this.address.address,
+        providerOrAccount: this.config.provider
+      });
+      this.managerContract = new Contract({
+        abi: ManagerAbi,
+        address: this.metadata.additionalInfo.manager.address,
+        providerOrAccount: this.config.provider
+      });
   }
 
   getMerkleTree() {
@@ -130,11 +132,11 @@ export class UniversalStrategy<
       amountInfo.tokenInfo.address.eq(this.asset().address),
       "Deposit token mismatch"
     );
-    const assetContract = new Contract(
-      UniversalVaultAbi,
-      this.asset().address.address,
-      this.config.provider
-    );
+    const assetContract = new Contract({
+      abi: UniversalVaultAbi,
+      address: this.asset().address.address,
+      providerOrAccount: this.config.provider
+    });
     const call1 = assetContract.populate("approve", [
       this.address.address,
       uint256.bnToUint256(amountInfo.amount.toWei())
@@ -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[] = [