@strkfarm/sdk 1.0.53 → 1.0.55

package/src/dataTypes/_bignumber.ts

@@ -61,6 +61,21 @@ export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
     }
     return value.toFixed(this.maxToFixedDecimals());
   }
+
+  minimum(value: string | number | T): T {
+    const _value = new BigNumber(value);
+    const _valueMe = new BigNumber(this.toString());
+    const answer = _value.lessThanOrEqualTo(_valueMe) ? _value : _valueMe;
+    return this.construct(answer.toString(), this.decimals);
+  }
+
+  maximum(value: string | number | T): T {
+    const _value = new BigNumber(value);
+    const _valueMe = new BigNumber(this.toString());
+    console.warn(`maximum: _value: ${_value.toString()}, _valueMe: ${_valueMe.toString()}`);
+    const answer = _value.greaterThanOrEqualTo(_valueMe) ? _value : _valueMe;
+    return this.construct(answer.toString(), this.decimals);
+  }
 }
 
 BigNumber.config({ DECIMAL_PLACES: 18, ROUNDING_MODE: BigNumber.ROUND_DOWN });

package/src/interfaces/common.tsx

@@ -14,7 +14,8 @@ export enum RiskType {
   SMART_CONTRACT_RISK = "Smart Contract Risk",
   ORACLE_RISK = "Oracle Risk",
   TECHNICAL_RISK = "Technical Risk",
-  COUNTERPARTY_RISK = "Counterparty Risk" // e.g. bad debt
+  COUNTERPARTY_RISK = "Counterparty Risk", // e.g. bad debt
+  DEPEG_RISK = "Depeg Risk" // e.g. USDC depeg
 }
 
 export interface RiskFactor {
@@ -104,7 +105,7 @@ export interface IInvestmentFlow {
 }
 
 export function getMainnetConfig(
-  rpcUrl = "https://starknet-mainnet.public.blastapi.io",
+  rpcUrl: string,
   blockIdentifier: BlockIdentifier = "pending"
 ): IConfig {
   return {
@@ -135,6 +136,8 @@ export const getRiskExplaination = (riskType: RiskType) => {
       return "The risk of technical issues e.g. backend failure.";
     case RiskType.COUNTERPARTY_RISK:
       return "The risk of the counterparty defaulting e.g. bad debt on lending platforms.";
+    case RiskType.DEPEG_RISK:
+      return "The risk of a token losing its peg to the underlying asset, leading to potential losses for holders.";
   }
 };
 

package/src/modules/avnu.ts

@@ -60,7 +60,6 @@ export class AvnuWrapper {
         throw new Error('no quotes found')
     }
     
-    logger.verbose(`${AvnuWrapper.name}: getQuotes => Found ${JSON.stringify(filteredQuotes[0])}`);
     return filteredQuotes[0];
   }
 

package/src/strategies/base-strategy.ts

@@ -21,8 +21,14 @@ export interface DualTokenInfo {
     token1: SingleTokenInfo
 }
 
+interface CacheData {
+  timestamp: number;
+  ttl: number;
+  data: any;
+}
 export class BaseStrategy<TVLInfo, ActionInfo> {
     readonly config: IConfig;
+    readonly cache: Map<string, CacheData> = new Map();
 
     constructor(config: IConfig) {
         this.config = config;
@@ -43,5 +49,26 @@ export class BaseStrategy<TVLInfo, ActionInfo> {
     async withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]> {
         throw new Error("Not implemented");
     }
+
+    setCache(key: string, data: any, ttl: number = 60000): void {
+        const timestamp = Date.now();
+        this.cache.set(key, { timestamp, ttl, data });
+    }
+
+    getCache(key: string): any | null {
+        const cachedData = this.cache.get(key);
+        if (!cachedData || !this.isCacheValid(key)) {
+            return null;
+        }
+        return cachedData.data;
+    }
+
+    isCacheValid(key: string): boolean {
+        const cachedData = this.cache.get(key);
+        if (!cachedData) return false;
+
+        const { timestamp, ttl } = cachedData;
+        return Date.now() - timestamp <= ttl;
+    }
     
 }

package/src/strategies/ekubo-cl-vault.tsx

@@ -1456,11 +1456,19 @@ export class EkuboCLVault extends BaseStrategy<
         const swap1Amount = Web3Number.fromWei(
           uint256.uint256ToBN(swapInfo1.token_from_amount).toString(),
           18 // cause its always STRK?
-        );
+        ).minimum(
+          postFeeAmount.toFixed(18) // cause always strk
+        ); // ensure we don't swap more than we have
+        swapInfo.token_from_amount = uint256.bnToUint256(swap1Amount.toWei());
+        swapInfo.token_to_min_amount = uint256.bnToUint256(
+          swap1Amount.multipliedBy(0).toWei() // placeholder
+        ); // 0.01% slippage
+
         logger.verbose(
           `${EkuboCLVault.name}: harvest => swap1Amount: ${swap1Amount}`
         );
-        const remainingAmount = postFeeAmount.minus(swap1Amount);
+
+        const remainingAmount = postFeeAmount.minus(swap1Amount).maximum(0);
         logger.verbose(
           `${EkuboCLVault.name}: harvest => remainingAmount: ${remainingAmount}`
         );
@@ -1500,7 +1508,11 @@ export class EkuboCLVault extends BaseStrategy<
       const _callsFinal = await this.rebalanceIter(
         swapInfo,
         acc,
-        harvestEstimateCall
+        harvestEstimateCall,
+        claim.token.eq(poolKey.token0),
+        0,
+        0n,
+        BigInt(postFeeAmount.toWei()), // upper limit is the post fee amount
       );
       logger.verbose(
         `${EkuboCLVault.name}: harvest => _callsFinal: ${JSON.stringify(

package/src/strategies/index.ts

@@ -2,3 +2,4 @@ export * from './autoCompounderStrk';
 export * from './vesu-rebalance';
 export * from './ekubo-cl-vault';
 export * from './base-strategy';
+export * from './sensei';

package/src/strategies/sensei.ts

@@ -0,0 +1,333 @@
+import { getNoRiskTags, highlightTextWithLinks, IConfig, IProtocol, IStrategyMetadata, RiskFactor, RiskType, TokenInfo } from "@/interfaces";
+import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { Call, Contract, uint256 } from "starknet";
+import SenseiABI from "@/data/sensei.abi.json";
+import { getTrovesEndpoint, logger } from "@/utils";
+import { Global } from "@/global";
+import { QuoteRequest } from "@avnu/avnu-sdk";
+import { PricerBase } from "@/modules/pricerBase";
+import ERC20ABI from "@/data/erc20.abi.json";
+import { AvnuWrapper } from "@/modules";
+
+export interface SenseiVaultSettings {
+  mainToken: TokenInfo;
+  secondaryToken: TokenInfo;
+  targetHfBps: number; // in bps
+  feeBps: number; // in bps
+}
+
+export class SenseiVault extends BaseStrategy<
+  SingleTokenInfo,
+  SingleActionAmount
+> {
+  readonly address: ContractAddr;
+  readonly metadata: IStrategyMetadata<SenseiVaultSettings>;
+  readonly pricer: PricerBase;
+  readonly contract: Contract;
+  constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<SenseiVaultSettings>) {
+    super(config);
+    this.address = metadata.address;
+    this.pricer = pricer;
+    this.metadata = metadata;
+    this.contract = new Contract(SenseiABI, this.address.address, this.config.provider);
+
+    if (metadata.depositTokens.length === 0) {
+      throw new Error("Deposit tokens are not defined in metadata");
+    }
+  }
+
+  async getUserTVL(user: ContractAddr): Promise<SingleTokenInfo> {
+    const result: any = await this.contract.call(
+      "describe_position",
+      [user.address],
+    );
+    const amount = Web3Number.fromWei(
+      uint256.uint256ToBN(result[1].estimated_size).toString(),
+      this.metadata.depositTokens[0].decimals,
+    )
+    const price = await this.pricer.getPrice(
+      this.metadata.depositTokens[0].symbol,
+    );
+    return {
+      usdValue: Number(amount.toFixed(6)) * price.price,
+      amount,
+      tokenInfo: this.metadata.depositTokens[0],
+    }
+  }
+
+  async getTVL(): Promise<SingleTokenInfo> {
+     try {
+      const {
+        collateralXSTRK,
+        collateralUSDValue,
+        debtSTRK,
+        debtUSDValue,
+        xSTRKPrice,
+        collateralInSTRK,
+      } = await this.getPositionInfo();
+
+      const usdValue =
+        Number(collateralUSDValue.toFixed(6)) -
+        Number(debtUSDValue.toFixed(6));
+
+      return {
+        usdValue,
+        amount: new Web3Number(
+          (collateralInSTRK - Number(debtSTRK.toFixed(6))).toFixed(6),
+          collateralXSTRK.decimals,
+        ),
+        tokenInfo: this.metadata.depositTokens[0],
+      };
+    } catch (error) {
+      console.error('Error fetching TVL:', error);
+      return {
+        usdValue: 0,
+        amount: new Web3Number('0', this.metadata.depositTokens[0].decimals),
+        tokenInfo: this.metadata.depositTokens[0],
+      }
+    }
+  }   
+
+  async depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]> {
+    const mainTokenContract = new Contract(
+      ERC20ABI,
+      this.metadata.depositTokens[0].address.address,
+      this.config.provider,
+    );  
+    const call1 = mainTokenContract.populate('approve', [
+      this.address.address,
+      uint256.bnToUint256(amountInfo.amount.toWei()),
+    ]);
+    const call2 = this.contract.populate('deposit', [
+      uint256.bnToUint256(amountInfo.amount.toWei()),
+      receiver.address,
+    ]);
+
+    const calls = [call1, call2];
+    return calls;
+  }
+
+  async withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]> {
+    const call = this.contract.populate('withdraw', [
+      uint256.bnToUint256(amountInfo.amount.toWei()),
+      receiver.address,
+      300, // 3% max slippage
+    ]);
+    return [call];
+  }
+
+  async getPositionInfo(): Promise<{
+    collateralXSTRK: Web3Number;
+    collateralUSDValue: Web3Number;
+    debtSTRK: Web3Number;
+    debtUSDValue: Web3Number;
+    xSTRKPrice: number;
+    collateralInSTRK: number;
+  }> {
+    const CACHE_KEY = 'positionInfo';
+    if (this.isCacheValid(CACHE_KEY)) {
+      return this.getCache(CACHE_KEY);
+    }
+    const resp = await fetch(
+      `${getTrovesEndpoint()}/vesu/positions?walletAddress=${this.address.address}`,
+    );
+    const data = await resp.json();
+    if (!data.data || data.data.length == 0) {
+      throw new Error('No positions found');
+    }
+
+    const collateralXSTRK = Web3Number.fromWei(
+      data.data[0].collateral.value,
+      data.data[0].collateral.decimals,
+    );
+    const collateralUSDValue = Web3Number.fromWei(
+      data.data[0].collateral.usdPrice.value,
+      data.data[0].collateral.usdPrice.decimals,
+    );
+    const debtSTRK = Web3Number.fromWei(
+      data.data[0].debt.value,
+      data.data[0].debt.decimals,
+    );
+    const debtUSDValue = Web3Number.fromWei(
+      data.data[0].debt.usdPrice.value,
+      data.data[0].debt.usdPrice.decimals,
+    );
+
+    const xSTRKPrice = await this.getSecondaryTokenPriceRelativeToMain();
+    const collateralInSTRK =
+      Number(collateralXSTRK.toFixed(6)) * xSTRKPrice;
+    const STRKUSDPrice =
+      Number(debtUSDValue.toFixed(6)) /
+      Number(debtSTRK.toFixed(6));
+    const actualCollateralUSDValue = collateralInSTRK * STRKUSDPrice;
+
+    const cacheData = {
+      collateralXSTRK,
+      collateralUSDValue: new Web3Number(
+        actualCollateralUSDValue.toFixed(6),
+        collateralUSDValue.decimals,
+      ),
+      debtSTRK,
+      debtUSDValue,
+      xSTRKPrice,
+      collateralInSTRK,
+    };
+    this.setCache(CACHE_KEY, cacheData); // cache for 1 hour
+    return cacheData;
+  }
+
+   async getSecondaryTokenPriceRelativeToMain(retry = 0): Promise<number> {
+    const CACHE_KEY = 'xSTRKPrice';
+    if (this.isCacheValid(CACHE_KEY)) {
+      return this.getCache(CACHE_KEY);
+    }
+    const params: QuoteRequest = {
+      sellTokenAddress: this.metadata.additionalInfo.secondaryToken.address.address,
+      buyTokenAddress: this.metadata.additionalInfo.mainToken.address.address,
+      sellAmount: BigInt(new Web3Number('1', 18).toWei()),
+      takerAddress: this.address.address,
+    };
+    logger.verbose('getSecondaryTokenPriceRelativeToMain [1]', params);
+    let avnu = new AvnuWrapper();
+    const quote = await avnu.getQuotes(
+      params.sellTokenAddress,
+      params.buyTokenAddress,
+      params.sellAmount?.toString() || '0',
+      params.takerAddress!
+    );
+    if (!quote) {
+      throw new Error('No quotes found to compute secondary token price relative to main token');
+    }
+
+    const firstQuote = quote;
+    const price = Number(
+      Web3Number.fromWei(firstQuote.buyAmount.toString(), 18).toFixed(
+        6,
+      ),
+    );
+    logger.verbose('getSecondaryTokenPriceRelativeToMain [2]', price);
+    this.setCache(CACHE_KEY, price); // cache for 1 min
+    return price;
+  }
+
+  getSettings = async () => {
+    const settings = await this.contract.call('get_settings', []);
+    logger.verbose('getSettings', settings);
+    return settings;
+  };
+    
+}
+
+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}}.`;
+
+const vesuProtocol: IProtocol = {
+  name: "Vesu",
+  logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png"
+};
+const endurProtocol: IProtocol = {
+  name: "Endur",
+  logo: "https://app.endur.fi/logo.png"
+};
+const _riskFactor: RiskFactor[] = [
+  { type: RiskType.SMART_CONTRACT_RISK, value: 0.5, weight: 25, reason: "Audited by CSC" },
+  { type: RiskType.DEPEG_RISK, value: 0.25, weight: 25, reason: "Depending on prevailing market conditions and trading activity, xSTRK may lose its peg to the underlying asset." },
+  { type: RiskType.LIQUIDATION_RISK, value: 0.1, weight: 10, reason: "Liquidation risk is low due to the nature of the Re7 Pool on Vesu" },
+  { type: RiskType.LOW_LIQUIDITY_RISK, value: 0.5, weight: 50, reason: "xSTRK can be sometimes illiquid near true price" }
+];
+
+const FAQS = [
+  {
+    question: "What is xSTRK Sensei?",
+    answer: "xSTRK Sensei is a leveraged looping strategy involving xSTRK and STRK. It uses xSTRK as collateral on Vesu, borrows STRK, and buys more xSTRK with it to create up to 4x leverage and boost yields."
+  },
+  {
+    question: "What is the benefit of using xSTRK Sensei?",
+    answer: "The strategy amplifies your xSTRK exposure and yield through leverage. It also helps you accumulate more Endur points faster."
+  },
+  {
+    question: "What is the maximum leverage possible?",
+    answer: "The strategy may allow up to ~4x leverage, depending on your collateral ratio and market conditions on Vesu. This strategy tries to maintain a health factor of 1.1 on Vesu",
+  },
+  {
+    question: "Isn't 1.1 health factor risky?",
+    answer: "Based on Re7's xSTRK pool configuration on Vesu, xSTRK uses STRK price as its oracle source. This means collateral and debt will always move in the same direction, making 1.1 HF safe. However, if debt increases too much (over months), liquidation may occur, which we try to avoid by actively monitoring the position."
+  },
+  {
+    question: "Are there any risks involved?",
+    answer: "Yes. The major risks are related to xSTRK's illiquidity and price volatility. During volatility or low liquidity, exiting a position can result in loss."
+  },
+  {
+    question: "Does the position always grow?",
+    answer: "No. While xSTRK's true value increases over time, its DEX price may not grow continuously and can fluctuate or move in discrete steps."
+  },
+  {
+    question: "Can I lose money using this strategy?",
+    answer: "Yes. If the xSTRK price drops sharply or becomes illiquid, you may face slippage or loss when trying to exit the looped position."
+  },
+  {
+    question: "What affects the DEX price of xSTRK?",
+    answer: "xSTRK's DEX price depends on supply, demand, and liquidity. Unlike its true value which grows steadily, the DEX price can fluctuate due to market activity."
+  },
+  {
+    question: "Why is xSTRK considered illiquid?",
+    answer: "Since xSTRK is a evolving LST with limited trading volume, sudden large trades can cause high slippage, making it harder to enter or exit positions efficiently. Such conditions normalize over time. Enter and exit positions with caution.",
+  },
+  {
+    question: "Do I earn Endur points on looped xSTRK?",
+    answer: "Yes. All xSTRK in the looped position contributes to your Endur points, allowing you to farm points more effectively with leverage. Visit endur.fi/leaderboard to see your points.",
+  }
+];
+
+export const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[] =
+  [
+    {
+      name: "xSTRK Sensei",
+      description: highlightTextWithLinks(
+        senseiDescription.replaceAll('{{token1}}', 'STRK').replaceAll('{{token2}}', 'xSTRK'),
+        [{
+          highlight: "Endur",
+          link: "https://endur.fi"
+        }, {
+          highlight: "Vesu",
+          link: "https://vesu.xyz"
+        }, {
+          highlight: 'delta neutral position',
+          link: 'https://www.investopedia.com/terms/d/deltaneutral.asp'
+        }]
+      ),
+      address: ContractAddr.from(
+        "0x7023a5cadc8a5db80e4f0fde6b330cbd3c17bbbf9cb145cbabd7bd5e6fb7b0b"
+      ),
+      launchBlock: 1053811,
+      type: "Other",
+      depositTokens: [
+        Global.getDefaultTokens().find((t) => t.symbol === "STRK")!
+      ],
+      protocols: [endurProtocol, vesuProtocol],
+      maxTVL: new Web3Number("1500000", 18),
+      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)
+      },
+      additionalInfo: {
+        mainToken: Global.getDefaultTokens().find((t) => t.symbol === "STRK")!,
+        secondaryToken: Global.getDefaultTokens().find((t) => t.symbol === "xSTRK")!,
+        targetHfBps: 11000, // 1.1 health factor
+        feeBps: 2000, // 2% fee on profits
+      },
+      faqs: FAQS,
+      contractDetails: [],
+      investmentSteps: [
+        "Swap STRK for xSTRK",
+        "Deposit xSTRK to Vesu's Re7 xSTRK Pool",
+        "Borrow STRK against your xSTRK collateral",
+        "Buy more xSTRK with borrowed STRK",
+        "Repeat the process to loop your position",
+        "Claim DeFi spring (STRK) rewards weekly and reinvest",
+      ]
+    },
+  ];

package/src/utils/index.ts

@@ -14,4 +14,8 @@ export function assert(condition: boolean, message: string) {
     if (!condition) {
         throw new Error(message);
     }
+}
+
+export function getTrovesEndpoint(): string {
+    return process.env.TROVES_ENDPOINT || 'https://app.troves.fi';
 }