@strkfarm/sdk 1.0.55 → 1.0.57

package/src/strategies/universal-strategy.ts

@@ -0,0 +1,695 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
+import { PricerBase } from "@/modules/pricerBase";
+import { getNoRiskTags, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, VaultPosition } from "@/interfaces";
+import { Call, CallData, Contract, num, uint256 } from "starknet";
+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 { Global } from "@/global";
+
+export interface UniversalStrategySettings {
+  manager: ContractAddr,
+  vaultAllocator: ContractAddr,
+  redeemRequestNFT: ContractAddr,
+  leafAdapters: LeafAdapterFn<any>[],
+  adapters: {id: string, adapter: BaseAdapter}[],
+  targetHealthFactor: number,
+  minHealthFactor: number
+}
+
+
+export class UniversalStrategy<
+  S extends UniversalStrategySettings
+> extends BaseStrategy<
+  SingleTokenInfo,
+  SingleActionAmount
+> {
+
+  /** Contract address of the strategy */
+  readonly address: ContractAddr;
+  /** Pricer instance for token price calculations */
+  readonly pricer: PricerBase;
+  /** Metadata containing strategy information */
+  readonly metadata: IStrategyMetadata<S>;
+  /** Contract instance for interacting with the strategy */
+  readonly contract: Contract;
+  readonly managerContract: Contract;
+  merkleTree: StandardMerkleTree | undefined;
+
+  constructor(
+      config: IConfig,
+      pricer: PricerBase,
+      metadata: IStrategyMetadata<S>
+    ) {
+      super(config);
+      this.pricer = pricer;
+  
+      assert(
+        metadata.depositTokens.length === 1,
+        "VesuRebalance only supports 1 deposit token"
+      );
+      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
+      );
+  }
+
+  getMerkleTree() {
+    if (this.merkleTree) return this.merkleTree;
+    const leaves = this.metadata.additionalInfo.leafAdapters.map((adapter, index) => {
+      return adapter()
+    });
+    const standardTree = StandardMerkleTree.of(leaves.map(l => l.leaf));
+    this.merkleTree = standardTree;
+    return standardTree;
+  }
+
+  getMerkleRoot() {
+    return this.getMerkleTree().root;
+  }
+
+  getProofs<T>(id: string): { proofs: string[], callConstructor: GenerateCallFn<T> } {
+    const tree = this.getMerkleTree();
+    let proofs: string[] = [];
+    for (const [i, v] of tree.entries()) {
+      if (v.readableId == id) {
+        proofs = tree.getProof(i);
+      }
+    }
+    if (proofs.length === 0) {
+      throw new Error(`Proof not found for ID: ${id}`);
+    }
+
+    // find leaf adapter
+    const leafAdapter = this.metadata.additionalInfo.leafAdapters.find(adapter => adapter().leaf.readableId === id);
+    if (!leafAdapter) {
+      throw new Error(`Leaf adapter not found for ID: ${id}`);
+    }
+    const leafInfo = leafAdapter();
+    return {
+      proofs,
+      callConstructor: leafInfo.callConstructor.bind(leafInfo),
+    };
+  }
+
+  getAdapter(id: string): BaseAdapter {
+    const adapter = this.metadata.additionalInfo.adapters.find(adapter => adapter.id === id);
+    if (!adapter) {
+      throw new Error(`Adapter not found for ID: ${id}`);
+    }
+    return adapter.adapter;
+  }
+
+  asset() {
+    return this.metadata.depositTokens[0];
+  }
+
+  async depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]> {
+    // 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"
+    );
+    const assetContract = new Contract(
+      UniversalVaultAbi,
+      this.asset().address.address,
+      this.config.provider
+    );
+    const call1 = assetContract.populate("approve", [
+      this.address.address,
+      uint256.bnToUint256(amountInfo.amount.toWei())
+    ]);
+    const call2 = this.contract.populate("deposit", [
+      uint256.bnToUint256(amountInfo.amount.toWei()),
+      receiver.address
+    ]);
+    return [call1, call2];
+  }
+
+  /**
+   * Calculates the Total Value Locked (TVL) for a specific user.
+   * @param user - Address of the user
+   * @returns Object containing the amount in token units and USD value
+   */
+  async getUserTVL(user: ContractAddr) {
+    const shares = await this.contract.balanceOf(user.address);
+    const assets = await this.contract.convert_to_assets(
+      uint256.bnToUint256(shares)
+    );
+    const amount = Web3Number.fromWei(
+      assets.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+    let price = await this.pricer.getPrice(
+      this.metadata.depositTokens[0].symbol
+    );
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount,
+      usdValue
+    };
+  }
+
+  /**
+   * Calculates the weighted average APY across all pools based on USD value.
+   * @returns {Promise<number>} The weighted average APY across all pools
+   */
+  async netAPY(): Promise<{ net: number, splits: { apy: number, id: string }[] }> {
+    const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
+    const pools = await VesuAdapter.getVesuPools();
+    const pool1 = pools.pools.find(p => vesuAdapter1.config.poolId.eqString(num.getHexString(p.id)));
+    const pool2 = pools.pools.find(p => vesuAdapter2.config.poolId.eqString(num.getHexString(p.id)));
+    if (!pool1 || !pool2) {
+      throw new Error('Pool not found');
+    };
+    const collateralAsset1 = pool1.assets.find((a: any) => a.symbol === vesuAdapter1.config.collateral.symbol)?.stats!;
+    const debtAsset1 = pool1.assets.find((a: any) => a.symbol === vesuAdapter1.config.debt.symbol)?.stats!;
+    const collateralAsset2 = pool2.assets.find((a: any) => a.symbol === vesuAdapter2.config.collateral.symbol)?.stats!;
+    const debtAsset2 = pool2.assets.find((a: any) => a.symbol === vesuAdapter2.config.debt.symbol)?.stats!;
+
+    // supplyApy: { value: '8057256029163289', decimals: 18 },
+    // defiSpringSupplyApr: { value: '46856062629264560', decimals: 18 },
+    // borrowApr: { value: '12167825982336000', decimals: 18 },
+    const collateral1APY = Number(collateralAsset1.supplyApy.value) / 1e18;
+    const debt1APY = Number(debtAsset1.borrowApr.value) / 1e18;
+    const collateral2APY = Number(collateralAsset2.supplyApy.value) / 1e18;
+    const debt2APY = Number(debtAsset2.borrowApr.value) / 1e18;
+
+    const positions = await this.getVaultPositions();
+    const weights = positions.map((p, index) => p.usdValue * (index % 2 == 0 ? 1 : -1));
+    const baseAPYs = [collateral1APY, debt1APY, collateral2APY, debt2APY];
+    assert(positions.length == baseAPYs.length, "Positions and APYs length mismatch");
+    const rewardAPYs = [Number(collateralAsset1.defiSpringSupplyApr.value) / 1e18, 0, Number(collateralAsset2.defiSpringSupplyApr.value) / 1e18, 0];
+    const baseAPY = this.computeAPY(baseAPYs, weights);
+    const rewardAPY = this.computeAPY(rewardAPYs, weights);
+    const apys = [...baseAPYs, ...rewardAPYs];
+    const netAPY = baseAPY + rewardAPY;
+    return { net: netAPY, splits: [{
+      apy: baseAPY, id: 'base'
+    }, {
+      apy: rewardAPY, id: 'defispring'
+    }] };
+  }
+
+  private computeAPY(apys: number[], weights: number[]) {
+    assert(apys.length === weights.length, "APYs and weights length mismatch");
+    const weightedSum = apys.reduce((acc, apy, i) => acc + apy * weights[i], 0);
+    const totalWeight = weights.reduce((acc, weight) => acc + weight, 0);
+    return weightedSum / totalWeight;
+  }
+
+  /**
+     * Calculates the total TVL of the strategy.
+     * @returns Object containing the total amount in token units and USD value
+  */
+  async getTVL() {
+    const assets = await this.contract.total_assets();
+    const amount = Web3Number.fromWei(
+      assets.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+    let price = await this.pricer.getPrice(
+      this.metadata.depositTokens[0].symbol
+    );
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount,
+      usdValue
+    };
+  }
+
+  async getAUM(): Promise<{net: SingleTokenInfo, prevAum: Web3Number, splits: {id: string, aum: Web3Number}[]}> {
+    const currentAUM: bigint = await this.contract.call('aum', []) as bigint;
+    const lastReportTime = await this.contract.call('last_report_timestamp', []);
+
+    const token1Price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+
+    // calculate actual aum
+    const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
+    const leg1AUM = await vesuAdapter1.getPositions(this.config);
+    const leg2AUM = await vesuAdapter2.getPositions(this.config);
+
+    const aumToken = leg1AUM[0].amount
+      .plus(leg2AUM[0].usdValue / token1Price.price)
+      .minus(leg1AUM[1].usdValue / token1Price.price)
+      .minus(leg2AUM[1].amount);
+    logger.verbose(`${this.getTag()} Actual AUM: ${aumToken}`);
+
+    // calculate estimated growth from strk rewards
+    const netAPY = await this.netAPY();
+    const defispringAPY = netAPY.splits.find(s => s.id === 'defispring')?.apy || 0;
+    if (!defispringAPY) throw new Error('DefiSpring APY not found');
+
+    const timeDiff = (Math.round(Date.now() / 1000) - Number(lastReportTime));
+    const growthRate = timeDiff * defispringAPY / (365 * 24 * 60 * 60);
+    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
+    const rewardAssets = prevAum.multipliedBy(growthRate);
+    logger.verbose(`${this.getTag()} DefiSpring AUM time difference: ${timeDiff}`);
+    logger.verbose(`${this.getTag()} Current AUM: ${currentAUM}`);
+    logger.verbose(`${this.getTag()} Net APY: ${JSON.stringify(netAPY)}`);
+    logger.verbose(`${this.getTag()} rewards AUM: ${rewardAssets}`);
+
+    const newAUM = aumToken.plus(rewardAssets);
+    logger.verbose(`${this.getTag()} New AUM: ${newAUM}`);
+    
+    const net = {
+      tokenInfo: this.asset(),
+      amount: newAUM,
+      usdValue: newAUM.multipliedBy(token1Price.price).toNumber()
+    };
+    const splits = [{
+      id: 'finalised',
+      aum: aumToken
+    }, {
+      id: 'defispring',
+      aum: rewardAssets
+    }];
+    return { net, splits, prevAum };
+  }
+
+  getVesuAdapters() {
+    const vesuAdapter1 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG1) as VesuAdapter;
+    const vesuAdapter2 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG2) as VesuAdapter;
+    vesuAdapter1.pricer = this.pricer;
+    vesuAdapter2.pricer = this.pricer;
+    vesuAdapter1.networkConfig = this.config;
+    vesuAdapter2.networkConfig = this.config;
+    
+    return [vesuAdapter1, vesuAdapter2];
+  }
+
+  async getVaultPositions(): Promise<VaultPosition[]> {
+    const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
+    const leg1Positions = await vesuAdapter1.getPositions(this.config);
+    const leg2Positions = await vesuAdapter2.getPositions(this.config);
+    return [...leg1Positions, ...leg2Positions];
+  }
+
+  getSetManagerCall(strategist: ContractAddr, root = this.getMerkleRoot()) {
+    return this.managerContract.populate('set_manage_root', [strategist.address, num.getHexString(root)]);
+  }
+  
+  getManageCall(proofIds: string[], manageCalls: ManageCall[]) {
+    assert(proofIds.length == manageCalls.length, 'Proof IDs and Manage Calls length mismatch');
+    return this.managerContract.populate('manage_vault_with_merkle_verification', {
+        proofs: proofIds.map(id => this.getProofs(id).proofs),
+        decoder_and_sanitizers: manageCalls.map(call => call.sanitizer.address),
+        targets: manageCalls.map(call => call.call.contractAddress.address),
+        selectors: manageCalls.map(call => call.call.selector),
+        calldatas: manageCalls.map(call => call.call.calldata), // Calldata[]
+    });
+  }
+  
+  getVesuModifyPositionCalls(params: {
+    isLeg1: boolean,
+    isDeposit: boolean,
+    depositAmount: Web3Number,
+    debtAmount: Web3Number
+  }) {
+      assert(params.depositAmount.gt(0) || params.debtAmount.gt(0), 'Either deposit or debt amount must be greater than 0');
+      // approve token
+      const isToken1 = params.isLeg1 == params.isDeposit; // XOR
+      const STEP1_ID = isToken1 ? UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1 :UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN2;
+      const manage4Info = this.getProofs<ApproveCallParams>(STEP1_ID);
+      const approveAmount = params.isDeposit ? params.depositAmount : params.debtAmount;
+      const manageCall4 = manage4Info.callConstructor({
+          amount: approveAmount
+      })
+
+      // deposit and borrow or repay and withdraw
+      const STEP2_ID = params.isLeg1 ? UNIVERSAL_MANAGE_IDS.VESU_LEG1 : UNIVERSAL_MANAGE_IDS.VESU_LEG2;
+      const manage5Info = this.getProofs<VesuModifyPositionCallParams>(STEP2_ID);
+      const manageCall5 = manage5Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
+          collateralAmount: params.depositAmount,
+          isAddCollateral: params.isDeposit,
+          debtAmount: params.debtAmount,
+          isBorrow: params.isDeposit
+      }))
+
+      const output = [{
+        proofs: manage5Info.proofs,
+        manageCall: manageCall5,
+        step: STEP2_ID
+      }];
+      if (approveAmount.gt(0)) {
+        output.unshift({
+          proofs: manage4Info.proofs,
+          manageCall: manageCall4,
+          step: STEP1_ID
+        })
+      }
+      return output;
+  }
+
+  getTag() {
+    return `${UniversalStrategy.name}:${this.metadata.name}`;
+  }
+
+  async getVesuHealthFactors() {
+    return await Promise.all(this.getVesuAdapters().map(v => v.getHealthFactor()));
+  }
+
+  async computeRebalanceConditionAndReturnCalls(): Promise<Call[]> {
+    const vesuAdapters = this.getVesuAdapters();
+    const healthFactors = await this.getVesuHealthFactors();
+    const leg1HealthFactor = healthFactors[0];
+    const leg2HealthFactor = healthFactors[1];
+    logger.verbose(`${this.getTag()}: HealthFactorLeg1: ${leg1HealthFactor}`);
+    logger.verbose(`${this.getTag()}: HealthFactorLeg2: ${leg2HealthFactor}`);
+
+    const minHf = this.metadata.additionalInfo.minHealthFactor;
+    const isRebalanceNeeded1 = leg1HealthFactor < minHf;
+    const isRebalanceNeeded2 = leg2HealthFactor < minHf;
+    if (!isRebalanceNeeded1 && !isRebalanceNeeded2) {
+      return [];
+    }
+    
+    if (isRebalanceNeeded1) {
+      const amount = await this.getLegRebalanceAmount(vesuAdapters[0], leg1HealthFactor, false);
+      const leg2HF = await this.getNewHealthFactor(vesuAdapters[1], amount, true);
+      assert(leg2HF > minHf, `Rebalance Leg1 failed: Leg2 HF after rebalance would be too low: ${leg2HF}`);
+      return [await this.getRebalanceCall({
+        isLeg1toLeg2: false,
+        amount: amount
+      })];
+    } else {
+      const amount = await this.getLegRebalanceAmount(vesuAdapters[1], leg2HealthFactor, true);
+      const leg1HF = await this.getNewHealthFactor(vesuAdapters[0], amount, false);
+      assert(leg1HF > minHf, `Rebalance Leg2 failed: Leg1 HF after rebalance would be too low: ${leg1HF}`);
+      return [await this.getRebalanceCall({
+        isLeg1toLeg2: true,
+        amount: amount
+      })];
+    }
+  }
+
+  private async getNewHealthFactor(vesuAdapter: VesuAdapter, newAmount: Web3Number, isWithdraw: boolean) {
+    const {
+      collateralTokenAmount,
+      collateralUSDAmount,
+      collateralPrice,
+      debtTokenAmount,
+      debtUSDAmount,
+      debtPrice,
+      ltv
+    } = await vesuAdapter.getAssetPrices();
+
+    if (isWithdraw) {
+      const newHF = ((collateralTokenAmount.toNumber() - newAmount.toNumber()) * collateralPrice * ltv) / debtUSDAmount;
+      logger.verbose(`getNewHealthFactor:: HF: ${newHF}, amoutn: ${newAmount.toNumber()}, isDeposit`);
+      return newHF;
+    } else { // is borrow
+      const newHF = (collateralUSDAmount * ltv) / ((debtTokenAmount.toNumber() + newAmount.toNumber()) * debtPrice);
+      logger.verbose(`getNewHealthFactor:: HF: ${newHF}, amoutn: ${newAmount.toNumber()}, isRepay`);
+      return newHF;
+    }
+  }
+
+  /**
+   * 
+   * @param vesuAdapter 
+   * @param currentHf 
+   * @param isDeposit if true, attempt by adding collateral, else by repaying
+   * @returns 
+   */
+  private async getLegRebalanceAmount(vesuAdapter: VesuAdapter, currentHf: number, isDeposit: boolean) {
+    const {
+      collateralTokenAmount,
+      collateralUSDAmount,
+      collateralPrice,
+      debtTokenAmount,
+      debtUSDAmount,
+      debtPrice,
+      ltv
+    } = await vesuAdapter.getAssetPrices();
+
+    // debt is zero, nothing to rebalance
+    if(debtTokenAmount.isZero()) {
+      return Web3Number.fromWei(0, 0);
+    }
+
+    assert(collateralPrice > 0 && debtPrice > 0, "getRebalanceAmount: Invalid price");
+
+    // avoid calculating for too close
+    const targetHF = this.metadata.additionalInfo.targetHealthFactor;
+    if (currentHf > targetHF - 0.01) 
+      throw new Error("getLegRebalanceAmount: Current health factor is healthy");
+
+    if (isDeposit) {
+      // TargetHF = (collAmount + newAmount) * price * ltv / debtUSD
+      const newAmount = targetHF * debtUSDAmount / (collateralPrice * ltv) - collateralTokenAmount.toNumber();
+      logger.verbose(`${this.getTag()}:: getLegRebalanceAmount: addCollateral, currentHf: ${currentHf}, targetHF: ${targetHF}, collAmount: ${collateralTokenAmount.toString()}, collUSD: ${collateralUSDAmount}, collPrice: ${collateralPrice}, debtAmount: ${debtTokenAmount.toString()}, debtUSD: ${debtUSDAmount}, debtPrice: ${debtPrice}, ltv: ${ltv}, newAmount: ${newAmount}`);
+      return new Web3Number(newAmount.toFixed(8), collateralTokenAmount.decimals);
+    } else {
+      // TargetHF = collUSD * ltv / (debtAmount - newAmount) * debtPrice
+      const newAmount =  debtTokenAmount.toNumber() - collateralUSDAmount * ltv / (targetHF * debtPrice);
+      logger.verbose(`${this.getTag()}:: getLegRebalanceAmount: repayDebt, currentHf: ${currentHf}, targetHF: ${targetHF}, collAmount: ${collateralTokenAmount.toString()}, collUSD: ${collateralUSDAmount}, collPrice: ${collateralPrice}, debtAmount: ${debtTokenAmount.toString()}, debtUSD: ${debtUSDAmount}, debtPrice: ${debtPrice}, ltv: ${ltv}, newAmount: ${newAmount}`);
+      return new Web3Number(newAmount.toFixed(8), debtTokenAmount.decimals);
+    }
+  }
+
+  async getVesuMultiplyCall(params: {
+    isDeposit: boolean,
+    leg1DepositAmount: Web3Number
+  }) {
+    const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
+    const leg1LTV = await vesuAdapter1.getLTVConfig(this.config);
+    const leg2LTV = await vesuAdapter2.getLTVConfig(this.config);
+    logger.verbose(`${this.getTag()}: LTVLeg1: ${leg1LTV}`);
+    logger.verbose(`${this.getTag()}: LTVLeg2: ${leg2LTV}`);
+
+    const token1Price = await this.pricer.getPrice(vesuAdapter1.config.collateral.symbol);
+    const token2Price = await this.pricer.getPrice(vesuAdapter2.config.collateral.symbol);
+    logger.verbose(`${this.getTag()}: Price${vesuAdapter1.config.collateral.symbol}: ${token1Price.price}`);
+    logger.verbose(`${this.getTag()}: Price${vesuAdapter2.config.collateral.symbol}: ${token2Price.price}`);
+
+    const TARGET_HF = this.metadata.additionalInfo.targetHealthFactor;
+
+    const k1 = token1Price.price * leg1LTV  / token2Price.price / TARGET_HF;
+    const k2 = token1Price.price * TARGET_HF / token2Price.price / leg2LTV;
+
+    const borrow2Amount = new Web3Number(
+      params.leg1DepositAmount.multipliedBy(k1.toFixed(6)).dividedBy(k2 - k1).toFixed(6),
+      vesuAdapter2.config.debt.decimals
+    );
+    const borrow1Amount = new Web3Number(
+      borrow2Amount.multipliedBy(k2).toFixed(6),
+      vesuAdapter1.config.debt.decimals
+    );
+    logger.verbose(`${this.getTag()}:: leg1DepositAmount: ${params.leg1DepositAmount.toString()} ${vesuAdapter1.config.collateral.symbol}`);
+    logger.verbose(`${this.getTag()}:: borrow1Amount: ${borrow1Amount.toString()} ${vesuAdapter1.config.debt.symbol}`);
+    logger.verbose(`${this.getTag()}:: borrow2Amount: ${borrow2Amount.toString()} ${vesuAdapter2.config.debt.symbol}`);
+
+    const callSet1 = this.getVesuModifyPositionCalls({
+      isLeg1: true,
+      isDeposit: params.isDeposit,
+      depositAmount: params.leg1DepositAmount.plus(borrow2Amount),
+      debtAmount: borrow1Amount
+    });
+
+    const callSet2 = this.getVesuModifyPositionCalls({
+      isLeg1: false,
+      isDeposit: params.isDeposit,
+      depositAmount: borrow1Amount,
+      debtAmount: borrow2Amount
+    });
+
+    const allActions = [...callSet1.map(i => i.manageCall), ...callSet2.map(i => i.manageCall)];
+    const flashloanCalldata = CallData.compile([
+        [...callSet1.map(i => i.proofs), ...callSet2.map(i => i.proofs)],
+        allActions.map(i => i.sanitizer.address),
+        allActions.map(i => i.call.contractAddress.address),
+        allActions.map(i => i.call.selector),
+        allActions.map(i => i.call.calldata)
+    ])
+
+    // flash loan
+    const STEP1_ID = UNIVERSAL_MANAGE_IDS.FLASH_LOAN;
+    const manage1Info = this.getProofs<FlashloanCallParams>(STEP1_ID);
+    const manageCall1 = manage1Info.callConstructor({
+        amount: borrow2Amount,
+        data: flashloanCalldata.map(i => BigInt(i))
+    })
+    const manageCall = this.getManageCall([UNIVERSAL_MANAGE_IDS.FLASH_LOAN], [manageCall1]);
+    return manageCall;
+  }
+
+  async getRebalanceCall(params: {
+    isLeg1toLeg2: boolean,
+    amount: Web3Number
+  }) {
+    let callSet1 = this.getVesuModifyPositionCalls({
+      isLeg1: true,
+      isDeposit: params.isLeg1toLeg2,
+      depositAmount: Web3Number.fromWei(0, 0),
+      debtAmount: params.amount
+    });
+
+    let callSet2 = this.getVesuModifyPositionCalls({
+      isLeg1: false,
+      isDeposit: params.isLeg1toLeg2,
+      depositAmount: params.amount,
+      debtAmount: Web3Number.fromWei(0, 0)
+    });
+
+    if (params.isLeg1toLeg2) {
+      const manageCall = this.getManageCall([
+        ...callSet1.map(i => i.step), ...callSet2.map(i => i.step)
+      ], [...callSet1.map(i => i.manageCall), ...callSet2.map(i => i.manageCall)]);
+      return manageCall;
+    } else {
+      const manageCall = this.getManageCall([
+        ...callSet2.map(i => i.step), ...callSet1.map(i => i.step)
+      ], [...callSet2.map(i => i.manageCall), ...callSet1.map(i => i.manageCall)]);
+      return manageCall;
+    }
+  }
+}
+
+
+export enum UNIVERSAL_MANAGE_IDS {
+  FLASH_LOAN = 'flash_loan_init',
+  VESU_LEG1 = 'vesu_leg1',
+  VESU_LEG2 = 'vesu_leg2',
+  APPROVE_TOKEN1 = 'approve_token1',
+  APPROVE_TOKEN2 = 'approve_token2'
+}
+
+export enum UNIVERSAL_ADAPTERS {
+  COMMON = 'common_adapter',
+  VESU_LEG1 = 'vesu_leg1_adapter',
+  VESU_LEG2 = 'vesu_leg2_adapter'
+}
+
+function getLooperSettings(
+  token1Symbol: string,
+  token2Symbol: string,
+  vaultSettings: UniversalStrategySettings,
+  pool1: ContractAddr,
+  pool2: ContractAddr
+) {
+  const USDCToken = Global.getDefaultTokens().find(token => token.symbol === token1Symbol)!;
+  const ETHToken = Global.getDefaultTokens().find(token => token.symbol === token2Symbol)!;
+
+  const commonAdapter = new CommonAdapter({
+    manager: vaultSettings.manager,
+    asset: USDCToken.address,
+    id: UNIVERSAL_MANAGE_IDS.FLASH_LOAN
+  })
+  const vesuAdapterUSDCETH = new VesuAdapter({
+    poolId: pool1,
+    collateral: USDCToken,
+    debt: ETHToken,
+    vaultAllocator: vaultSettings.vaultAllocator,
+    id: UNIVERSAL_MANAGE_IDS.VESU_LEG1
+  })
+  const vesuAdapterETHUSDC = new VesuAdapter({
+    poolId: pool2,
+    collateral: ETHToken,
+    debt: USDCToken,
+    vaultAllocator: vaultSettings.vaultAllocator,
+    id: UNIVERSAL_MANAGE_IDS.VESU_LEG2
+  })
+  vaultSettings.adapters.push(...[{
+    id: UNIVERSAL_ADAPTERS.COMMON,
+    adapter: commonAdapter
+  }, {
+    id: UNIVERSAL_ADAPTERS.VESU_LEG1,
+    adapter: vesuAdapterUSDCETH
+  }, {
+    id: UNIVERSAL_ADAPTERS.VESU_LEG2,
+    adapter: vesuAdapterETHUSDC
+  }])
+  vaultSettings.leafAdapters.push(commonAdapter.getFlashloanAdapter.bind(commonAdapter));
+  vaultSettings.leafAdapters.push(vesuAdapterUSDCETH.getModifyPosition.bind(vesuAdapterUSDCETH));
+  vaultSettings.leafAdapters.push(vesuAdapterETHUSDC.getModifyPosition.bind(vesuAdapterETHUSDC));
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(USDCToken.address, vesuAdapterUSDCETH.VESU_SINGLETON, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(ETHToken.address, vesuAdapterETHUSDC.VESU_SINGLETON, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN2).bind(commonAdapter));
+  return vaultSettings; 
+}
+
+const _riskFactor: RiskFactor[] = [
+  { type: RiskType.SMART_CONTRACT_RISK, value: 0.5, weight: 25, reason: "Audited by Zellic" },
+  { type: RiskType.LIQUIDATION_RISK, value: 1, weight: 50, reason: "Liquidation risk is mitigated btable price feed on Starknet" }
+];
+
+const usdcVaultSettings: UniversalStrategySettings = {
+  manager: ContractAddr.from('0xf41a2b1f498a7f9629db0b8519259e66e964260a23d20003f3e42bb1997a07'),
+  vaultAllocator: ContractAddr.from('0x228cca1005d3f2b55cbaba27cb291dacf1b9a92d1d6b1638195fbd3d0c1e3ba'),
+  redeemRequestNFT: ContractAddr.from('0x906d03590010868cbf7590ad47043959d7af8e782089a605d9b22567b64fda'),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
+}
+
+const wbtcVaultSettings: UniversalStrategySettings = {
+  manager: ContractAddr.from('0xef8a664ffcfe46a6af550766d27c28937bf1b77fb4ab54d8553e92bca5ba34'),
+  vaultAllocator: ContractAddr.from('0x1e01c25f0d9494570226ad28a7fa856c0640505e809c366a9fab4903320e735'),
+  redeemRequestNFT: ContractAddr.from('0x4fec59a12f8424281c1e65a80b5de51b4e754625c60cddfcd00d46941ec37b2'),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
+}
+
+export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[] =
+  [
+    {
+      name: "USDC Evergreen",
+      description: "A universal strategy for managing USDC assets",
+      address: ContractAddr.from('0x7e6498cf6a1bfc7e6fc89f1831865e2dacb9756def4ec4b031a9138788a3b5e'),
+      launchBlock: 0,
+      type: 'ERC4626',
+      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'USDC')!],
+      additionalInfo: getLooperSettings('USDC', 'ETH', usdcVaultSettings, VesuPools.Genesis, VesuPools.Genesis),
+      risk: {
+        riskFactor: _riskFactor,
+        netRisk:
+          _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
+          _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
+        notARisks: getNoRiskTags(_riskFactor)
+      },
+      protocols: [Protocols.VESU],
+      maxTVL: Web3Number.fromWei(0, 6),
+      contractDetails: [],
+      faqs: [],
+      investmentSteps: [],
+    },
+    {
+      name: "WBTC Evergreen",
+      description: "A universal strategy for managing WBTC assets",
+      address: ContractAddr.from('0x5a4c1651b913aa2ea7afd9024911603152a19058624c3e425405370d62bf80c'),
+      launchBlock: 0,
+      type: 'ERC4626',
+      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!],
+      additionalInfo: getLooperSettings('WBTC', 'ETH', wbtcVaultSettings, VesuPools.Genesis, VesuPools.Genesis),
+      risk: {
+        riskFactor: _riskFactor,
+        netRisk:
+          _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
+          _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
+        notARisks: getNoRiskTags(_riskFactor)
+      },
+      protocols: [Protocols.VESU],
+      maxTVL: Web3Number.fromWei(0, 8),
+      contractDetails: [],
+      faqs: [],
+      investmentSteps: [],
+    },
+  ]