@strkfarm/sdk 1.2.0 → 2.0.0-dca.1

package/src/strategies/sensei.ts

@@ -1,7 +1,7 @@
-import { getNoRiskTags, highlightTextWithLinks, IConfig, IProtocol, IStrategyMetadata, RiskFactor, RiskType, TokenInfo } from "@/interfaces";
+import { getNoRiskTags, highlightTextWithLinks, IConfig, IProtocol, IStrategyMetadata, RiskFactor, RiskType, StrategyTag, TokenInfo, AuditStatus, SourceCodeType, AccessControlType, InstantWithdrawalVault, StrategyLiveStatus, VaultType } from "@/interfaces";
 import { BaseStrategy, SingleActionAmount, SingleTokenInfo } 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 +9,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 +41,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,
@@ -144,23 +158,42 @@ export class SenseiVault extends BaseStrategy<
       throw new Error('No positions found');
     }
 
-    const collateralXSTRK = Web3Number.fromWei(
+    let collateralXSTRK = Web3Number.fromWei(
       data.data[0].collateral.value,
       data.data[0].collateral.decimals,
     );
-    const collateralUSDValue = Web3Number.fromWei(
+    let collateralUSDValue = Web3Number.fromWei(
       data.data[0].collateral.usdPrice.value,
       data.data[0].collateral.usdPrice.decimals,
     );
-    const debtSTRK = Web3Number.fromWei(
+    let debtSTRK = Web3Number.fromWei(
       data.data[0].debt.value,
       data.data[0].debt.decimals,
     );
-    const debtUSDValue = Web3Number.fromWei(
+    let debtUSDValue = Web3Number.fromWei(
       data.data[0].debt.usdPrice.value,
       data.data[0].debt.usdPrice.decimals,
     );
 
+    if (data.data[1]) {
+      collateralXSTRK = collateralXSTRK.plus(Web3Number.fromWei(
+        data.data[1].collateral.value,
+        data.data[1].collateral.decimals,
+      ));
+      collateralUSDValue = collateralUSDValue.plus(Web3Number.fromWei(
+        data.data[1].collateral.usdPrice.value,
+        data.data[1].collateral.usdPrice.decimals,
+      ));
+      debtSTRK = debtSTRK.plus(Web3Number.fromWei(
+        data.data[1].debt.value,
+        data.data[1].debt.decimals,
+      ));
+      debtUSDValue = debtUSDValue.plus(Web3Number.fromWei(
+        data.data[1].debt.usdPrice.value,
+        data.data[1].debt.usdPrice.decimals,
+      ));
+    }
+
     const xSTRKPrice = await this.getSecondaryTokenPriceRelativeToMain();
     const collateralInSTRK =
       Number(collateralXSTRK.toFixed(6)) * xSTRKPrice;
@@ -189,10 +222,11 @@ export class SenseiVault extends BaseStrategy<
     const existingCacheData = this.getCache<number>(CACHE_KEY);
     if (existingCacheData) return existingCacheData;
     
+    let AMOUNT = 100;
     const params: QuoteRequest = {
       sellTokenAddress: this.metadata.additionalInfo.secondaryToken.address.address,
       buyTokenAddress: this.metadata.additionalInfo.mainToken.address.address,
-      sellAmount: BigInt(new Web3Number('1', 18).toWei()),
+      sellAmount: BigInt(new Web3Number(AMOUNT.toString(), 18).toWei()),
       takerAddress: this.address.address,
     };
     logger.verbose('getSecondaryTokenPriceRelativeToMain [1]', params);
@@ -212,7 +246,7 @@ export class SenseiVault extends BaseStrategy<
       Web3Number.fromWei(firstQuote.buyAmount.toString(), 18).toFixed(
         6,
       ),
-    );
+    ) / AMOUNT;
     logger.verbose('getSecondaryTokenPriceRelativeToMain [2]', price);
     this.setCache(CACHE_KEY, price); // cache for 1 min
     return price;
@@ -223,6 +257,268 @@ 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;
+    */
+  }
     
 }
 
@@ -289,9 +585,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 +605,37 @@ export const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[] =
       ),
       launchBlock: 1053811,
       type: "Other",
+      curator: {
+        name: "Unwrap Labs",
+        logo: "https://assets.troves.fi/integrations/unwraplabs/white.png"
+      },
+      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: {
+        maxTVL: new Web3Number("1500000", 18),
+        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.ACTIVE,
+        isPaused: false,
+        isInMaintenance: false,
+        isAudited: false,
+        isInstantWithdrawal: true,
+        isTransactionHistDisabled: true,
+        quoteToken: Global.getDefaultTokens().find(
+            (t) => t.symbol === "STRK"
+        )!
+    },
       risk: {
         riskFactor: _riskFactor,
         netRisk:
@@ -335,6 +658,31 @@ 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.STANDARD_ACCOUNT,
+          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 hours. 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.",
+      }]
     },
-  ];
+  ];

package/src/strategies/types.ts

@@ -0,0 +1,4 @@
+export enum LSTPriceType {
+  ENDUR_PRICE = 'ENDUR_PRICE',
+  AVNU_PRICE = 'AVNU_PRICE'
+}

package/src/strategies/universal-adapters/vesu-adapter.ts

@@ -234,6 +234,25 @@ export const VesuPools = {
   Re7xSTRK: ContractAddr.from('0x052fb52363939c3aa848f8f4ac28f0a51379f8d1b971d8444de25fbd77d8f161'),
   Re7xBTC: ContractAddr.from('0x3a8416bf20d036df5b1cf3447630a2e1cb04685f6b0c3a70ed7fb1473548ecf'),
   Prime: ContractAddr.from('0x451fe483d5921a2919ddd81d0de6696669bccdacd859f72a4fba7656b97c3b5'),
+  Re7STRK: ContractAddr.from('0x01fcdacc1d8184eca7b472b5acbaf1500cec9d5683ca95fede8128b46c8f9cc2'),
+}
+
+export const VesuPoolMetadata = {
+  [VesuPools.Genesis.address]: {
+    name: 'Genesis',
+  },
+  [VesuPools.Re7xSTRK.address]: {
+    name: 'Re7 xSTRK',
+  },
+  [VesuPools.Re7xBTC.address]: {
+    name: 'Re7 xBTC',
+  },
+  [VesuPools.Prime.address]: {
+    name: 'Prime',
+  },
+  [VesuPools.Re7STRK.address]: {
+    name: 'Re7 STRK',
+  },
 }
 
 export const extensionMap: {[key: string]: ContractAddr} = {};
@@ -418,14 +437,14 @@ export class VesuAdapter extends BaseAdapter {
     }
   }
 
-  getVesuModifyDelegationAdapter = (id: string): LeafAdapterFn<VesuModifyDelegationCallParams> => {
+  getVesuModifyDelegationAdapter = (id: string, delegatee: ContractAddr): LeafAdapterFn<VesuModifyDelegationCallParams> => {
     return () => {
       const { addr: VESU_SINGLETON, isV2 } = getVesuSingletonAddress(this.config.poolId);
       const packedArguments: bigint[] = isV2 ? [
-        toBigInt(this.VESU_MULTIPLY.toString()), // v2
+        toBigInt(delegatee.toString()), // v2
       ] : [
         this.config.poolId.toBigInt(),
-        toBigInt(this.VESU_MULTIPLY_V1.toString()), // v1
+        toBigInt(delegatee.toString()), // v1
       ];
       const output = this.constructSimpleLeafData({
         id: id,
@@ -434,29 +453,31 @@ export class VesuAdapter extends BaseAdapter {
         packedArguments
       }, isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS);
 
-      return { leaf: output, callConstructor: this.getVesuModifyDelegationCall.bind(this) };
+      return { leaf: output, callConstructor: this.getVesuModifyDelegationCall(delegatee).bind(this) };
     }
   }
 
-  getVesuModifyDelegationCall = (params: VesuModifyDelegationCallParams): ManageCall => {
-    const VESU_SINGLETON = getVesuSingletonAddress(this.config.poolId).addr;
-    const { contract, isV2 } = this.getVesuSingletonContract(getMainnetConfig(), this.config.poolId);
-    const call = contract.populate('modify_delegation', isV2 ? {
-      delegatee: this.VESU_MULTIPLY.toBigInt(),
-      delegation: params.delegation,
-    } : {
-      pool_id: this.config.poolId.toBigInt(),
-      delegatee: this.VESU_MULTIPLY_V1.toBigInt(),
-      delegation: params.delegation,
-    });
-    return {
-      sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
-      call: {
-        contractAddress: VESU_SINGLETON,
-        selector: hash.getSelectorFromName('modify_delegation'),
-        calldata: [
-          ...call.calldata as bigint[]
-        ]
+  getVesuModifyDelegationCall = (delegatee: ContractAddr) => {
+    return (params: VesuModifyDelegationCallParams) => {
+      const VESU_SINGLETON = getVesuSingletonAddress(this.config.poolId).addr;
+      const { contract, isV2 } = this.getVesuSingletonContract(getMainnetConfig(), this.config.poolId);
+      const call = contract.populate('modify_delegation', isV2 ? {
+        delegatee: delegatee.toBigInt(),
+        delegation: params.delegation,
+      } : {
+        pool_id: this.config.poolId.toBigInt(),
+        delegatee: delegatee.toBigInt(),
+        delegation: params.delegation,
+      });
+      return {
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
+        call: {
+          contractAddress: VESU_SINGLETON,
+          selector: hash.getSelectorFromName('modify_delegation'),
+          calldata: [
+            ...call.calldata as bigint[]
+          ]
+        }
       }
     }
   }
@@ -654,12 +675,12 @@ export class VesuAdapter extends BaseAdapter {
       amount: collateralAmount,
       token: this.config.collateral,
       usdValue: collateralAmount.multipliedBy(token1Price.price).toNumber(),
-      remarks: "Collateral"
+      remarks: `Collateral - ${VesuPoolMetadata[this.config.poolId.address].name} pool`
     }, {
       amount: debtAmount,
       token: this.config.debt,
       usdValue: debtAmount.multipliedBy(token2Price.price).toNumber(),
-      remarks: "Debt"
+      remarks: `Debt - ${VesuPoolMetadata[this.config.poolId.address].name} pool`
     }];
     this.setCache(CACHE_KEY, value, 60000); // ttl: 1min
     return value;
@@ -747,7 +768,7 @@ export class VesuAdapter extends BaseAdapter {
       let pools: any[] = [];
       try {
         const data = await getAPIUsingHeadlessBrowser(
-          `${ENDPOINTS.VESU_BASE_STAGING}/pools`
+          `${ENDPOINTS.VESU_BASE}/pools`
         );
         pools = data.data;
 
@@ -893,4 +914,4 @@ export class VesuAdapter extends BaseAdapter {
     }
     throw new Error('Max utilization not found');
   }
-}
+}