@strkfarm/sdk 2.0.0-dev.34 → 2.0.0-dev.36

package/src/strategies/universal-strategy.tsx

@@ -1,19 +1,20 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
-import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
+import { SingleActionAmount, SingleTokenInfo, UserPositionCard, UserPositionCardsInput } from "./base-strategy";
 import { PricerBase } from "@/modules/pricerBase";
-import { FAQ, getNoRiskTags, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, StrategyTag, VaultPosition, AuditStatus, SourceCodeType, AccessControlType, InstantWithdrawalVault, StrategyLiveStatus, StrategySettings, VaultType, RedemptionInfo } from "@/interfaces";
+import { FAQ, getNoRiskTags, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, StrategyTag, VaultPosition, AuditStatus, SourceCodeType, AccessControlType, InstantWithdrawalVault, StrategyLiveStatus, StrategySettings, VaultType, RedemptionInfo, UnwrapLabsCurator, getMainnetConfig } from "@/interfaces";
 import { BlockIdentifier, 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, AvnuSwapCallParams, BaseAdapter, CommonAdapter, DepositParams, FlashloanCallParams, GenerateCallFn, LeafAdapterFn, ManageCall, WithdrawParams } from "./universal-adapters";
+import { ApproveCallParams, AvnuAdapter, AvnuSwapCallParams, BaseAdapter, BaseAdapterConfig, CommonAdapter, DepositParams, FlashloanCallParams, GenerateCallFn, LeafAdapterFn, ManageCall, VesuModifyPositionAdapter, VesuMultiplyAdapter, WithdrawParams } from "./universal-adapters";
 import { VesuAdapter, VesuModifyPositionCallParams, VesuDefiSpringRewardsCallParams, VesuPools } from "./universal-adapters/vesu-adapter";
 import { Global } from "@/global";
-import { AvnuWrapper, ERC20 } from "@/modules";
-import { AVNU_MIDDLEWARE, VESU_SINGLETON } from "./universal-adapters/adapter-utils";
+import { AvnuWrapper, ERC20, PricerFromApi } from "@/modules";
+import { AVNU_EXCHANGE, AVNU_MIDDLEWARE, AVNU_QUOTE_URL, VESU_SINGLETON } from "./universal-adapters/adapter-utils";
 import { LSTPriceType } from "./types";
 import { HarvestInfo, VesuHarvests } from "@/modules/harvests";
+import { SVKStrategy } from "./svk-strategy";
 
 export interface UniversalManageCall {
   proofs: string[];
@@ -42,7 +43,8 @@ export interface UniversalStrategySettings {
 
 export enum AUMTypes {
   FINALISED = 'finalised',
-  DEFISPRING = 'defispring'
+  DEFISPRING = 'defispring',
+  BTCFI = 'btcfi',
 }
 
 export enum PositionTypeAvnuExtended {
@@ -52,47 +54,18 @@ export enum PositionTypeAvnuExtended {
 
 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;
+> extends SVKStrategy<S> {
 
   constructor(
       config: IConfig,
       pricer: PricerBase,
       metadata: IStrategyMetadata<S>
     ) {
-      super(config);
-      this.pricer = pricer;
-
+      super(config, pricer, metadata);
       assert(
         metadata.depositTokens.length === 1,
-        "VesuRebalance only supports 1 deposit token"
+        "VesuRebalance only supports 1 deposit token",
       );
-      this.metadata = metadata;
-      this.address = metadata.address;
-
-      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() {
@@ -411,6 +384,50 @@ export class UniversalStrategy<
     return (apyForGivenBlocks * (365 * 24 * 3600)) / timeDiffSeconds;
   }
 
+  async getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]> {
+    const { user, investmentFlows = [] } = input;
+    const [userTVL] = await Promise.all([
+      this.getUserTVL(user),
+    ]);
+    const cards: UserPositionCard[] = [
+      {
+        title: "Your Holdings",
+        tooltip: "Your Holdings",
+        value: this.formatTokenAmountForCard(userTVL.amount, userTVL.tokenInfo),
+        subValue: `≈ ${this.formatUSDForCard(userTVL.usdValue)}`,
+        subValueColor: "positive",
+      },
+    ];
+
+    let lifetimeAmount = userTVL.amount.multipliedBy(0);
+    let lifetimeTokenInfo = userTVL.tokenInfo;
+    let lifetimeUsdValue = 0;
+    if (investmentFlows.length > 0) {
+      try {
+        const earningsResult = this.getLifetimeEarnings(userTVL, investmentFlows);
+        lifetimeAmount = earningsResult.lifetimeEarnings;
+        lifetimeTokenInfo = earningsResult.tokenInfo.tokenInfo;
+        const userAmount = userTVL.amount.toNumber();
+        if (Number.isFinite(userAmount) && userAmount > 0) {
+          const pricePerToken = userTVL.usdValue / userAmount;
+          lifetimeUsdValue = lifetimeAmount.toNumber() * pricePerToken;
+        }
+      } catch (error) {
+        logger.warn(`${this.getTag()}::getUserPositionCards lifetime earnings fallback`, error);
+      }
+    }
+
+    cards.push({
+      title: "Lifetime Earnings",
+      tooltip: "Lifetime Earnings",
+      value: this.formatTokenAmountForCard(lifetimeAmount, lifetimeTokenInfo),
+      subValue: `≈ ${this.formatUSDForCard(lifetimeUsdValue)}`,
+      subValueColor: this.getSubValueColorFromSignedNumber(lifetimeUsdValue),
+    });
+
+    return cards;
+  }
+
   /**
      * Calculates the total TVL of the strategy.
      * @returns Object containing the total amount in token units and USD value
@@ -550,15 +567,33 @@ export class UniversalStrategy<
     return rewardAssets;
   }
 
-  getVesuAdapters() {
-    const vesuAdapter1 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG1) as unknown as VesuAdapter;
-    const vesuAdapter2 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG2) as unknown as VesuAdapter;
-    vesuAdapter1.pricer = this.pricer;
-    vesuAdapter2.pricer = this.pricer;
-    vesuAdapter1.networkConfig = this.config;
-    vesuAdapter2.networkConfig = this.config;
+  getVesuMultiplyAdapter(): VesuMultiplyAdapter {
+    const id = UNIVERSAL_ADAPTER_IDS.VESU_MULTIPLY;
+    const adapter = this.getAdapter(id) as VesuMultiplyAdapter;
+    adapter.config.pricer = this.pricer;
+    adapter.config.networkConfig = this.config;
+    adapter._vesuAdapter.pricer = this.pricer;
+    adapter._vesuAdapter.networkConfig = this.config;
+    return adapter;
+  }
+
+  getVesuModifyPositionAdapter(): VesuModifyPositionAdapter {
+    const id = UNIVERSAL_ADAPTER_IDS.VESU_MODIFY;
+    const adapter = this.getAdapter(id) as VesuModifyPositionAdapter;
+    adapter.config.pricer = this.pricer;
+    adapter.config.networkConfig = this.config;
+    adapter._vesuAdapter.pricer = this.pricer;
+    adapter._vesuAdapter.networkConfig = this.config;
+    return adapter;
+  }
 
-    return [vesuAdapter1, vesuAdapter2];
+  /**
+   * Legacy helper for retired Evergreen flows. New integrations should use
+   * getVesuMultiplyAdapter / getVesuModifyPositionAdapter and BaseAdapter deposit/withdraw leaves.
+   */
+  getVesuAdapters(): VesuAdapter[] {
+    const multiply = this.getVesuMultiplyAdapter();
+    return [multiply._vesuAdapter];
   }
 
   async getVesuPositions(blockNumber: BlockIdentifier = 'latest'): Promise<VaultPosition[]> {
@@ -586,16 +621,15 @@ export class UniversalStrategy<
     return this.managerContract.populate('set_manage_root', [strategist.address, num.getHexString(root)]);
   }
 
-  // TODO: callConstructor now returns Promise<ManageCall[]>, migrate callers to await and flatten
-  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),
-    });
+  /**
+   * Compatibility helper: SVKStrategy's `getManageCall` expects proof-groups.
+   * We derive proof-groups from each manageCall's `proofReadableId`.
+   */
+  protected getManageCallFromManageCalls(manageCalls: ManageCall[]) {
+    return this.getManageCall(
+      this.getProofGroupsForManageCalls(manageCalls),
+      manageCalls,
+    );
   }
 
   getVesuModifyPositionCalls(params: {
@@ -821,22 +855,9 @@ export class UniversalStrategy<
         amount: borrow2Amount,
         data: flashloanCalldata.map(i => BigInt(i))
     })
-    const manageCall = this.getManageCall([UNIVERSAL_MANAGE_IDS.FLASH_LOAN], [manageCall1 as unknown as ManageCall]);
-    return manageCall;
-  }
-
-  async getBringLiquidityCall(params: {
-    amount: Web3Number
-  }) {
-    const manage1Info = this.getProofs<ApproveCallParams>(UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY);
-    const manageCall1 = manage1Info.callConstructor({
-        amount: params.amount
-    });
-    const manage2Info = this.getProofs<ApproveCallParams>(UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY);
-    const manageCall2 = manage2Info.callConstructor({
-        amount: params.amount
-    });
-    const manageCall = this.getManageCall([UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY, UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY], [manageCall1 as unknown as ManageCall, manageCall2 as unknown as ManageCall]);
+    const manageCall = this.getManageCallFromManageCalls([
+      manageCall1 as unknown as ManageCall,
+    ]);
     return manageCall;
   }
 
@@ -866,7 +887,6 @@ export class UniversalStrategy<
         amount,
         proofs
     });
-    const proofIds: string[] = [UNIVERSAL_MANAGE_IDS.DEFISPRING_REWARDS];
     const manageCalls: ManageCall[] = [manageCall1 as unknown as ManageCall];
 
     // swap rewards for underlying
@@ -891,14 +911,11 @@ export class UniversalStrategy<
       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 as unknown as ManageCall);
       manageCalls.push(manageCall3 as unknown as ManageCall);
     }
 
-    const manageCall = this.getManageCall(proofIds, manageCalls);
+    const manageCall = this.getManageCallFromManageCalls(manageCalls);
     return { call: manageCall, reward: actualReward, tokenInfo: STRK };
   }
 
@@ -921,14 +938,16 @@ export class UniversalStrategy<
     });
 
     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)]);
+      const manageCall = this.getManageCallFromManageCalls([
+        ...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)]);
+      const manageCall = this.getManageCallFromManageCalls([
+        ...callSet2.map(i => i.manageCall),
+        ...callSet1.map(i => i.manageCall),
+      ]);
       return manageCall;
     }
   }
@@ -952,10 +971,10 @@ export enum UNIVERSAL_MANAGE_IDS {
   AVNU_SWAP_REWARDS = 'avnu_swap_rewards'
 }
 
-export enum UNIVERSAL_ADAPTERS {
-  COMMON = 'common_adapter',
-  VESU_LEG1 = 'vesu_leg1_adapter',
-  VESU_LEG2 = 'vesu_leg2_adapter'
+export enum UNIVERSAL_ADAPTER_IDS {
+  VESU_MULTIPLY = 'vesu_multiply',
+  VESU_MODIFY = 'vesu_modify',
+  AVNU = 'avnu',
 }
 
 function getLooperSettings(
@@ -965,6 +984,9 @@ function getLooperSettings(
   pool1: ContractAddr,
   pool2: ContractAddr,
 ) {
+  vaultSettings.leafAdapters = [];
+  vaultSettings.adapters = [];
+
   const USDCToken = Global.getDefaultTokens().find(token => token.symbol === token1Symbol)!;
   const ETHToken = Global.getDefaultTokens().find(token => token.symbol === token2Symbol)!;
 
@@ -975,19 +997,45 @@ function getLooperSettings(
     vaultAddress: vaultSettings.vaultAddress,
     vaultAllocator: vaultSettings.vaultAllocator,
   })
-  const vesuAdapterUSDCETH = new VesuAdapter({
-    poolId: pool1,
-    collateral: USDCToken,
-    debt: ETHToken,
+
+  const baseAdapterConfig: BaseAdapterConfig = {
+    baseToken: USDCToken,
+    supportedPositions: [{ asset: USDCToken, isDebt: false }],
+    networkConfig: getMainnetConfig(),
+    pricer: new PricerFromApi(getMainnetConfig(), Global.getDefaultTokens()),
     vaultAllocator: vaultSettings.vaultAllocator,
-    id: UNIVERSAL_MANAGE_IDS.VESU_LEG1
+    vaultAddress: vaultSettings.vaultAddress,
+  };
+  const vesuMultiplyAdapter = new VesuMultiplyAdapter({
+    poolId: pool1,
+    collateral: ETHToken,
+    debt: USDCToken,
+    marginToken: USDCToken,
+    targetHealthFactor: 1.3,
+    minHealthFactor: 1.2,
+    quoteAmountToFetchPrice: new Web3Number(0.1, 18),
+    minimumVesuMovementAmount: 5,
+    ...baseAdapterConfig,
+    supportedPositions: [{asset: ETHToken, isDebt: false}, {asset: USDCToken, isDebt: true}],
   })
-  const vesuAdapterETHUSDC = new VesuAdapter({
-    poolId: pool2,
+  const vesuModifyPositionAdapter = new VesuModifyPositionAdapter({
+    poolId: pool1,
     collateral: ETHToken,
     debt: USDCToken,
-    vaultAllocator: vaultSettings.vaultAllocator,
-    id: UNIVERSAL_MANAGE_IDS.VESU_LEG2
+    targetLtv: 0.75,
+    maxLtv: 0.9,
+    ...baseAdapterConfig,
+    supportedPositions: [{asset: ETHToken, isDebt: false}, {asset: USDCToken, isDebt: true}],
+  })
+
+  const avnuAdapter = new AvnuAdapter({
+    baseUrl: AVNU_QUOTE_URL,
+    avnuContract: AVNU_EXCHANGE,
+    slippage: 0.01,
+    minimumExtendedPriceDifferenceForSwapOpen: 0,
+    maximumExtendedPriceDifferenceForSwapClosing: 0,
+    ...baseAdapterConfig,
+    supportedPositions: [{asset: ETHToken, isDebt: false}, {asset: USDCToken, isDebt: false}],
   })
   // vaultSettings.adapters.push(...[{
   //   id: UNIVERSAL_ADAPTERS.COMMON,
@@ -1004,8 +1052,24 @@ function getLooperSettings(
   // 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, VESU_SINGLETON, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(ETHToken.address, VESU_SINGLETON, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN2).bind(commonAdapter));
+  vaultSettings.adapters.push({
+    id: UNIVERSAL_ADAPTER_IDS.VESU_MULTIPLY,
+    adapter: vesuMultiplyAdapter,
+  });
+  vaultSettings.adapters.push({
+    id: UNIVERSAL_ADAPTER_IDS.VESU_MODIFY,
+    adapter: vesuModifyPositionAdapter,
+  });
+  vaultSettings.adapters.push({
+    id: UNIVERSAL_ADAPTER_IDS.AVNU,
+    adapter: avnuAdapter,
+  });
+  vaultSettings.leafAdapters.push(() => vesuMultiplyAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => vesuMultiplyAdapter.getWithdrawLeaf());
+  vaultSettings.leafAdapters.push(() => vesuModifyPositionAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => vesuModifyPositionAdapter.getWithdrawLeaf());
+  vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
 
   // 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));
@@ -1015,8 +1079,8 @@ function getLooperSettings(
   // 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));
+  // 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, true).bind(commonAdapter));
   return vaultSettings;
 }
@@ -1351,11 +1415,8 @@ const createUniversalStrategy = (params: {
         risk: getUniversalRisk(),
         auditUrl: AUDIT_URL,
         protocols: [Protocols.VESU],
-        realizedAPYMethodology: "The realizedAPY is based on past 14 days performance by the vault",
-        curator: {
-            name: "Unwrap Labs",
-            logo: "https://assets.troves.fi/integrations/unwraplabs/white.png"
-        },
+        realizedApyMethodology: "The realizedAPY is based on past 14 days performance by the vault",
+        curator: UnwrapLabsCurator,
         settings: createUniversalSettings(params.tokenSymbol, params.maxTVLDecimals),
         contractDetails: getContractDetails(params.vaultSettings),
         faqs: getFAQs(),

package/src/strategies/vesu-rebalance.tsx

@@ -18,6 +18,7 @@ import {
   StrategySettings,
   StrategyLiveStatus,
   VaultType,
+  UnwrapLabsCurator,
 } from "@/interfaces";
 import { AvnuWrapper, Pricer, SwapInfo } from "@/modules";
 import { Account, CairoCustomEnum, Contract, num, uint256, BlockIdentifier } from "starknet";
@@ -1035,7 +1036,6 @@ const createVesuRebalanceSettings = (tokenSymbol: string): StrategySettings => {
         (t) => t.symbol === tokenSymbol
     )!;
     return {
-        maxTVL: Web3Number.fromWei("0", depositToken.decimals),
         isPaused: false,
         liveStatus: StrategyLiveStatus.DEPRECATED,
         isAudited: true,
@@ -1067,10 +1067,7 @@ const createVesuRebalanceStrategy = (
     ],
     protocols: [_protocol],
     auditUrl: AUDIT_URL,
-    curator: {
-        name: "Unwrap Labs",
-        logo: "https://assets.troves.fi/integrations/unwraplabs/white.png"
-    },
+    curator: UnwrapLabsCurator,
     settings: createVesuRebalanceSettings(tokenSymbol),
     risk: getVesuRebalanceRisk(),
     additionalInfo: {
@@ -1097,7 +1094,7 @@ const VESU_SECURITY = {
     contractLink: "https://github.com/trovesfi/troves-contracts",
   },
   accessControl: {
-    type: AccessControlType.STANDARD_ACCOUNT,
+    type: AccessControlType.ROLE_BASED_ACCESS,
     addresses: [ContractAddr.from("0x0")],
     timeLock: "2 Days",
   },