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

package/src/interfaces/common.tsx

@@ -25,6 +25,14 @@ export interface RiskFactor {
   reason?: string; // optional reason for the risk factor
 }
 
+export type PriceMethod = 'AvnuApi' | 'Coinbase' | 'Coinmarketcap' | 'Ekubo' | 'Avnu';
+export enum TokenIndexingType {
+  PEGGED = "pegged",
+  INDEXER = "indexer",
+  LST_SCRIPT = "lstScript",
+  IGNORE = "ignore",
+}
+
 export interface TokenInfo {
   name: string;
   symbol: string;
@@ -35,6 +43,9 @@ export interface TokenInfo {
   displayDecimals: number;
   priceProxySymbol?: string; // for tokens like illiquid tokens, we use a proxy symbol to get the price
   priceCheckAmount?: number; // for tokens like BTC, doing 1BTC price check may not be ideal, esp on illiquid netwrks like sn
+  priceMethod?: PriceMethod; // preferred price source; tried first, then falls back to other methods
+  dontPrice?: boolean; // a flag that skips pricer to check these tokens.
+  indexingType: TokenIndexingType;
 }
 
 export enum Network {
@@ -55,6 +66,75 @@ export interface IProtocol {
   logo: string;
 }
 
+export interface ICurator {
+  name: string;
+  logo: string;
+}
+
+export enum StrategyTag {
+  META_VAULT = "Meta Vaults",
+  LEVERED = "Maxx",
+  AUTOMATED_LP = "Ekubo",
+  BTC = "BTC"
+}
+
+export enum VaultType {
+  LOOPING = "Looping",
+  META_VAULT = "Meta Vault",
+  DELTA_NEUTRAL = "Delta Neutral",
+  AUTOMATED_LP = "Automated LP",
+  TVA = "Troves Value Averaging",
+}
+
+// Security metadata enums
+export enum AuditStatus {
+  AUDITED = "Audited",
+  NOT_AUDITED = "Not Audited",
+}
+
+export enum SourceCodeType {
+  OPEN_SOURCE = "Open Source",
+  CLOSED_SOURCE = "Closed Source",
+}
+
+export enum AccessControlType {
+  MULTISIG_ACCOUNT = "Multisig Account",
+  STANDARD_ACCOUNT = "Standard Account",
+  ROLE_BASED_ACCESS = "Role Based Access",
+}
+
+export enum InstantWithdrawalVault {
+  YES = "Yes",
+  NO = "No",
+}
+
+// Security metadata interfaces
+export interface SourceCodeInfo {
+  type: SourceCodeType;
+  contractLink: string;
+}
+
+export interface AccessControlInfo {
+  type: AccessControlType;
+  addresses: ContractAddr[];
+  timeLock?: string;
+}
+
+export interface SecurityMetadata {
+  auditStatus: AuditStatus;
+  sourceCode: SourceCodeInfo;
+  accessControl: AccessControlInfo;
+}
+
+export interface RedemptionInfo {
+  instantWithdrawalVault: InstantWithdrawalVault;
+  redemptionsInfo: {
+    title: string; // e.g. Upto $1M
+    description: string; // e.g. "1-2 hours"
+  }[],
+  alerts: StrategyAlert[];
+}
+
 export enum FlowChartColors {
   Green = "purple",
   Blue = "#35484f",
@@ -66,26 +146,89 @@ export interface FAQ {
   answer: string | React.ReactNode;
 }
 
+export enum StrategyLiveStatus {
+    ACTIVE = "Active",
+    NEW = "New",
+    COMING_SOON = "Coming Soon",
+    DEPRECATED = "Deprecated", // active but not recommended
+    RETIRED = "Retired", // not active anymore
+    HOT = "Hot & New 🔥"
+}
+
+export interface StrategyAlert {
+    type: "warning" | "info";
+    text: string | React.ReactNode;
+    tab: "all" | "deposit" | "withdraw";
+}
+
+export interface StrategySettings {
+    liveStatus?: StrategyLiveStatus;
+    isPaused?: boolean;
+    isInMaintenance?: boolean;
+    isAudited: boolean;
+    isInstantWithdrawal?: boolean;
+    hideHarvestInfo?: boolean;
+    is_promoted?: boolean;
+    isTransactionHistDisabled?: boolean;
+    quoteToken: TokenInfo;
+    hideNetEarnings?: boolean;
+    showWithdrawalWarningModal?: boolean;
+    alerts?: StrategyAlert[];
+    tags?: StrategyTag[];
+}
+
+export interface StrategyApyHistoryUIConfig {
+  // Defaults to true in UI if omitted.
+  showApyHistory?: boolean;
+  // Optional message shown when APY history is hidden.
+  noApyHistoryMessage?: string;
+}
+
+export interface FeeBps {
+  performanceFeeBps: number;
+}
+
 /**
  * @property risk.riskFactor.factor - The risk factors that are considered for the strategy.
  * @property risk.riskFactor.factor - The value of the risk factor from 0 to 10, 0 being the lowest and 10 being the highest.
+ * @property security - Security-related metadata including audit status, source code information, and access control details.
+ * @property redemptionInfo - Redemption information including instant withdrawal availability and expected redemption times.
  */
 export interface IStrategyMetadata<T> {
+  id: string;
   name: string;
   description: string | React.ReactNode;
+  /**
+   * Optional UI sort priority. Higher shows earlier.
+   * Intended for pinning flagship parent vaults (e.g. BTC above STRK).
+   */
+  priority?: number;
+  /**
+   * Optional UI config for the variant intro popup (strategy page).
+   * Should be identical across strategies that share the same `parentId`.
+   */
+  variantIntro?: {
+    title: string;
+    description: string;
+  };
   address: ContractAddr;
   launchBlock: number;
   type: "ERC4626" | "ERC721" | "Other";
+  vaultType: {
+    type: VaultType;
+    description: string;
+  };
   depositTokens: TokenInfo[];
   protocols: IProtocol[];
   auditUrl?: string;
-  maxTVL: Web3Number;
   risk: {
     riskFactor: RiskFactor[];
     netRisk: number;
     notARisks: RiskType[];
   };
   apyMethodology?: string;
+  realizedApyMethodology?: string;
+  feeBps?: FeeBps;
   additionalInfo: T;
   contractDetails: {
     address: ContractAddr;
@@ -96,8 +239,34 @@ export interface IStrategyMetadata<T> {
   points?: {multiplier: number, logo: string, toolTip?: string}[];
   docs?: string;
   investmentSteps: string[];
-  curator?: { name: string, logo: string },
-  isPreview?: boolean
+  curator?: ICurator,
+  isPreview?: boolean;
+  tags?: StrategyTag[];
+  security: SecurityMetadata;
+  redemptionInfo: RedemptionInfo;
+  usualTimeToEarnings: null | string; // e.g. "2 weeks" // some strats grow like step functions
+  usualTimeToEarningsDescription: null | string; // e.g. "LSTs price on DEX goes up roughly every 2 weeks"
+  discontinuationInfo?: {
+    date?: Date;
+    reason?: React.ReactNode | string;
+    info?: React.ReactNode | string;
+  };
+  settings?: StrategySettings;
+  apyHistoryUIConfig?: StrategyApyHistoryUIConfig;
+    // Legacy field for multi-step strategies (deprecated, use investmentFlows instead)
+    actions?: Array<{
+        name?: string;
+        pool?: {
+            protocol?: { name: string; logo: string };
+            pool?: { name: string; logos?: string[] };
+            apr?: number;
+            borrow?: { apr?: number };
+        };
+        amount?: string | number;
+        isDeposit?: boolean;
+    }>;
+  parentId?: string;
+  parentName?: string;
 }
 
 export interface IInvestmentFlow {
@@ -124,6 +293,23 @@ export function getMainnetConfig(
   };
 }
 
+export const getStrategyTagDesciption = (tag: StrategyTag): string => {
+  switch (tag) {
+    case StrategyTag.META_VAULT:
+      return "A meta vault is a vault that auto allocates funds to multiple vaults based on optimal yield opportunities";
+    case StrategyTag.LEVERED:
+      return "Looping vaults on Endur LSTs with leveraged borrowing of STRK or BTC to increase yield (2-4x higher yield than simply staking)";
+    case StrategyTag.AUTOMATED_LP:
+      return "Automated LP vaults on Ekubo that rebalance position automatically, ensuring you earn fees efficiently";
+    case StrategyTag.BTC:
+      return "BTC linked vaults";
+  }
+}
+
+export const getAllStrategyTags = (): StrategyTag[] => {
+  return Object.values(StrategyTag);
+}
+
 export const getRiskExplaination = (riskType: RiskType) => {
   switch (riskType) {
     case RiskType.MARKET_RISK:
@@ -196,7 +382,7 @@ export function highlightTextWithLinks(
       {parts.map((part, i) => {
         const match = highlights.find(m => m.highlight.toLowerCase() === part.toLowerCase());
         return match ? (
-          <a key={i} href={match.link} target="_blank" style={{ color: 'var(--chakra-colors-white)', background: 'var(--chakra-colors-highlight)' }}>
+          <a key={i} href={match.link} target="_blank" style={{ color: 'white', background: 'rgba(255, 255, 255, 0.04)' }}>
             {part}
           </a>
         ) : (
@@ -215,6 +401,30 @@ export interface VaultPosition {
   protocol: IProtocol
 }
 
+export interface AmountInfo {
+    amount: Web3Number;
+    usdValue: number;
+    tokenInfo: TokenInfo;
+}
+
+export interface AmountsInfo {
+    usdValue: number;
+    amounts: AmountInfo[];
+}
+
+/**
+ * Strategy capabilities interface
+ * Describes what optional methods a strategy instance supports
+ */
+export interface StrategyCapabilities {
+    hasMatchInputAmounts: boolean;
+    hasNetAPY: boolean;
+    hasGetInvestmentFlows: boolean;
+    hasGetPendingRewards: boolean;
+    hasHarvest: boolean;
+    hasRebalance: boolean;
+}
+
 const VesuProtocol: IProtocol = {
   name: "Vesu",
   logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png"
@@ -249,6 +459,12 @@ const VaultProtocol: IProtocol = {
   name: "Vault",
   logo: ""
 }
+
+const TrovesProtocol: IProtocol = {
+  name: "Troves",
+  logo: "https://app.troves.fi/favicon.ico"
+};
+
 export const Protocols = {
   NONE: NoneProtocol,
   VESU: VesuProtocol,
@@ -256,5 +472,11 @@ export const Protocols = {
   EXTENDED: ExtendedProtocol,
   EKUBO: EkuboProtocol,
   AVNU: AvnuProtocol,
-  VAULT: VaultProtocol
-}
+  VAULT: VaultProtocol,
+  TROVES: TrovesProtocol
+}
+
+export const UnwrapLabsCurator: ICurator = {
+  name: "Unwrap Labs",
+  logo: "https://assets.troves.fi/integrations/unwraplabs/white.png"
+}

package/src/modules/apollo-client-config.ts

@@ -0,0 +1,28 @@
+import { ApolloClient, InMemoryCache } from '@apollo/client';
+import { IConfig } from '@/interfaces';
+
+/**
+ * Creates an Apollo Client instance configured for the appropriate environment
+ * @param config - The application config containing network and stage information
+ * @returns Configured Apollo Client instance
+ */
+export function createApolloClient(config: IConfig) {
+  // Determine the URI based on the environment
+  const uri = config.stage === 'production' 
+    ? 'https://api.troves.fi/' 
+    : 'http://localhost:4000';
+
+  return new ApolloClient({
+    uri,
+    cache: new InMemoryCache(),
+  });
+}
+
+// Default client for backward compatibility
+const apolloClient = new ApolloClient({
+  uri: 'https://api.troves.fi/',
+  cache: new InMemoryCache(),
+});
+
+export default apolloClient;
+

package/src/modules/avnu.ts

@@ -4,7 +4,7 @@ import { Call, Uint256 } from "starknet";
 import { AvnuOptions, fetchBuildExecuteTransaction, fetchQuotes, Quote } from "@avnu/avnu-sdk";
 import { assert } from "../utils";
 import { logger } from "@/utils/logger";
-import { ContractAddr } from "@/dataTypes";
+import { ContractAddr, Web3Number } from "@/dataTypes";
 
 export interface Route {
     token_from: string,
@@ -15,12 +15,12 @@ export interface Route {
 }
 
 export interface SwapInfo {
-    token_from_address: string, 
-    token_from_amount: Uint256, 
-    token_to_address: string,   
-    token_to_amount: Uint256, 
-    token_to_min_amount: Uint256,  
-    beneficiary: string,  
+    token_from_address: string,
+    token_from_amount: Uint256,
+    token_to_address: string,
+    token_to_amount: Uint256,
+    token_to_min_amount: Uint256,
+    beneficiary: string,
     integrator_fee_amount_bps: number,
     integrator_fee_recipient: string,
     routes: Route[]
@@ -59,7 +59,7 @@ export class AvnuWrapper {
         }
         throw new Error('no quotes found')
     }
-    
+
     return filteredQuotes[0];
   }
 
@@ -100,9 +100,9 @@ export class AvnuWrapper {
     // swapInfo as expected by the strategy
     // fallback, max 1% slippage
     const _minAmount = minAmount || (quote.buyAmount * 95n / 100n).toString();
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
+    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
+    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
+    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
     const swapInfo: SwapInfo = {
       token_from_address: quote.sellTokenAddress,
       token_from_amount: uint256.bnToUint256(quote.sellAmount),
@@ -140,12 +140,21 @@ export class AvnuWrapper {
   async getSwapCallData(
     quote: Pick<Quote, 'quoteId' | 'buyTokenAddress' | 'buyAmount' | 'sellTokenAddress' | 'sellAmount'>,
     taker: string,
+    minAmount?: Web3Number,
   ) {
     const calldata = await fetchBuildExecuteTransaction(quote.quoteId, taker, undefined, false);
     const result = calldata.calls.map((call: Call) => {
       const data = call.calldata as string[];
       return data.map(x => BigInt(x));
     });
+
+    // override with given min amount out
+    if (minAmount) {
+      logger.verbose(`AvnuWrapper: minAmount passed ${minAmount.toString()}`)
+      const u256 = uint256.bnToUint256(minAmount.toWei());
+      result[0][6] = BigInt(u256.low);
+      result[0][7] = BigInt(u256.high);
+    }
     return result;
   }
-}
+}

package/src/modules/ekubo-pricer.ts

@@ -0,0 +1,80 @@
+import { Contract, RpcProvider, BlockIdentifier } from "starknet";
+import EkuboPricerAbi from '@/data/ekubo-price-fethcer.abi.json';
+import { PricerBase } from "./pricerBase";
+import { IConfig, TokenInfo } from "@/interfaces";
+import { PriceInfo } from "./pricer";
+
+export class EkuboPricer extends PricerBase {
+    EKUBO_PRICE_FETCHER_ADDRESS = '0x04946fb4ad5237d97bbb1256eba2080c4fe1de156da6a7f83e3b4823bb6d7da1';
+    readonly contract: Contract;
+    // Updating to new USDC_ADDRESS
+    private readonly USDC_ADDRESS = '0x033068F6539f8e6e6b131e6B2B814e6c34A5224bC66947c47DaB9dFeE93b35fb';
+    private readonly USDC_DECIMALS = 6;
+
+    constructor(config: IConfig, tokens: TokenInfo[]) {
+        super(config, tokens);
+        this.contract = new Contract({
+            abi: EkuboPricerAbi, 
+            address: this.EKUBO_PRICE_FETCHER_ADDRESS, 
+            providerOrAccount: config.provider as RpcProvider
+        });
+    }
+
+    private div2Power128(num: bigint): number {
+        return Number((num * BigInt(1e18)) / BigInt(2 ** 128)) / 1e18;
+    }
+
+    async getPrice(tokenAddr: string, blockIdentifier: BlockIdentifier = 'latest'): Promise<PriceInfo> {
+        if (!tokenAddr) {
+            throw new Error(`EkuboPricer:getPrice - no token`);
+        }
+
+        // get_prices arguments in order:
+        // - quote_token: USDC address (quote token for price calculation)
+        // - base_tokens: array containing the base token address/addresses
+        // - period: time period in seconds for TWAP (3600 = 1 hour)
+        // - min_token: minimum token amount threshold (min liquidity) in 6 Decimals = 1000000)
+        const result: any = await this.contract.call(
+            'get_prices',
+            [this.USDC_ADDRESS, [tokenAddr], 3600, 1000000],
+            { blockIdentifier }
+        );
+
+        if (!result || result.length === 0) {
+            throw new Error(`EkuboPricer: No price result returned for ${tokenAddr}`);
+        }
+
+        const priceResult = result[0];
+        
+        if (!priceResult?.variant?.Price) {
+            const variant = priceResult?.variant ? Object.keys(priceResult.variant)[0] : 'Unknown';
+            throw new Error(`EkuboPricer: Price fetch failed with variant: ${variant}`);
+        }
+
+        const rawPrice = typeof priceResult.variant.Price === 'string' 
+            ? BigInt(priceResult.variant.Price) 
+            : priceResult.variant.Price;
+
+        // Get token info to determine decimals from configured tokens
+        const tokenInfo = this.tokens.find(t => 
+            t.address.address.toLowerCase() === tokenAddr.toLowerCase()
+        );
+        
+        if (!tokenInfo) {
+            throw new Error(`Token ${tokenAddr} not found in global tokens`);
+        }
+
+        // Convert from x128 format
+        const priceAfterX128 = this.div2Power128(rawPrice);
+        
+        // Adjust for token decimals
+        const decimalAdjustment = 10 ** (tokenInfo.decimals - this.USDC_DECIMALS);
+        const price = priceAfterX128 * decimalAdjustment;
+
+        return {
+            price,
+            timestamp: new Date()
+        };
+    }
+}
+

package/src/modules/ekubo-quoter.ts

@@ -41,36 +41,57 @@ export class EkuboQuoter {
     this.tokenMarketData = new TokenMarketData(pricer, config);
   }
 
-  /**
-   * 
-   * @param fromToken 
-   * @param toToken 
-   * @param amount Can be negative too, which would mean to get exact amount out
-   * @returns 
-   */
-  async getQuote(fromToken: string, toToken: string, amount: Web3Number, retry = 0): Promise<EkuboQuote> {
-    // let _fromToken = amount.gt(0) ? fromToken : toToken;
-    // let _toToken = amount.gt(0) ? toToken : fromToken;
-
+  private async _callQuoterApi(fromToken: string, toToken: string, amount: Web3Number, retry = 0): Promise<EkuboQuote> {
     try {
-      const url = this.ENDPOINT.replace("{{AMOUNT}}", amount.toFixed(0)).replace("{{TOKEN_FROM_ADDRESS}}", fromToken).replace("{{TOKEN_TO_ADDRESS}}", toToken);
-      console.log("url", url);
+      const url = this.ENDPOINT.replace("{{AMOUNT}}", amount.toWei()).replace("{{TOKEN_FROM_ADDRESS}}", fromToken).replace("{{TOKEN_TO_ADDRESS}}", toToken);
+      logger.verbose(`EkuboQuoter::_callQuoterApi url: ${url}`);
       const quote = await axios.get(url);
-     return quote.data as EkuboQuote;
+      // console.log('quote', quote.data);
+      // console.log('')
+      return quote.data as EkuboQuote;
     } catch (error: any) {
-      logger.error(`${error.message} dassf ${error.data}`);
+      logger.error(`EkuboQuoter::_callQuoterApi error: ${error.message}`);
       if (retry < 3) {
         await new Promise((resolve) => setTimeout(resolve, (retry + 1) * 5000));
-        return await this.getQuote(fromToken, toToken, amount, retry + 1);
+        return await this._callQuoterApi(fromToken, toToken, amount, retry + 1);
       }
       throw error;
     }
   }
 
+  /**
+   * Given exactly `inputAmount` of `fromToken`, how much `toToken` do I receive?
+   * @param fromToken - address of the token being sold
+   * @param toToken - address of the token being bought
+   * @param inputAmount - must be positive (the amount of fromToken to sell)
+   * @returns EkuboQuote where `total_calculated` is the output amount (positive)
+   */
+  async getQuoteExactInput(fromToken: string, toToken: string, inputAmount: Web3Number): Promise<EkuboQuote> {
+    if (inputAmount.isNegative() || inputAmount.isZero()) {
+      throw new Error(`EkuboQuoter::getQuoteExactInput inputAmount must be positive, got ${inputAmount.toFixed()}`);
+    }
+    return this._callQuoterApi(fromToken, toToken, inputAmount);
+  }
+
+  /**
+   * To receive exactly `outputAmount` of `toToken`, how much `fromToken` must I provide?
+   * @param fromToken - address of the token being sold
+   * @param toToken - address of the token being bought
+   * @param outputAmount - must be positive (the desired amount of toToken to receive)
+   * @returns EkuboQuote where `total_calculated` is the required input amount (negative per Ekubo convention)
+   */
+  async getQuoteExactOutput(fromToken: string, toToken: string, outputAmount: Web3Number): Promise<EkuboQuote> {
+    if (outputAmount.isNegative() || outputAmount.isZero()) {
+      throw new Error(`EkuboQuoter::getQuoteExactOutput outputAmount must be positive, got ${outputAmount.toFixed()}`);
+    }
+    const negatedAmount = new Web3Number(outputAmount.multipliedBy(-1).toFixed(Math.min(outputAmount.decimals, 15)), outputAmount.decimals);
+    return this._callQuoterApi(toToken, fromToken, negatedAmount);
+  }
+
   async getDexPrice(baseToken: TokenInfo, quoteToken: TokenInfo, amount: Web3Number) {
     const lstTokenInfo = baseToken;
     const lstUnderlyingTokenInfo = quoteToken;
-    const quote = await this.getQuote(
+    const quote = await this.getQuoteExactInput(
       lstTokenInfo.address.address,
       lstUnderlyingTokenInfo.address.address,
       amount
@@ -95,26 +116,23 @@ export class EkuboQuoter {
     logger.verbose(`${EkuboQuoter.name}:: LST true Exchange Rate: ${exchangeRate}`);
     return exchangeRate;
   }
-  // debt collateral 
+  // debt collateral
   async getSwapLimitAmount(fromToken: TokenInfo, toToken: TokenInfo, amount: Web3Number, max_slippage: number = 0.002): Promise<Web3Number> {
     const isExactAmountIn = amount.greaterThanOrEqualTo(0);
     logger.verbose(`${EkuboQuoter.name}::getSwapLimitAmount isExactAmountIn: ${isExactAmountIn}, fromToken: ${fromToken.symbol}, toToken: ${toToken.symbol}, amount: ${amount}`);
     const isYieldToken = this.tokenMarketData.isAPYSupported(toToken);
-    console.log("isYieldToken", isYieldToken);
-    
+
     // if LST, get true exchange rate else use dex price
     // wbtc
-    const baseToken = isExactAmountIn ? toToken : fromToken; // fromToken -> wbtc, 
-    const quoteToken = isExactAmountIn ? fromToken : toToken; // toToken -> usdc, 
+    const baseToken = isExactAmountIn ? toToken : fromToken; // fromToken -> wbtc,
+    const quoteToken = isExactAmountIn ? fromToken : toToken; // toToken -> usdc,
     // need dex price of from token in toToken
     // from baseToken to underlying token
     // for withdraw, usdc to btc with amount negative
     const dexPrice = await this.getDexPrice(baseToken, quoteToken, amount);
     const trueExchangeRate = isYieldToken ? await this.tokenMarketData.getTruePrice(baseToken) : dexPrice;
-    console.log("trueExchangeRate", trueExchangeRate);
     if (isExactAmountIn) {
       let minLSTReceived = amount.dividedBy(dexPrice).multipliedBy(1 - max_slippage); // used for increase
-      console.log("minLSTReceived", minLSTReceived);
       const minLSTReceivedAsPerTruePrice = amount.dividedBy(trueExchangeRate); // execution output to be <= True LST price
       if (minLSTReceived < minLSTReceivedAsPerTruePrice) {
         minLSTReceived = minLSTReceivedAsPerTruePrice; // the execution shouldn't be bad than True price logi
@@ -122,26 +140,26 @@ export class EkuboQuoter {
       logger.verbose(`${EkuboQuoter.name}::getModifyLeverCall minLSTReceivedAsPerTruePrice: ${minLSTReceivedAsPerTruePrice}, minLSTReceived: ${minLSTReceived}`);
       return minLSTReceived;
     }
-    
+
     let maxUsedCollateral = amount.abs().dividedBy(dexPrice).multipliedBy(1 + max_slippage); // +ve for exact amount out, used for decrease
     const maxUsedCollateralInLST = amount.abs().dividedBy(trueExchangeRate).multipliedBy(1.005); // 0.5% slippage, worst case based on true price
     logger.verbose(`${EkuboQuoter.name}::getModifyLeverCall maxUsedCollateralInLST: ${maxUsedCollateralInLST}, maxUsedCollateral: ${maxUsedCollateral}`);
     if (maxUsedCollateralInLST > maxUsedCollateral) {
       maxUsedCollateral = maxUsedCollateralInLST;
     }
-    
+
     return maxUsedCollateral;
   }
 
   /**
    * Formats Ekubo response for Vesu multiple use
-   * @param quote 
-   * @param fromTokenInfo 
-   * @returns 
+   * @param quote
+   * @param fromTokenInfo
+   * @returns
    */
   getVesuMultiplyQuote(quote: EkuboQuote, fromTokenInfo: TokenInfo, toTokenInfo: TokenInfo): Swap[] {
     return quote.splits.map(split => {
-      
+
       const isNegativeAmount = BigInt(split.amount_specified) <= 0n;
       const token = isNegativeAmount ? toTokenInfo : fromTokenInfo;
       return {

package/src/modules/erc20.ts

@@ -58,6 +58,23 @@ export class ERC20 {
     return transferCall;
   }
 
+  transferFrom(
+    token: string | ContractAddr,
+    from: string | ContractAddr,
+    to: string | ContractAddr,
+    amount: Web3Number
+  ) {
+    const contract = this.contract(token);
+    const amountUint256 = uint256.bnToUint256(amount.toWei());
+    const transferFromCall = contract.populate("transferFrom", [
+      from.toString(),
+      to.toString(),
+      amountUint256.low.toString(),
+      amountUint256.high.toString(),
+    ]);
+    return transferFromCall;
+  }
+
    approve(
     token: string | ContractAddr,
     spender: string | ContractAddr,