@strkfarm/sdk 2.0.0-dev.27 → 2.0.0-dev.28

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,
@@ -223,6 +237,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 +565,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 +585,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 +638,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/svk-strategy.ts

@@ -3,7 +3,7 @@ import { IConfig, IStrategyMetadata, TokenInfo, VaultPosition } from "@/interfac
 import { PricerBase } from "@/modules/pricerBase";
 import { ERC20 } from "@/modules";
 import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
-import { Call, Contract, num } from "starknet";
+import { Call, Contract, num, uint256 } from "starknet";
 import { assert, LeafData, logger, StandardMerkleTree } from "@/utils";
 import { UniversalStrategySettings } from "./universal-strategy";
 import { UNIVERSAL_MANAGE_IDS } from "./universal-strategy";
@@ -15,9 +15,9 @@ import { ManageCall, PositionInfo } from "./universal-adapters";
  * Base class for all SVK (Starknet Vault Kit) strategies.
  * Contains common functions that are shared across all SVK strategies.
  */
-export abstract class SVKStrategy<S extends UniversalStrategySettings> 
+export abstract class SVKStrategy<S extends UniversalStrategySettings>
   extends BaseStrategy<SingleTokenInfo, SingleActionAmount> {
-  
+
   /** Contract address of the strategy */
   readonly address: ContractAddr;
   /** Pricer instance for token price calculations */
@@ -36,13 +36,13 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
     this.pricer = pricer;
     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,
@@ -57,14 +57,51 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
     return this.metadata.depositTokens[0];
   }
 
+  async depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]> {
+    // Technically its not erc4626 abi, but we just need approve call
+    // so, its ok to use it
+    assert(
+      amountInfo.tokenInfo.address.eq(this.asset().address),
+      "Deposit token mismatch"
+    );
+    const assetContract = new Contract({
+      abi: UniversalVaultAbi,
+      address: this.asset().address.address,
+      providerOrAccount: this.config.provider
+    });
+    const call1 = assetContract.populate("approve", [
+      this.address.address,
+      uint256.bnToUint256(amountInfo.amount.toWei())
+    ]);
+    const call2 = this.contract.populate("deposit", [
+      uint256.bnToUint256(amountInfo.amount.toWei()),
+      receiver.address
+    ]);
+    return [call1, call2];
+  }
+
+  async withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]> {
+    assert(
+      amountInfo.tokenInfo.address.eq(this.asset().address),
+      "Withdraw token mismatch"
+    );
+    const shares = await this.contract.call('convert_to_shares', [uint256.bnToUint256(amountInfo.amount.toWei())]);
+    const call = this.contract.populate("request_redeem", [
+      uint256.bnToUint256(shares.toString()),
+      receiver.address,
+      owner.address
+    ]);
+    return [call];
+  }
+
   /**
    * Returns the unused balance in the vault allocator.
    * Note: This function is common for any SVK strategy.
    */
   async getUnusedBalance(): Promise<SingleTokenInfo> {
     const balance = await (new ERC20(this.config)).balanceOf(
-      this.asset().address, 
-      this.metadata.additionalInfo.vaultAllocator, 
+      this.asset().address,
+      this.metadata.additionalInfo.vaultAllocator,
       this.asset().decimals
     );
     const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
@@ -76,6 +113,23 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
     };
   }
 
+  /**
+    * Builds a manage call from an adapter's proof tree.
+    * DRY helper for the repeated getProofs → getManageCall pattern.
+    */
+  protected async buildManageCallFromAdapter(
+    adapter: { getProofs: (isDeposit: boolean, tree: any) => any },
+    isDeposit: boolean,
+    amount: Web3Number,
+  ): Promise<Call> {
+    const proofsInfo = adapter.getProofs(isDeposit, this.getMerkleTree());
+    const manageCalls = await proofsInfo.callConstructor({ amount });
+    return this.getManageCall(
+      this.getProofGroupsForManageCalls(manageCalls),
+      manageCalls,
+    );
+  }
+
   /**
    * Bridges liquidity from the vault allocator back to the vault.
    * Note: This function is common for any SVK strategy.
@@ -85,37 +139,54 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
     const approveAdapter = this.metadata.additionalInfo.leafAdapters.find(
       adapter => adapter().leaves.find(leaf => leaf.readableId === UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY)
     );
-    
+
     if (!approveAdapter) {
       throw new Error(`${this.getTag()}::getBringLiquidityCall: approve adapter not found`);
     }
-    
+
     // Find bring liquidity leaf adapter
     const bringLiquidityAdapter = this.metadata.additionalInfo.leafAdapters.find(
       adapter => adapter().leaves.find(leaf => leaf.readableId === UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY)
     );
-    
+
     if (!bringLiquidityAdapter) {
       throw new Error(`${this.getTag()}::getBringLiquidityCall: bring liquidity adapter not found`);
     }
-    
-    // Get proofs
-    const tree = this.getMerkleTree();
-    const proofGroups: string[][] = [];
-    for (const [i, v] of tree.entries()) {
-      if (v.readableId === UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY ||
-          v.readableId === UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY) {
-        proofGroups.push(tree.getProof(i));
-      }
-    }
-    
+
     // Construct calls
     logger.verbose("approve adapter amount", params.amount);
     const approveCalls = await approveAdapter().callConstructor({ amount: params.amount });
     const bringLiquidityCalls = await bringLiquidityAdapter().callConstructor({ amount: params.amount });
-    
+    const manageCalls = [...approveCalls, ...bringLiquidityCalls];
+
     // Combine into final call
-    return this.getManageCall(proofGroups, [...approveCalls, ...bringLiquidityCalls]);
+    return this.getManageCall(this.getProofGroupsForManageCalls(manageCalls), manageCalls);
+  }
+
+  /**
+   * Resolves ordered merkle proofs from emitted manage calls.
+   * This ensures only runtime-required proofs are passed to manager calls.
+   */
+  protected getProofGroupsForManageCalls(manageCalls: ManageCall[]): string[][] {
+    const tree = this.getMerkleTree();
+    const proofByReadableId = new Map<string, string[]>();
+    for (const [i, v] of tree.entries()) {
+      if (proofByReadableId.has(v.readableId)) {
+        throw new Error(`Duplicate readableId found in merkle tree: ${v.readableId}`);
+      }
+      proofByReadableId.set(v.readableId, tree.getProof(i));
+    }
+
+    return manageCalls.map((manageCall, index) => {
+      if (!manageCall.proofReadableId) {
+        throw new Error(`Missing proofReadableId for manage call at index ${index}`);
+      }
+      const proof = proofByReadableId.get(manageCall.proofReadableId);
+      if (!proof) {
+        throw new Error(`Proof not found for readableId: ${manageCall.proofReadableId}`);
+      }
+      return proof;
+    });
   }
 
   /**
@@ -157,10 +228,10 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
    */
   getManageCall(proofGroups: string[][], manageCalls: ManageCall[]): Call {
     assert(
-      proofGroups.length == manageCalls.length, 
+      proofGroups.length == manageCalls.length,
       `Proof IDs and Manage Calls length mismatch: ${proofGroups.length} != ${manageCalls.length}`
     );
-    
+
     return this.managerContract.populate('manage_vault_with_merkle_verification', {
       proofs: proofGroups.map(group => group),
       decoder_and_sanitizers: manageCalls.map(call => call.sanitizer.address),
@@ -176,7 +247,7 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
    */
   getSetManagerCall(strategist: ContractAddr, root = this.getMerkleRoot()): Call {
     return this.managerContract.populate('set_manage_root', [
-      strategist.address, 
+      strategist.address,
       num.getHexString(root)
     ]);
   }
@@ -244,4 +315,3 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
   }
 
 }
-

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/adapter-utils.ts

@@ -15,6 +15,7 @@ export const AVNU_EXCHANGE_FOR_LEGACY_USDC = ContractAddr.from('0x7bffc7f6bda62b
 export const AVNU_QUOTE_URL = "https://starknet.api.avnu.fi/swap/v3/quotes";
 export const EXTENDED_CONTRACT = ContractAddr.from('0x062da0780fae50d68cecaa5a051606dc21217ba290969b302db4dd99d2e9b470');
 export const VESU_SINGLETON = ContractAddr.from('0x000d8d6dfec4d33bfb6895de9f3852143a17c6f92fd2a21da3d6924d34870160');
+export const TRANSFER_SANITIZER = ContractAddr.from('0x07c94fd8762b37b02c2afeaf37e5d77523a2aedd370ccff6e130b2d5e9e23037');
 export function toBigInt(value: string | number): bigint {
     if (typeof value === 'string') {
         return BigInt(value);
@@ -23,4 +24,4 @@ export function toBigInt(value: string | number): bigint {
     } else {
         throw new Error('Value must be a string or number');
     }
-}
+}