@strkfarm/sdk 1.2.1 → 2.0.0-dca.2

package/src/strategies/universal-strategy.tsx

@@ -1,7 +1,7 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
 import { PricerBase } from "@/modules/pricerBase";
-import { FAQ, getNoRiskTags, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, VaultPosition } from "@/interfaces";
+import { FAQ, getNoRiskTags, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, StrategyTag, VaultPosition, AuditStatus, SourceCodeType, AccessControlType, InstantWithdrawalVault, StrategyLiveStatus, StrategySettings, VaultType, RedemptionInfo } from "@/interfaces";
 import { BlockIdentifier, Call, CallData, Contract, num, uint256 } from "starknet";
 import { VesuRebalanceSettings } from "./vesu-rebalance";
 import { assert, LeafData, logger, StandardMerkleTree } from "@/utils";
@@ -11,6 +11,7 @@ import { ApproveCallParams, AvnuSwapCallParams, BaseAdapter, CommonAdapter, Flas
 import { Global } from "@/global";
 import { AvnuWrapper, ERC20 } from "@/modules";
 import { AVNU_MIDDLEWARE, VESU_SINGLETON } from "./universal-adapters/adapter-utils";
+import { LSTPriceType } from "./types";
 import { HarvestInfo, VesuHarvests } from "@/modules/harvests";
 
 export interface UniversalManageCall {
@@ -174,22 +175,26 @@ export class UniversalStrategy<
     return [call];
   }
 
-  /**
-   * 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)
+  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 {
@@ -208,7 +213,7 @@ export class UniversalStrategy<
     });
     logger.verbose(`${this.metadata.name}::netAPY: vesu-pools: ${JSON.stringify(pools)}`);
     if (pools.some(p => !p)) {
-      throw new Error('Pool not found');
+      throw new Error(`Pool not found, available pools: ${allVesuPools.pools.length}, requiredPools: ${JSON.stringify(vesuAdapters.map(v => v.config.poolId))}`);
     };
     const positions = await this.getVesuPositions();
     logger.verbose(`${this.metadata.name}::netAPY: positions: ${JSON.stringify(positions)}`);
@@ -305,6 +310,100 @@ export class UniversalStrategy<
     return weightedSum / currentAUM.toNumber();
   }
 
+  /**
+   * 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(
+      `${this.getTag()}: 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(), 18);
+
+    // 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(), 18);
+
+    const blockBeforeInfo = await this.config.provider.getBlockWithTxs(
+      blockBefore
+    );
+
+    // Calculate assets per share
+    const assetsPerShareNow = amountNow
+      .multipliedBy(1e18)
+      .dividedBy(supplyNow.toString());
+
+    const assetsPerShareBf = amountBefore
+      .multipliedBy(1e18)
+      .dividedBy(supplyBefore.toString());
+
+    const timeDiffSeconds = blockNowTime - blockBeforeInfo.timestamp;
+
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsNow: ${amountNow.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsBefore: ${amountBefore.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsPerShareNow: ${assetsPerShareNow.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsPerShareBf: ${assetsPerShareBf.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] Supply before: ${supplyBefore.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] Supply now: ${supplyNow.toString()}`);
+    logger.verbose(`${this.getTag()} [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
@@ -337,7 +436,7 @@ export class UniversalStrategy<
     };
   }
 
-  protected async getVesuAUM(adapter: VesuAdapter) {
+  protected async getVesuAUM(adapter: VesuAdapter, _priceType?: LSTPriceType) {
     const legAUM = await adapter.getPositions(this.config);
     const underlying = this.asset();
     let vesuAum = Web3Number.fromWei("0", underlying.decimals);
@@ -370,7 +469,7 @@ export class UniversalStrategy<
     return prevAum;
   }
 
-  async getAUM(): Promise<{net: SingleTokenInfo, prevAum: Web3Number, splits: {id: string, aum: Web3Number}[]}> {
+  async getAUM(unrealizedAUM?: boolean): Promise<{net: SingleTokenInfo, prevAum: Web3Number, splits: {id: string, aum: Web3Number}[]}> {
     const prevAum = await this.getPrevAUM();
     const token1Price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
 
@@ -378,7 +477,9 @@ export class UniversalStrategy<
     const vesuAdapters = this.getVesuAdapters();
     let vesuAum = Web3Number.fromWei("0", this.asset().decimals);
     for (const adapter of vesuAdapters) {
-      vesuAum = vesuAum.plus(await this.getVesuAUM(adapter));
+      const priceType = unrealizedAUM ? LSTPriceType.ENDUR_PRICE : LSTPriceType.AVNU_PRICE;
+      const aumValue = await this.getVesuAUM(adapter, priceType);
+      vesuAum = vesuAum.plus(aumValue);
     }
 
     // account unused balance as aum as well (from vault allocator)
@@ -997,7 +1098,6 @@ export default function MetaVaultDescription(allowedSources: AllowedSources[]) {
   const containerStyle = {
     maxWidth: "800px",
     margin: "0 auto",
-    backgroundColor: "#111",
     color: "#eee",
     fontFamily: "Arial, sans-serif",
     borderRadius: "12px",
@@ -1024,7 +1124,6 @@ export default function MetaVaultDescription(allowedSources: AllowedSources[]) {
       <h1 style={{ fontSize: "18px", marginBottom: "10px" }}>Meta Vault — Automated Yield Router</h1>
       <p style={{ fontSize: "14px", lineHeight: "1.5", marginBottom: "16px" }}>
         This Evergreen vault is a tokenized Meta Vault, auto-compounding strategy that continuously allocates your deposited
-        asset to the best available yield source in the ecosystem. Depositors receive vault shares that
         represent a proportional claim on the underlying assets and accrued yield. Allocation shifts are
         handled programmatically based on on-chain signals and risk filters, minimizing idle capital and
         maximizing net APY.
@@ -1141,116 +1240,175 @@ const investmentSteps: string[] = [
 ]
 
 const AUDIT_URL = 'https://docs.troves.fi/p/security#starknet-vault-kit'
+
+// Helper to create common risk object
+const getUniversalRisk = () => ({
+    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 Universal strategy settings
+const createUniversalSettings = (
+    tokenSymbol: string,
+    maxTVLDecimals: number
+): StrategySettings => {
+    const isUSDT = tokenSymbol === "USDT";
+    return {
+        maxTVL: Web3Number.fromWei(0, maxTVLDecimals),
+        isAudited: true,
+        liveStatus: isUSDT ? StrategyLiveStatus.RETIRED : StrategyLiveStatus.ACTIVE,
+        isPaused: isUSDT,
+        isInstantWithdrawal: false,
+        hideHarvestInfo: true,
+        quoteToken: Global.getDefaultTokens().find(
+            (token) => token.symbol === tokenSymbol
+        )!,
+        alerts: [
+            {
+                tab: "withdraw" as const,
+                text: "On withdrawal, you will receive an NFT representing your withdrawal request. The funds will be automatically sent to your wallet (NFT owner) in 1-2 hours. You can monitor the status in transactions tab.",
+                type: "info" as const
+            }
+        ],
+        showWithdrawalWarningModal: true
+    };
+};
+
+const EVERGREEN_SECURITY = {
+  auditStatus: AuditStatus.AUDITED,
+  sourceCode: {
+    type: SourceCodeType.CLOSED_SOURCE,
+    contractLink: "https://github.com/trovesfi/troves-contracts",
+  },
+  accessControl: {
+    type: AccessControlType.STANDARD_ACCOUNT,
+    addresses: [ContractAddr.from("0x0")],
+    timeLock: "2 Days",
+  },
+};
+
+const EVERGREEN_REDEMPTION_INFO: RedemptionInfo = {
+  instantWithdrawalVault: InstantWithdrawalVault.NO,
+  redemptionsInfo: [{
+      title: "Typical Duration",
+      description: "1-2 hours"
+  }],
+  alerts: [{
+    type: 'info',
+    text: 'In cases of low liquidity, high slippages, the redemptions can take longer time. Redemption times are estimates and may vary based on network conditions and liquidity requirements.',
+    tab: 'withdraw'
+  }]
+};
+
+// Helper to create a Universal strategy
+const createUniversalStrategy = (params: {
+    tokenSymbol: string;
+    address: string;
+    vaultSettings: UniversalStrategySettings;
+    token1Symbol: string;
+    token2Symbol: string;
+    maxTVLDecimals: number;
+    allowedSources: AllowedSources[];
+    tags: StrategyTag[];
+}): IStrategyMetadata<UniversalStrategySettings> => {
+    const isUSDT = params.tokenSymbol === "USDT";
+    return {
+        id: `evergreen_${params.tokenSymbol.toLowerCase()}`,
+        name: `${params.tokenSymbol} Evergreen`,
+        description: getDescription(params.tokenSymbol, params.allowedSources),
+        address: ContractAddr.from(params.address),
+        launchBlock: 0,
+        type: "ERC4626" as const,
+        vaultType: {
+          type: VaultType.META_VAULT,
+          description: "Automatically allocates funds to the best available yield source in the ecosystem"
+        },
+        depositTokens: [
+            Global.getDefaultTokens().find((token) => token.symbol === params.tokenSymbol)!
+        ],
+        additionalInfo: getLooperSettings(
+            params.token1Symbol,
+            params.token2Symbol,
+            params.vaultSettings,
+            VesuPools.Genesis,
+            VesuPools.Genesis
+        ),
+        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"
+        },
+        settings: createUniversalSettings(params.tokenSymbol, params.maxTVLDecimals),
+        contractDetails: getContractDetails(params.vaultSettings),
+        faqs: getFAQs(),
+        investmentSteps: investmentSteps,
+        tags: params.tags,
+        security: EVERGREEN_SECURITY,
+        redemptionInfo: EVERGREEN_REDEMPTION_INFO,
+        discontinuationInfo: isUSDT ? {
+            info: "This strategy has been retired and is no longer accepting new deposits."
+        } : undefined,
+        usualTimeToEarnings: null,
+        usualTimeToEarningsDescription: null,
+    };
+};
+
 export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[] =
-  [
-    {
-      name: "USDC.e Evergreen",
-      description: getDescription('USDC.e', ['vesu', 'extended']),
-      address: ContractAddr.from('0x7e6498cf6a1bfc7e6fc89f1831865e2dacb9756def4ec4b031a9138788a3b5e'),
-      launchBlock: 0,
-      type: 'ERC4626',
-      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'USDC.e')!],
-      additionalInfo: getLooperSettings('USDC.e', '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)
-      },
-      auditUrl: AUDIT_URL,
-      protocols: [Protocols.VESU],
-      maxTVL: Web3Number.fromWei(0, 6),
-      contractDetails: getContractDetails(usdcVaultSettings),
-      faqs: getFAQs(),
-      investmentSteps: investmentSteps,
-    },
-    {
-      name: "WBTC Evergreen",
-      description: getDescription('WBTC', ['vesu', 'endur', 'extended']),
-      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: getContractDetails(wbtcVaultSettings),
-      faqs: getFAQs(),
-      investmentSteps: investmentSteps,
-      auditUrl: AUDIT_URL,
-    },
-    {
-      name: "ETH Evergreen",
-      description: getDescription('ETH', ['vesu', 'extended']),
-      address: ContractAddr.from('0x446c22d4d3f5cb52b4950ba832ba1df99464c6673a37c092b1d9622650dbd8'),
-      launchBlock: 0,
-      type: 'ERC4626',
-      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'ETH')!],
-      additionalInfo: getLooperSettings('ETH', 'WBTC', ethVaultSettings, 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, 18),
-      contractDetails: getContractDetails(ethVaultSettings),
-      faqs: getFAQs(),
-      investmentSteps: investmentSteps,
-      auditUrl: AUDIT_URL,
-    },
-    {
-      name: "STRK Evergreen",
-      description: getDescription('STRK', ['vesu', 'endur', 'extended']),
-      address: ContractAddr.from('0x55d012f57e58c96e0a5c7ebbe55853989d01e6538b15a95e7178aca4af05c21'),
-      launchBlock: 0,
-      type: 'ERC4626',
-      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'STRK')!],
-      additionalInfo: getLooperSettings('STRK', 'ETH', strkVaultSettings, 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, 18),
-      contractDetails: getContractDetails(strkVaultSettings),
-      faqs: getFAQs(),
-      investmentSteps: investmentSteps,
-      auditUrl: AUDIT_URL,
-    },
-    {
-      name: "USDT Evergreen",
-      description: getDescription('USDT', ['vesu']),
-      address: ContractAddr.from('0x1c4933d1880c6778585e597154eaca7b428579d72f3aae425ad2e4d26c6bb3'),
-      launchBlock: 0,
-      type: 'ERC4626',
-      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'USDT')!],
-      additionalInfo: getLooperSettings('USDT', 'ETH', usdtVaultSettings, 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: getContractDetails(usdtVaultSettings),
-      faqs: getFAQs(),
-      investmentSteps: investmentSteps,
-      auditUrl: AUDIT_URL,
-    }
-  ]
+[
+    createUniversalStrategy({
+        tokenSymbol: "USDC.e",
+        address: "0x7e6498cf6a1bfc7e6fc89f1831865e2dacb9756def4ec4b031a9138788a3b5e",
+        vaultSettings: usdcVaultSettings,
+        token1Symbol: "USDC.e",
+        token2Symbol: "ETH",
+        maxTVLDecimals: 6,
+        allowedSources: ["vesu", "extended"],
+        tags: [StrategyTag.META_VAULT]
+    }),
+    createUniversalStrategy({
+        tokenSymbol: "WBTC",
+        address: "0x5a4c1651b913aa2ea7afd9024911603152a19058624c3e425405370d62bf80c",
+        vaultSettings: wbtcVaultSettings,
+        token1Symbol: "WBTC",
+        token2Symbol: "ETH",
+        maxTVLDecimals: 8,
+        allowedSources: ["vesu", "endur", "extended"],
+        tags: [StrategyTag.BTC, StrategyTag.META_VAULT]
+    }),
+    createUniversalStrategy({
+        tokenSymbol: "ETH",
+        address: "0x446c22d4d3f5cb52b4950ba832ba1df99464c6673a37c092b1d9622650dbd8",
+        vaultSettings: ethVaultSettings,
+        token1Symbol: "ETH",
+        token2Symbol: "WBTC",
+        maxTVLDecimals: 18,
+        allowedSources: ["vesu", "extended"],
+        tags: [StrategyTag.META_VAULT]
+    }),
+    createUniversalStrategy({
+        tokenSymbol: "STRK",
+        address: "0x55d012f57e58c96e0a5c7ebbe55853989d01e6538b15a95e7178aca4af05c21",
+        vaultSettings: strkVaultSettings,
+        token1Symbol: "STRK",
+        token2Symbol: "ETH",
+        maxTVLDecimals: 18,
+        allowedSources: ["vesu", "endur", "extended"],
+        tags: [StrategyTag.META_VAULT]
+    }),
+    createUniversalStrategy({
+        tokenSymbol: "USDT",
+        address: "0x1c4933d1880c6778585e597154eaca7b428579d72f3aae425ad2e4d26c6bb3",
+        vaultSettings: usdtVaultSettings,
+        token1Symbol: "USDT",
+        token2Symbol: "ETH",
+        maxTVLDecimals: 6,
+        allowedSources: ["vesu"],
+        tags: [StrategyTag.META_VAULT]
+    })
+];