@strkfarm/sdk 2.0.0-dev.5 → 2.0.0-dev.51

package/src/strategies/vesu-rebalance.tsx

@@ -9,10 +9,19 @@ import {
   IProtocol,
   IStrategyMetadata,
   RiskFactor,
-  RiskType
+  RiskType,
+  StrategyTag,
+  AuditStatus,
+  SourceCodeType,
+  AccessControlType,
+  InstantWithdrawalVault,
+  StrategySettings,
+  StrategyLiveStatus,
+  VaultType,
+  UnwrapLabsCurator,
 } from "@/interfaces";
 import { AvnuWrapper, Pricer, SwapInfo } from "@/modules";
-import { Account, CairoCustomEnum, Contract, num, uint256 } from "starknet";
+import { Account, CairoCustomEnum, Contract, num, uint256, BlockIdentifier } from "starknet";
 import VesuRebalanceAbi from "@/data/vesu-rebalance.abi.json";
 import { Global } from "@/global";
 import { assert } from "@/utils";
@@ -26,7 +35,7 @@ import {
   SingleTokenInfo
 } from "./base-strategy";
 import { getAPIUsingHeadlessBrowser } from "@/node/headless";
-import { VESU_REWARDS_ENDPOINT, VesuHarvests } from "@/modules/harvests";
+import { VESU_REWARDS_ENDPOINT, VesuHarvests, HarvestInfo } from "@/modules/harvests";
 import VesuPoolIDs from "@/data/vesu_pools.json";
 import { COMMON_CONTRACTS, ENDPOINTS } from "./constants";
 
@@ -150,7 +159,8 @@ export class VesuRebalance extends BaseStrategy<
   async withdrawCall(
     amountInfo: SingleActionAmount,
     receiver: ContractAddr,
-    owner: ContractAddr
+    owner: ContractAddr,
+    _isMaxWithdraw: boolean = false
   ) {
     return [
       this.contract.populate("withdraw", [
@@ -177,22 +187,26 @@ export class VesuRebalance extends BaseStrategy<
     return this.metadata.depositTokens[0].decimals; // same as underlying token
   }
 
-  /**
-   * 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.balance_of(user.address);
-    const assets = await this.contract.convert_to_assets(
-      uint256.bnToUint256(shares)
+  async getUserTVL(user: ContractAddr, blockIdentifier: BlockIdentifier = "latest") {
+    const shares: any = await this.contract.call("balanceOf", [user.address], { blockIdentifier });
+    const assets: any = await this.contract.call(
+      "convert_to_assets",
+      [uint256.bnToUint256(shares)],
+      { blockIdentifier }
     );
     const amount = Web3Number.fromWei(
       assets.toString(),
       this.metadata.depositTokens[0].decimals
     );
+
+    // Convert blockIdentifier to block number for pricer if it's a number
+    const blockNumber = typeof blockIdentifier === 'number' || typeof blockIdentifier === 'bigint'
+      ? Number(blockIdentifier)
+      : undefined;
+
     let price = await this.pricer.getPrice(
-      this.metadata.depositTokens[0].symbol
+      this.metadata.depositTokens[0].symbol,
+      blockNumber
     );
     const usdValue = Number(amount.toFixed(6)) * price.price;
     return {
@@ -202,6 +216,105 @@ export class VesuRebalance extends BaseStrategy<
     };
   }
 
+  /**
+   * Calculates user realized APY based on trueSharesBasedAPY method.
+   * Returns the APY as a number.
+   */
+  async getUserRealizedAPY(
+    blockIdentifier: BlockIdentifier = "latest",
+    sinceBlocks = 600000
+  ): Promise<number> {
+    logger.verbose(
+      `${VesuRebalance.name}: getUserRealizedAPY => starting with blockIdentifier=${blockIdentifier}, sinceBlocks=${sinceBlocks}`
+    );
+
+    // Determine current block number and timestamp
+    let blockNow =
+      typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint"
+        ? Number(blockIdentifier)
+        : (await this.config.provider.getBlockLatestAccepted()).block_number;
+    const blockNowTime =
+      typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint"
+        ? (await this.config.provider.getBlockWithTxs(blockIdentifier)).timestamp
+        : new Date().getTime() / 1000;
+
+    // Look back window, but never before launch block
+    const blockBefore = Math.max(
+      blockNow - sinceBlocks,
+      this.metadata.launchBlock
+    );
+
+    // TVL amounts (in underlying token units) and supply at current reference block
+    const assetsNowRaw: bigint = await this.contract.call("total_assets", [], {
+      blockIdentifier,
+    }) as bigint;
+    const amountNow = Web3Number.fromWei(
+      assetsNowRaw.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+
+    const supplyNowRaw: bigint = await this.contract.call("total_supply", [], {
+      blockIdentifier,
+    }) as bigint;
+    const supplyNow = Web3Number.fromWei(
+      supplyNowRaw.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+
+    // Historical TVL and supply
+    const assetsBeforeRaw: bigint = await this.contract.call(
+      "total_assets",
+      [],
+      { blockIdentifier: blockBefore }
+    ) as bigint;
+    const amountBefore = Web3Number.fromWei(
+      assetsBeforeRaw.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+
+    const supplyBeforeRaw: bigint = await this.contract.call(
+      "total_supply",
+      [],
+      { blockIdentifier: blockBefore }
+    ) as bigint;
+    const supplyBefore = Web3Number.fromWei(
+      supplyBeforeRaw.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+
+    const blockBeforeInfo = await this.config.provider.getBlockWithTxs(
+      blockBefore
+    );
+
+    const assetsPerShareNow = amountNow
+      .multipliedBy(1e18)
+      .dividedBy(supplyNow.toString());
+
+    const assetsPerShareBf = amountBefore
+      .multipliedBy(1e18)
+      .dividedBy(supplyBefore.toString());
+
+    const timeDiffSeconds = blockNowTime - blockBeforeInfo.timestamp;
+
+    logger.verbose(`${VesuRebalance.name}:${this.metadata.name} [getUserRealizedAPY] assetsNow: ${amountNow.toString()}`);
+    logger.verbose(`${VesuRebalance.name}:${this.metadata.name} [getUserRealizedAPY] assetsBefore: ${amountBefore.toString()}`);
+    logger.verbose(`${VesuRebalance.name}:${this.metadata.name} [getUserRealizedAPY] assetsPerShareNow: ${assetsPerShareNow.toString()}`);
+    logger.verbose(`${VesuRebalance.name}:${this.metadata.name} [getUserRealizedAPY] assetsPerShareBf: ${assetsPerShareBf.toString()}`);
+    logger.verbose(`${VesuRebalance.name}:${this.metadata.name} [getUserRealizedAPY] Supply before: ${supplyBefore.toString()}`);
+    logger.verbose(`${VesuRebalance.name}:${this.metadata.name} [getUserRealizedAPY] Supply now: ${supplyNow.toString()}`);
+    logger.verbose(`${VesuRebalance.name}:${this.metadata.name} [getUserRealizedAPY] Time diff in seconds: ${timeDiffSeconds}`);
+
+    const apyForGivenBlocks =
+      Number(
+        assetsPerShareNow
+          .minus(assetsPerShareBf)
+          .multipliedBy(10000)
+          .dividedBy(assetsPerShareBf)
+      ) / 10000;
+
+    return (apyForGivenBlocks * (365 * 24 * 3600)) / timeDiffSeconds;
+  }
+
   /**
    * Calculates the total TVL of the strategy.
    * @returns Object containing the total amount in token units and USD value
@@ -224,7 +337,7 @@ export class VesuRebalance extends BaseStrategy<
   }
 
   static async getAllPossibleVerifiedPools(asset: ContractAddr) {
-    const data = await getAPIUsingHeadlessBrowser(`${ENDPOINTS.VESU_BASE_STAGING}/pools`);
+    const data = await getAPIUsingHeadlessBrowser(`${ENDPOINTS.VESU_BASE}/pools`);
     const verifiedPools = data.data.filter((d: any) => d.isVerified);
     const pools = verifiedPools
       .map((p: any) => {
@@ -490,7 +603,7 @@ export class VesuRebalance extends BaseStrategy<
     let pools: any[] = [];
     try {
       const data = await getAPIUsingHeadlessBrowser(
-        `${ENDPOINTS.VESU_BASE_STAGING}/pools`
+        `${ENDPOINTS.VESU_BASE}/pools`
       );
       pools = data.data;
 
@@ -767,10 +880,17 @@ export class VesuRebalance extends BaseStrategy<
     return [baseFlow];
   }
 
-  async harvest(acc: Account, endpoint = VESU_REWARDS_ENDPOINT) {
-    const vesuHarvest = new VesuHarvests(this.config);
-    const harvests = await vesuHarvest.getUnHarvestedRewards(this.address, endpoint);
-    const harvest = harvests[0];
+  async getPendingRewards(): Promise<HarvestInfo[]> {
+    const vesuHarvests = new VesuHarvests(this.config);
+    return await vesuHarvests.getUnHarvestedRewards(this.address);
+  }
+
+  async harvest(acc: Account) {
+    const pendingRewards = await this.getPendingRewards();
+    if (pendingRewards.length == 0) {
+      throw new Error(`No pending rewards found`);
+    }
+    const harvest = pendingRewards[0];
     const avnu = new AvnuWrapper();
     let swapInfo: SwapInfo = {
       token_from_address: harvest.token.address,
@@ -902,6 +1022,91 @@ const _riskFactor: RiskFactor[] = [
 const AUDIT_URL =
   "https://assets.troves.fi/strkfarm/audit_report_vesu_and_ekubo_strats.pdf";
 
+// Helper to create common risk object
+const getVesuRebalanceRisk = () => ({
+    riskFactor: _riskFactor,
+    netRisk:
+        _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
+        _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
+    notARisks: getNoRiskTags(_riskFactor)
+});
+
+// Helper to create Vesu Rebalance strategy settings
+const createVesuRebalanceSettings = (tokenSymbol: string): StrategySettings => {
+    const depositToken = Global.getDefaultTokens().find(
+        (t) => t.symbol === tokenSymbol
+    )!;
+    return {
+        isPaused: false,
+        liveStatus: StrategyLiveStatus.DEPRECATED,
+        isAudited: true,
+        isInstantWithdrawal: true,
+        quoteToken: depositToken,
+        alerts: []
+    };
+};
+
+// Helper to create a Vesu Rebalance strategy
+const createVesuRebalanceStrategy = (
+    idSymbol: string,
+    name: string,
+    tokenSymbol: string,
+    address: string
+): IStrategyMetadata<VesuRebalanceSettings> => ({
+    id: `vesu_fusion_${idSymbol.toLowerCase()}`,
+    name,
+    description: _description.replace("{{TOKEN}}", tokenSymbol),
+    address: ContractAddr.from(address),
+    launchBlock: 0,
+    type: "ERC4626" as const,
+    vaultType: {
+      type: VaultType.META_VAULT,
+      description: `Automatically diversify ${tokenSymbol} holdings into different Vesu pools while reducing risk and maximizing yield. Defi spring ${tokenSymbol} Rewards are auto-compounded as well.`
+    },
+    depositTokens: [
+        Global.getDefaultTokens().find((t) => t.symbol === tokenSymbol)!
+    ],
+    protocols: [_protocol],
+    auditUrl: AUDIT_URL,
+    curator: UnwrapLabsCurator,
+    settings: createVesuRebalanceSettings(tokenSymbol),
+    risk: getVesuRebalanceRisk(),
+    additionalInfo: {
+        feeBps: 1000
+    },
+    faqs,
+    contractDetails: [],
+    investmentSteps: [],
+    tags: [],
+    security: VESU_SECURITY,
+    redemptionInfo: VESU_REDEMPTION_INFO,
+    discontinuationInfo: {
+        info: "This strategy has been deprecated and is no longer accepting new deposits."
+    },
+    usualTimeToEarnings: null,
+    usualTimeToEarningsDescription: null,
+});
+
+// Shared security & redemption metadata for all Vesu strategies
+const VESU_SECURITY = {
+  auditStatus: AuditStatus.AUDITED,
+  sourceCode: {
+    type: SourceCodeType.OPEN_SOURCE,
+    contractLink: "https://github.com/trovesfi/troves-contracts",
+  },
+  accessControl: {
+    type: AccessControlType.ROLE_BASED_ACCESS,
+    addresses: [ContractAddr.from("0x0")],
+    timeLock: "2 Days",
+  },
+};
+
+const VESU_REDEMPTION_INFO = {
+  instantWithdrawalVault: InstantWithdrawalVault.YES,
+  redemptionsInfo: [],
+  alerts: [],
+};
+
 const faqs: FAQ[] = [
   {
     question: "What is the Vesu Rebalancing Strategy?",
@@ -953,137 +1158,32 @@ const faqs: FAQ[] = [
  * Represents the Vesu Rebalance Strategies.
  */
 export const VesuRebalanceStrategies: IStrategyMetadata<VesuRebalanceSettings>[] =
-  [
-    {
-      name: "Vesu Fusion STRK",
-      description: _description,
-      address: ContractAddr.from(
-        "0x7fb5bcb8525954a60fde4e8fb8220477696ce7117ef264775a1770e23571929"
-      ),
-      launchBlock: 0,
-      type: "ERC4626",
-      depositTokens: [
-        Global.getDefaultTokens().find((t) => t.symbol === "STRK")!
-      ],
-      protocols: [_protocol],
-      auditUrl: AUDIT_URL,
-      maxTVL: Web3Number.fromWei("0", 18),
-      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)
-      },
-      additionalInfo: {
-        feeBps: 1000
-      },
-      faqs,
-      contractDetails: [],
-      investmentSteps: []
-    },
-    {
-      name: "Vesu Fusion ETH",
-      description: _description.replace("{{TOKEN}}", "ETH"),
-      address: ContractAddr.from(
-        "0x5eaf5ee75231cecf79921ff8ded4b5ffe96be718bcb3daf206690ad1a9ad0ca"
-      ),
-      launchBlock: 0,
-      type: "ERC4626",
-      auditUrl: AUDIT_URL,
-      depositTokens: [
-        Global.getDefaultTokens().find((t) => t.symbol === "ETH")!
-      ],
-      protocols: [_protocol],
-      maxTVL: Web3Number.fromWei("0", 18),
-      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)
-      },
-      additionalInfo: {
-        feeBps: 1000
-      },
-      faqs,
-      contractDetails: [],
-      investmentSteps: []
-    },
-    {
-      name: "Vesu Fusion USDC",
-      description: _description.replace("{{TOKEN}}", "USDC"),
-      address: ContractAddr.from(
-        "0xa858c97e9454f407d1bd7c57472fc8d8d8449a777c822b41d18e387816f29c"
-      ),
-      launchBlock: 0,
-      type: "ERC4626",
-      auditUrl: AUDIT_URL,
-      depositTokens: [
-        Global.getDefaultTokens().find((t) => t.symbol === "USDC")!
-      ],
-      protocols: [_protocol],
-      maxTVL: Web3Number.fromWei("0", 6),
-      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)
-      },
-      additionalInfo: {
-        feeBps: 1000
-      },
-      faqs,
-      contractDetails: [],
-      investmentSteps: []
-    },
-    {
-      name: "Vesu Fusion USDT",
-      description: _description.replace("{{TOKEN}}", "USDT"),
-      address: ContractAddr.from(
-        "0x115e94e722cfc4c77a2f15c4aefb0928c1c0029e5a57570df24c650cb7cec2c"
-      ),
-      launchBlock: 0,
-      type: "ERC4626",
-      depositTokens: [
-        Global.getDefaultTokens().find((t) => t.symbol === "USDT")!
-      ],
-      auditUrl: AUDIT_URL,
-      protocols: [_protocol],
-      maxTVL: Web3Number.fromWei("0", 6),
-      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)
-      },
-      additionalInfo: {
-        feeBps: 1000
-      },
-      faqs,
-      contractDetails: [],
-      investmentSteps: []
-      // }, {
-      //     name: 'Vesu Fusion WBTC',
-      //     description: _description.replace('{{TOKEN}}', 'WBTC'),
-      //     address: ContractAddr.from('0x778007f8136a5b827325d21613803e796bda4d676fbe1e34aeab0b2a2ec027f'),
-      //     type: 'ERC4626',
-      //     depositTokens: [Global.getDefaultTokens().find(t => t.symbol === 'WBTC')!],
-      // auditUrl: AUDIT_URL,
-      //     protocols: [_protocol],
-      //     maxTVL: Web3Number.fromWei('0', 8),
-      //     risk: {
-      //         riskFactor: _riskFactor,
-      //         netRisk: _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
-      //     },
-      //     additionalInfo: {
-      //         feeBps: 1000,
-      //     },
-      
-    }
-];
+    [
+        createVesuRebalanceStrategy(
+            'strk',
+            "Vesu Fusion STRK",
+            "STRK",
+            "0x7fb5bcb8525954a60fde4e8fb8220477696ce7117ef264775a1770e23571929"
+        ),
+        createVesuRebalanceStrategy(
+            'eth',
+            "Vesu Fusion ETH",
+            "ETH",
+            "0x5eaf5ee75231cecf79921ff8ded4b5ffe96be718bcb3daf206690ad1a9ad0ca"
+        ),
+        createVesuRebalanceStrategy(
+            'usdc',
+            "Vesu Fusion USDC.e",
+            "USDC.e",
+            "0xa858c97e9454f407d1bd7c57472fc8d8d8449a777c822b41d18e387816f29c"
+        ),
+        createVesuRebalanceStrategy(
+            'usdt',
+            "Vesu Fusion USDT",
+            "USDT",
+            "0x115e94e722cfc4c77a2f15c4aefb0928c1c0029e5a57570df24c650cb7cec2c"
+        )
+    ];
 
 // auto assign contract details to each strategy
 VesuRebalanceStrategies.forEach((s) => {
@@ -1092,7 +1192,7 @@ VesuRebalanceStrategies.forEach((s) => {
     address: s.address,
     name: "Vault",
     sourceCodeUrl: "https://github.com/strkfarm/strkfarm-contracts/tree/main/src/strategies/vesu_rebalance"
-  }, 
+  },
   ...COMMON_CONTRACTS];
   // set docs link
   s.docs = "https://docs.troves.fi/p/strategies/vesu-fusion-rebalancing-vaults"
@@ -1115,4 +1215,5 @@ VesuRebalanceStrategies.forEach((s) => {
     "Monitor and Rebalance funds across multiple Vesu pools to maximize yield",
     "Harvest and supply Defi Spring STRK rewards every week (Auto-compound)",
   ]
-});
+
+});