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

package/src/strategies/sensei.ts

@@ -1,7 +1,13 @@
-import { getNoRiskTags, highlightTextWithLinks, IConfig, IProtocol, IStrategyMetadata, RiskFactor, RiskType, TokenInfo } from "@/interfaces";
-import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
+import { getNoRiskTags, highlightTextWithLinks, IConfig, IProtocol, IStrategyMetadata, RiskFactor, RiskType, StrategyTag, TokenInfo, AuditStatus, SourceCodeType, AccessControlType, InstantWithdrawalVault, StrategyLiveStatus, VaultType, UnwrapLabsCurator } from "@/interfaces";
+import {
+  BaseStrategy,
+  SingleActionAmount,
+  SingleTokenInfo,
+  UserPositionCard,
+  UserPositionCardsInput,
+} from "./base-strategy";
 import { ContractAddr, Web3Number } from "@/dataTypes";
-import { Call, Contract, uint256 } from "starknet";
+import { Call, Contract, num, uint256, BlockIdentifier } from "starknet";
 import SenseiABI from "@/data/sensei.abi.json";
 import { getTrovesEndpoint, logger } from "@/utils";
 import { Global } from "@/global";
@@ -9,6 +15,10 @@ import { QuoteRequest } from "@avnu/avnu-sdk";
 import { PricerBase } from "@/modules/pricerBase";
 import ERC20ABI from "@/data/erc20.abi.json";
 import { AvnuWrapper } from "@/modules";
+import { gql } from "@apollo/client";
+import apolloClient from "@/modules/apollo-client";
+import { VesuAdapter, VesuPools } from "./universal-adapters/vesu-adapter";
+import { LSTAPRService } from "@/modules/lst-apr";
 
 export interface SenseiVaultSettings {
   mainToken: TokenInfo;
@@ -37,17 +47,27 @@ export class SenseiVault extends BaseStrategy<
     }
   }
 
-  async getUserTVL(user: ContractAddr): Promise<SingleTokenInfo> {
+  async getUserTVL(user: ContractAddr, blockIdentifier: BlockIdentifier = "latest"): Promise<SingleTokenInfo> {
     const result: any = await this.contract.call(
       "describe_position",
       [user.address],
+      {
+        blockIdentifier,
+      }
     );
     const amount = Web3Number.fromWei(
       uint256.uint256ToBN(result[1].estimated_size).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;
+    
     const price = await this.pricer.getPrice(
       this.metadata.depositTokens[0].symbol,
+      blockNumber
     );
     return {
       usdValue: Number(amount.toFixed(6)) * price.price,
@@ -80,7 +100,7 @@ export class SenseiVault extends BaseStrategy<
         tokenInfo: this.metadata.depositTokens[0],
       };
     } catch (error) {
-      console.error('Error fetching TVL:', error);
+      console.error(`[SDK] Error fetching TVL for ${this.metadata.id}:`, error);
       return {
         usdValue: 0,
         amount: new Web3Number('0', this.metadata.depositTokens[0].decimals),
@@ -108,7 +128,7 @@ export class SenseiVault extends BaseStrategy<
     return calls;
   }
 
-  async withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]> {
+  async withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr, _isMaxWithdraw: boolean = false): Promise<Call[]> {
     const call = this.contract.populate('withdraw', [
       uint256.bnToUint256(amountInfo.amount.toWei()),
       receiver.address,
@@ -223,7 +243,272 @@ export class SenseiVault extends BaseStrategy<
     logger.verbose('getSettings', settings);
     return settings;
   };
+
+  /**
+   * Calculate lifetime earnings for a user
+   * Not yet implemented for Sensei Vault strategy
+   */
+  getLifetimeEarnings(
+    userTVL: SingleTokenInfo,
+    investmentFlows: Array<{ amount: string; type: string; timestamp: number; tx_hash: string }>
+  ): any {
+    throw new Error("getLifetimeEarnings is not implemented yet for this strategy");
+  }
+
+  async netAPY(): Promise<number> {
+    try {
+      // Fetch Vesu pools and select the Re7 xSTRK pool
+      const { pools } = await VesuAdapter.getVesuPools();
+      const re7PoolId = VesuPools.Re7xSTRK;
+      const pool = pools.find((p: any) =>
+        ContractAddr.from(num.getHexString(p.id)).eq(re7PoolId),
+      );
+
+      if (!pool) {
+        logger.warn(`${SenseiVault.name}::netAPY - Re7 xSTRK pool not found`);
+        return 0;
+      }
+
+      const mainSymbol = this.metadata.additionalInfo.mainToken.symbol.toLowerCase(); // STRK
+      const secondarySymbol =
+        this.metadata.additionalInfo.secondaryToken.symbol.toLowerCase(); // xSTRK
+
+      const collateralAssetStats = pool.assets.find(
+        (a: any) => String(a.symbol).toLowerCase() === secondarySymbol,
+      )?.stats;
+      const debtAssetStats = pool.assets.find(
+        (a: any) => String(a.symbol).toLowerCase() === mainSymbol,
+      )?.stats;
+
+      if (!collateralAssetStats || !debtAssetStats) {
+        logger.warn(
+          `${SenseiVault.name}::netAPY - Missing collateral/debt stats on Vesu pool`,
+        );
+        return 0;
+      }
+
+      // Base xSTRK lending APY from Vesu
+      const xstrkSupplyAPY =
+        Number(collateralAssetStats.supplyApy?.value || 0) / 1e18;
+
+      // STRK rewards APR on xSTRK collateral from Vesu
+      const strkRewardsAPR = collateralAssetStats.defiSpringSupplyApr
+        ? Number(collateralAssetStats.defiSpringSupplyApr.value || 0) / 1e18
+        : 0;
+
+      // STRK borrow APY from Vesu
+      const borrowAPY =
+        Number(debtAssetStats.borrowApr?.value || 0) / 1e18;
+
+      // LST APR for xSTRK from Endur (based on underlying STRK asset)
+      const lstAPY = await LSTAPRService.getLSTAPR(
+        this.metadata.additionalInfo.mainToken.address,
+      );
+
+      // Collateral APY = Vesu xSTRK supply + Endur xSTRK APR + STRK rewards
+      const collateralAPY = xstrkSupplyAPY + lstAPY + strkRewardsAPR;
+
+      const feeFactor = this.metadata.additionalInfo.feeBps / 10000; // convert bps to decimal
+      const feeAdjustedColAPY =
+        collateralAPY - strkRewardsAPR * feeFactor;
+
+      // Position info (collateral & debt in USD terms)
+      const { collateralUSDValue, debtUSDValue } =
+        await this.getPositionInfo();
+
+      const collateralUSD = Number(collateralUSDValue.toFixed(6));
+      const debtUSD = Number(debtUSDValue.toFixed(6));
+
+      // Compute expected leverage using the same math as app-side strategy
+      const targetHf = this.metadata.additionalInfo.targetHfBps / 10000;
+      const xSTRKPrice = await this.getSecondaryTokenPriceRelativeToMain();
+      const denominator = targetHf * xSTRKPrice - 0.87;
+      if (denominator <= 0) {
+        logger.warn(
+          `${SenseiVault.name}::netAPY - Invalid denominator in leverage calc`,
+        );
+        return 0;
+      }
+      const borrowedSTRK = (0.87 * xSTRKPrice) / denominator;
+      const expectedLeverage = 1 + borrowedSTRK;
+      if (!Number.isFinite(expectedLeverage) || expectedLeverage <= 0) {
+        logger.warn(
+          `${SenseiVault.name}::netAPY - Non-positive or invalid expectedLeverage`,
+        );
+        return 0;
+      }
+
+      const payoff =
+        collateralUSD * feeAdjustedColAPY - debtUSD * borrowAPY;
+      const investment = collateralUSD - debtUSD;
+
+      if (investment === 0) {
+        return 0;
+      }
+
+      const netAPY = payoff / investment;
+      return Number.isFinite(netAPY) ? netAPY : 0;
+    } catch (error) {
+      logger.error(`${SenseiVault.name}::netAPY - Error`, error);
+      return 0;
+    }
+  }
+
+  /**
+   * Calculates user realized APY based on position growth accounting for deposits and withdrawals.
+   * Returns the APY as a number.
+   * Not implemented for Sensei Strategy yet.
+   */
+  async getUserRealizedAPY(
+    blockIdentifier: BlockIdentifier = "latest",
+    sinceBlocks = 600000
+  ): Promise<number> {
+    throw new Error("getUserRealizedAPY not implemented yet for Sensei strategy");
     
+    /* 
+    logger.verbose(
+      `${SenseiVault.name}: getUserRealizedAPY => starting with userAddress=${userAddress.address}, blockIdentifier=${blockIdentifier}, sinceBlocks=${sinceBlocks}`
+    );
+
+    // Determine current block number
+    let blockNow =
+      typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint"
+        ? Number(blockIdentifier)
+        : (await this.config.provider.getBlockLatestAccepted()).block_number;
+
+    // Look back window, but never before launch block
+    const blockBefore = Math.max(
+      blockNow - sinceBlocks,
+      this.metadata.launchBlock
+    );
+
+    logger.verbose(
+      `${SenseiVault.name}: getUserRealizedAPY => blockNow=${blockNow}, blockBefore=${blockBefore}`
+    );
+
+    // Get current estimated size
+    const currentResult: any = await this.contract.call(
+      "describe_position",
+      [userAddress.address],
+      {
+        blockIdentifier,
+      }
+    );
+    const currentEstimatedSize = Web3Number.fromWei(
+      uint256.uint256ToBN(currentResult[1].estimated_size).toString(),
+      this.metadata.depositTokens[0].decimals,
+    );
+
+    // Get previous estimated size
+    const previousResult: any = await this.contract.call(
+      "describe_position",
+      [userAddress.address],
+      {
+        blockIdentifier: blockBefore,
+      }
+    );
+    const previousEstimatedSize = Web3Number.fromWei(
+      uint256.uint256ToBN(previousResult[1].estimated_size).toString(),
+      this.metadata.depositTokens[0].decimals,
+    );
+
+    logger.verbose(
+      `${SenseiVault.name}: getUserRealizedAPY => currentEstimatedSize=${currentEstimatedSize.toString()}, previousEstimatedSize=${previousEstimatedSize.toString()}`
+    );
+
+    // Query GraphQL for deposits and withdrawals between blockBefore and blockNow
+    let newDeposits = Web3Number.fromWei("0", this.metadata.depositTokens[0].decimals);
+    let newWithdrawals = Web3Number.fromWei("0", this.metadata.depositTokens[0].decimals);
+
+    try {
+      const { data } = await apolloClient.query({
+        query: gql`
+          query Query($where: Investment_flowsWhereInput) {
+            findManyInvestment_flows(where: $where) {
+              block_number
+              amount
+              type
+            }
+          }
+        `,
+        variables: {
+          where: {
+            contract: {
+              equals: this.address.address.toLowerCase(),
+            },
+            owner: {
+              equals: userAddress.address.toLowerCase(),
+            },
+            block_number: {
+              gte: blockBefore,
+              lte: blockNow,
+            },
+          },
+        },
+        fetchPolicy: 'no-cache',
+      });
+
+      // Sum deposits and withdrawals
+      for (const flow of data.findManyInvestment_flows) {
+        const amount = Web3Number.fromWei(
+          flow.amount,
+          this.metadata.depositTokens[0].decimals
+        );
+        if (flow.type === 'deposit') {
+          newDeposits = newDeposits.plus(amount);
+        } else if (flow.type === 'withdraw') {
+          newWithdrawals = newWithdrawals.plus(amount);
+        }
+      }
+
+      logger.verbose(
+        `${SenseiVault.name}: getUserRealizedAPY => newDeposits=${newDeposits.toString()}, newWithdrawals=${newWithdrawals.toString()}`
+      );
+    } catch (error) {
+      logger.verbose(
+        `${SenseiVault.name}: getUserRealizedAPY => Error querying GraphQL, continuing with zero deposits/withdrawals:`,
+        error
+      );
+      // Continue with zero deposits/withdrawals if GraphQL query fails
+    }
+
+    // Calculate growth: Current estimated size - new deposits + new withdrawals - previous estimated size
+    const growth = currentEstimatedSize
+      .minus(newDeposits)
+      .plus(newWithdrawals)
+      .minus(previousEstimatedSize);
+
+    logger.verbose(
+      `${SenseiVault.name}: getUserRealizedAPY => growth=${growth.toString()}`
+    );
+
+    // Handle edge case where previous position is zero
+    if (previousEstimatedSize.isZero() || previousEstimatedSize.lte(0)) {
+      logger.verbose(
+        `${SenseiVault.name}: getUserRealizedAPY => Previous position is zero, returning 0`
+      );
+      return 0;
+    }
+
+    // Calculate actual block difference (in case limited by launch block)
+    const actualBlockDiff = blockNow - blockBefore;
+
+    // Calculate APY: 100 * 365/n * growth / previousEstimatedSize
+    // where n is the number of blocks (sinceBlocks or actual block difference)
+    const growthRatio = growth.dividedBy(previousEstimatedSize);
+    const apy = Number(growthRatio) * 100 * 365 / actualBlockDiff;
+
+    logger.verbose(
+      `${SenseiVault.name}: getUserRealizedAPY => actualBlockDiff=${actualBlockDiff}, growthRatio=${Number(growthRatio)}, apy=${apy}`
+    );
+
+    return apy;
+    */
+  }
+
+  async getUserPositionCards(_input: UserPositionCardsInput): Promise<UserPositionCard[]> {
+    return [];
+  }
 }
 
 const senseiDescription = `Deposit your {{token1}} to automatically loop your funds via Endur ({{token2}}) and Vesu to create a delta neutral position. This strategy is designed to maximize your yield on {{token1}}. Your position is automatically adjusted periodically to maintain a healthy health factor. You receive a NFT as representation for your stake on Troves. You can withdraw anytime by redeeming your NFT for {{token1}}.`;
@@ -289,9 +574,10 @@ const FAQS = [
 export const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[] =
   [
     {
+      id: "xstrk_sensei",
       name: "xSTRK Sensei",
       description: highlightTextWithLinks(
-        senseiDescription.replaceAll('{{token1}}', 'STRK').replaceAll('{{token2}}', 'xSTRK'),
+        senseiDescription.replace('{{token1}}', 'STRK').replace('{{token2}}', 'xSTRK'),
         [{
           highlight: "Endur",
           link: "https://endur.fi"
@@ -308,11 +594,33 @@ export const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[] =
       ),
       launchBlock: 1053811,
       type: "Other",
+      curator: UnwrapLabsCurator,
+      vaultType: {
+        type: VaultType.LOOPING,
+        description: "Creates leveraged looping position on xSTRK by borrowing STRK to increase yield"
+      },
       depositTokens: [
         Global.getDefaultTokens().find((t) => t.symbol === "STRK")!
       ],
       protocols: [endurProtocol, vesuProtocol],
-      maxTVL: new Web3Number("1500000", 18),
+      settings: {
+        alerts: [
+            {
+                type: "info",
+                text: "Depeg-risk: If xSTRK price on DEXes deviates from expected price, you may lose money or may have to wait for the price to recover.",
+                tab: "all"
+            }
+        ],
+        liveStatus: StrategyLiveStatus.RETIRED,
+        isPaused: false,
+        isInMaintenance: false,
+        isAudited: false,
+        isInstantWithdrawal: true,
+        isTransactionHistDisabled: true,
+        quoteToken: Global.getDefaultTokens().find(
+            (t) => t.symbol === "STRK"
+        )!
+    },
       risk: {
         riskFactor: _riskFactor,
         netRisk:
@@ -335,6 +643,42 @@ export const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[] =
         "Buy more xSTRK with borrowed STRK",
         "Repeat the process to loop your position",
         "Claim DeFi spring (STRK) rewards weekly and reinvest",
-      ]
+      ],
+      tags: [StrategyTag.LEVERED],
+      security: {
+        auditStatus: AuditStatus.AUDITED,
+        sourceCode: {
+          type: SourceCodeType.CLOSED_SOURCE,
+          contractLink: "https://github.com/trovesfi/troves-contracts",
+        },
+        accessControl: {
+          type: AccessControlType.ROLE_BASED_ACCESS,
+          addresses: [ContractAddr.from("0x0")],
+          timeLock: "2 Days",
+        },
+      },
+      redemptionInfo: {
+        instantWithdrawalVault: InstantWithdrawalVault.YES,
+        redemptionsInfo: [],
+        alerts: [],
+      },
+      usualTimeToEarnings: "2 weeks",
+      usualTimeToEarningsDescription: "Strategy returns depend on LST price on DEXes. Even though the true price of LST on Endur increases continuously, the DEX price may lag sometimes, and historically is seen to rebase at least once every 2 weeks. This is when you realise your earnings.",
+      points: [{
+        multiplier: 4,
+        logo: 'https://endur.fi/favicon.ico',
+        toolTip: "This strategy holds xSTRK. Earn 3-4x Endur points on your xSTRK due to the leverage. Points can be found on endur.fi.",
+      }],
+      discontinuationInfo: {
+        info: highlightTextWithLinks(
+          "This strategy is retired. All funds have been moved to Hyper xSTRK.",
+          [
+            {
+              highlight: "Hyper xSTRK",
+              link: "/strategy/hyper_xstrk",
+            },
+          ]
+        ),
+      },
     },
-  ];
+  ];