@strkfarm/sdk 1.0.62 → 1.0.64

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[] = [