@strkfarm/sdk 1.1.9 → 1.1.11

package/src/global.ts

@@ -122,6 +122,16 @@ const defaultTokens: TokenInfo[] = [{
     symbol: 'xtBTC',
     logo: 'https://assets.strkfarm.com/integrations/tokens/xtbtc.svg',
     address: ContractAddr.from('0x43a35c1425a0125ef8c171f1a75c6f31ef8648edcc8324b55ce1917db3f9b91'),
+    decimals: 18,
+    coingeckId: undefined,
+    displayDecimals: 6,
+    priceProxySymbol: 'WBTC',
+    priceCheckAmount: 0.0001, // 112000 * 0.0001 = $11.2
+}, {
+    name: 'xLBTC',
+    symbol: 'xLBTC',
+    logo: 'https://assets.strkfarm.com/integrations/tokens/xlbtc.svg',
+    address: ContractAddr.from('0x036834a40984312f7f7de8d31e3f6305b325389eaeea5b1c0664b2fb936461a4'),
     decimals: 8,
     coingeckId: undefined,
     displayDecimals: 6,

package/src/interfaces/common.tsx

@@ -96,7 +96,8 @@ export interface IStrategyMetadata<T> {
   points?: {multiplier: number, logo: string, toolTip?: string}[];
   docs?: string;
   investmentSteps: string[];
-  curator?: { name: string, logo: string }
+  curator?: { name: string, logo: string },
+  isPreview?: boolean
 }
 
 export interface IInvestmentFlow {

package/src/modules/index.ts

@@ -4,4 +4,5 @@ export * from './zkLend';
 export * from './pricer-from-api';
 export * from './erc20';
 export * from './avnu';
-export * from './ekubo-quoter';
+export * from './ekubo-quoter';
+export * from './pricer-lst';

package/src/modules/pricer-from-api.ts

@@ -42,7 +42,7 @@ export class PricerFromApi extends PricerBase {
 
     async getPriceFromMyAPI(tokenSymbol: string) {
         logger.verbose(`getPrice from redis: ${tokenSymbol}`);
-        const endpoint = 'https://app.troves.fi'
+        const endpoint = 'https://cache-server-t2me.onrender.com'
         const url = `${endpoint}/api/price/${tokenSymbol}`;
         const priceInfoRes = await fetch(url);
         const priceInfo = await priceInfoRes.json();

package/src/modules/pricer-lst.ts

@@ -0,0 +1,66 @@
+import { FatalError, PriceInfo, Pricer, Web3Number } from "@/index.browser";
+import { PricerBase } from "./pricerBase";
+import { IConfig, TokenInfo } from "@/interfaces";
+import { logger } from "@/utils";
+import axios from "axios";
+
+export class PricerLST extends Pricer {
+  private tokenMaps: {lst: TokenInfo, underlying: TokenInfo}[];
+  protected EKUBO_API = 'https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_ADDRESS}}/{{UNDERLYING_ADDRESS}}'; // e.g. xSTRK/STRK
+
+  constructor(config: IConfig, tokenMaps: {lst: TokenInfo, underlying: TokenInfo}[]) {
+    const refreshInterval = 5000;
+    const staleTime = 60000;
+    const allTokens = tokenMaps.map(map => [map.lst, map.underlying]).flat();
+    super(config, allTokens, refreshInterval, staleTime);
+    this.tokenMaps = tokenMaps;
+  }
+
+  isUnderlying(token: TokenInfo): boolean {
+    return this.tokenMaps.some(map => map.underlying.address.eq(token.address));
+  }
+
+  getUnderlying(token: TokenInfo): TokenInfo {
+    return this.tokenMaps.find(map => map.lst.address.eq(token.address))!.underlying;
+  }
+
+  async _getPrice(token: TokenInfo, defaultMethod = 'all'): Promise<number> {
+    if (this.isUnderlying(token)) {
+      return 1; // underlying is always 1 relative to LST
+    }
+
+    const methodToUse: string = this.methodToUse[token.symbol] || defaultMethod; // default start with coinbase
+    logger.verbose(`Fetching price of ${token.symbol} using ${methodToUse}`);
+    try {
+        const result = await this._getPriceEkubo(token, new Web3Number(token.priceCheckAmount ? token.priceCheckAmount : 1, token.decimals));
+        this.methodToUse[token.symbol] = 'Ekubo';
+        return result;
+    } catch (error: any) {
+        console.warn(`Ekubo: price err [${token.symbol}]: `, error.message);
+        console.warn(`Ekubo: price err [${token.symbol}]: `, Object.keys(error));
+        // do nothing, try next
+    }
+
+    throw new FatalError(`Price not found for ${token.symbol}`);
+  }
+
+  async _getPriceEkubo(token: TokenInfo, amountIn = new Web3Number(1, token.decimals), retry = 0): Promise<number> {
+    const underlying = this.getUnderlying(token);
+    const url = this.EKUBO_API
+      .replace("{{TOKEN_ADDRESS}}", token.address.toString())
+      .replace("{{AMOUNT}}", amountIn.toWei())
+      .replace("{{UNDERLYING_ADDRESS}}", underlying.address.toString());
+    const result = await axios.get(url);
+    const data: any = result.data;
+    const multiplier = 1 / amountIn.toNumber();
+    const outputUnderlying = Number(Web3Number.fromWei(data.total_calculated, underlying.decimals).toFixed(6)) * multiplier;
+    logger.verbose(`Ekubo: ${token.symbol} -> ${underlying.symbol}: ${outputUnderlying}, retry: ${retry}`);
+    if (outputUnderlying === 0 && retry < 3) {
+        // try again with a higher amount
+        const amountIn = new Web3Number(100, token.decimals); // 100 unit of token
+        return await this._getPriceEkubo(token, amountIn, retry + 1);
+    }
+
+    return outputUnderlying;
+  }
+}

package/src/modules/pricer.ts

@@ -21,7 +21,7 @@ export class Pricer extends PricerBase {
 
     // code populates this map during runtime to determine which method to use for a given token
     // The method set will be the first one to try after first attempt
-    private methodToUse: {[tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap'} = {};
+    protected methodToUse: {[tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap'} = {};
 
     /**
      * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB

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

@@ -1809,6 +1809,29 @@ const lstStrategies: IStrategyMetadata<CLVaultStrategySettings>[] = [
     contractDetails: [],
     investmentSteps: []
   },
+  {
+    ...xSTRKSTRK,
+    name: "Ekubo xLBTC/LBTC",
+    description: <></>,
+    address: ContractAddr.from(
+      "0x315a614603b1f702e466aedcbcb1ad97a77eb1192b8bd077e5154d4f2ee4fab"
+    ),
+    launchBlock: 2344809,
+    // must be same order as poolKey token0 and token1
+    depositTokens: [
+      Global.getDefaultTokens().find((t) => t.symbol === "LBTC")!,
+      Global.getDefaultTokens().find((t) => t.symbol === "xLBTC")!,
+    ],
+    additionalInfo: {
+      ...xSTRKSTRK.additionalInfo,
+      quoteAsset: Global.getDefaultTokens().find((t) => t.symbol === "LBTC")!,
+      lstContract: Global.getDefaultTokens().find((t) => t.symbol === "xLBTC")!.address,
+    },
+    faqs: getLSTFAQs("xLBTC"),
+    points: [],
+    contractDetails: [],
+    investmentSteps: []
+  }
 ];
 
 const ETHUSDCRe7Strategy: IStrategyMetadata<CLVaultStrategySettings> = {

package/src/strategies/universal-lst-muliplier-strategy.tsx

@@ -6,7 +6,7 @@ import { Global } from "@/global";
 import { ApproveCallParams, CommonAdapter, ManageCall, Swap, VesuAdapter, VesuModifyDelegationCallParams, VesuMultiplyCallParams, VesuPools } from "./universal-adapters";
 import { AVNU_MIDDLEWARE } from "./universal-adapters/adapter-utils";
 import { LiquidationRiskLevel, SmartContractRiskLevel, TechnicalRiskLevel } from "@/interfaces/risks";
-import { EkuboQuoter, ERC20 } from "@/modules";
+import { EkuboQuoter, ERC20, PricerLST } from "@/modules";
 import { assert, logger } from "@/utils";
 import { SingleTokenInfo } from "./base-strategy";
 import { Call, Contract, uint256 } from "starknet";
@@ -17,7 +17,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
   
   private quoteAmountToFetchPrice = new Web3Number(1, 18);
   
-  constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<UniversalStrategySettings>) {
+  constructor(config: IConfig, pricer: PricerLST, metadata: IStrategyMetadata<UniversalStrategySettings>) {
     super(config, pricer, metadata);
 
     const STRKToken = Global.getDefaultTokens().find(token => token.symbol === 'STRK')!;
@@ -42,9 +42,9 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
 
   // not applicable for this strategy
   // No rewards on collateral or borrowing of LST assets
-  protected async getRewardsAUM(prevAum: Web3Number): Promise<Web3Number> {
-    return Web3Number.fromWei("0", this.asset().decimals);
-  }
+  // protected async getRewardsAUM(prevAum: Web3Number): Promise<Web3Number> {
+  //   return Web3Number.fromWei("0", this.asset().decimals);
+  // }
 
   async getLSTDexPrice() {
     const ekuboQuoter = new EkuboQuoter(this.config);
@@ -82,12 +82,16 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     logger.debug(`${this.getTag()}::getVesuMultiplyCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
     existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
 
+    // - Prices as seen by Vesu contracts, ideal for HF math
     // Price 1 is ok as fallback bcz that would relatively price the 
     // collateral and debt as equal.
     const collateralPrice = collateralisation[0].usdValue > 0 ? collateralisation[0].usdValue / existingCollateralInfo.amount.toNumber() : 1;
     const debtPrice = collateralisation[1].usdValue > 0 ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber() : 1;
     logger.debug(`${this.getTag()}::getVesuMultiplyCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
 
+    // - Prices as seen by actual swap price
+    const dexPrice = await this.getLSTDexPrice();
+
     // compute optimal amount of collateral and debt post addition/removal
     // target hf = collateral * collateralPrice * ltv / debt * debtPrice
     // assuming X to be the usd amount of debt borrowed or repaied (negative). 
@@ -97,11 +101,10 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     // => X = (((collateral + legDepositAmount) * collateralPrice * ltv) - (debt * debtPrice * target hf)) / (target hf - ltv)
     const addedCollateral = params.leg1DepositAmount
       .multipliedBy(params.isDeposit ? 1 : -1)
-    const DEXPrice = await this.getLSTDexPrice();
     logger.verbose(`${this.getTag()}::getVesuMultiplyCall addedCollateral: ${addedCollateral}`);
     const numeratorPart1 = (existingCollateralInfo.amount.plus((addedCollateral))).multipliedBy(collateralPrice).multipliedBy(legLTV);
     const numeratorPart2 = existingDebtInfo.amount.multipliedBy(debtPrice).multipliedBy(this.metadata.additionalInfo.targetHealthFactor);
-    const denominatorPart = this.metadata.additionalInfo.targetHealthFactor - (legLTV / DEXPrice);
+    const denominatorPart = this.metadata.additionalInfo.targetHealthFactor - (legLTV / dexPrice);
     const x_debt_usd = numeratorPart1.minus(numeratorPart2).dividedBy(denominatorPart);
     logger.verbose(`${this.getTag()}::getVesuMultiplyCall x_debt_usd: ${x_debt_usd}`);
     logger.debug(`${this.getTag()}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}, numeratorPart2: ${numeratorPart2}, denominatorPart: ${denominatorPart}`);
@@ -121,6 +124,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     return this.getModifyLeverCall({
       marginAmount,
       debtAmount,
+      lstDexPriceInUnderlying: dexPrice,
       isIncrease: debtAmount.greaterThan(0)
     });
   }
@@ -152,6 +156,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
   async getModifyLeverCall(params: {
     marginAmount: Web3Number, // >0 during deposit
     debtAmount: Web3Number,
+    lstDexPriceInUnderlying: number,
     isIncrease: boolean
   }): Promise<Call[]> {
     assert(!params.marginAmount.isZero() || !params.debtAmount.isZero(), 'Deposit/debt must be non-0');
@@ -175,13 +180,12 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
       manageCalls.push(manageCall1);
     }
 
+    const lstDexPriceInUnderlying = params.lstDexPriceInUnderlying;
     const ekuboQuoter = new EkuboQuoter(this.config);
 
     // compute quotes for margin swap
-    const lstPrice = await this.getLSTExchangeRate();
     const marginSwap: Swap[] = [];
 
-
     // compute quotes for lever swap
     const MAX_SLIPPAGE = 0.01;
     // when increasing, debt is swapped to collateral (LST)
@@ -196,8 +200,8 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     );
     assert(leverSwapQuote.price_impact < MAX_SLIPPAGE, 'getIncreaseLeverCall: Price impact is too high [Debt swap]');
     const leverSwap = ekuboQuoter.getVesuMultiplyQuote(leverSwapQuote, fromToken, toToken);
-    const minExpectedDebt = params.debtAmount.dividedBy(lstPrice).multipliedBy(1 - MAX_SLIPPAGE); // used for increase
-    const maxUsedCollateral = params.debtAmount.abs().dividedBy(lstPrice).multipliedBy(1 + MAX_SLIPPAGE); // +ve for exact amount out, used for decrease
+    const minExpectedDebt = params.debtAmount.dividedBy(lstDexPriceInUnderlying).multipliedBy(1 - MAX_SLIPPAGE); // used for increase
+    const maxUsedCollateral = params.debtAmount.abs().dividedBy(lstDexPriceInUnderlying).multipliedBy(1 + MAX_SLIPPAGE); // +ve for exact amount out, used for decrease
    
     const STEP2_ID = LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON;
     const manage2Info = this.getProofs<VesuModifyDelegationCallParams>(STEP2_ID);
@@ -416,6 +420,54 @@ const hyperxSTRK: UniversalStrategySettings = {
   minHealthFactor: 1.05
 }
 
+const hyperxWBTC: UniversalStrategySettings = {
+  vaultAddress: ContractAddr.from('0x2da9d0f96a46b453f55604313785dc866424240b1c6811d13bef594343db818'),
+  manager: ContractAddr.from('0x75866db44c81e6986f06035206ee9c7d15833ddb22d6a22c016cfb5c866a491'),
+  vaultAllocator: ContractAddr.from('0x57b5c1bb457b5e840a2714ae53ada87d77be2f3fd33a59b4fe709ef20c020c1'),
+  redeemRequestNFT: ContractAddr.from('0x7a5dc288325456f05e70e9616e16bc02ffbe448f4b89f80b47c0970b989c7c'),
+  aumOracle: ContractAddr.from(''),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.1,
+  minHealthFactor: 1.05
+}
+
+const hyperxtBTC: UniversalStrategySettings = {
+  vaultAddress: ContractAddr.from('0x47d5f68477e5637ce0e56436c6b5eee5a354e6828995dae106b11a48679328'),
+  manager: ContractAddr.from('0xc4cc3e08029a0ae076f5fdfca70575abb78d23c5cd1c49a957f7e697885401'),
+  vaultAllocator: ContractAddr.from('0x50bbd4fe69f841ecb13b2619fe50ebfa4e8944671b5d0ebf7868fd80c61b31e'),
+  redeemRequestNFT: ContractAddr.from('0xeac9032f02057779816e38a6cb9185d12d86b3aacc9949b96b36de359c1e3'),
+  aumOracle: ContractAddr.from(''),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.1,
+  minHealthFactor: 1.05
+}
+
+const hyperxsBTC: UniversalStrategySettings = {
+  vaultAddress: ContractAddr.from('0x437ef1e7d0f100b2e070b7a65cafec0b2be31b0290776da8b4112f5473d8d9'),
+  manager: ContractAddr.from('0xc9ac023090625b0be3f6532ca353f086746f9c09f939dbc1b2613f09e5f821'),
+  vaultAllocator: ContractAddr.from('0x60c2d856936b975459a5b4eb28b8672d91f757bd76cebb6241f8d670185dc01'),
+  redeemRequestNFT: ContractAddr.from('0x429e8ee8bc7ecd1ade72630d350a2e0f10f9a2507c45f188ba17fe8f2ab4cf3'),
+  aumOracle: ContractAddr.from(''),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.1,
+  minHealthFactor: 1.05
+}
+
+const hyperxLBTC: UniversalStrategySettings = {
+  vaultAddress: ContractAddr.from('0x38e96a301428d204ab4553799aa386a0f14a5ef9b30a5830be1814e4fb8da1c'),
+  manager: ContractAddr.from('0x18d376446d9df1f783e17aff1f21bac3d97aa3ba378e367742cdd744468ad35'),
+  vaultAllocator: ContractAddr.from('0x3e98774ca0508505ba6d7f17d95ec391648f44f947b0d211241464a4f5b9b20'),
+  redeemRequestNFT: ContractAddr.from('0x268017b4c8b2117ca0136d9a77e3666db44b143447566f0746ca0b1c9ab1e72'),
+  aumOracle: ContractAddr.from('0x521a3f339c65e918e0d8a065b14baef1ea25676bb7fca1e0238ac47e20d7755'),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.1,
+  minHealthFactor: 1.05
+}
+
 function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string) {
   return [
     `Deposit ${underlyingSymbol} into the vault`,
@@ -427,7 +479,7 @@ function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string) {
   ]
 }
 
-function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addresses: UniversalStrategySettings): IStrategyMetadata<UniversalStrategySettings> {
+function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addresses: UniversalStrategySettings, isPreview: boolean = false): IStrategyMetadata<UniversalStrategySettings> {
   return {
     name: `Hyper ${lstSymbol}`,
     description: getDescription(lstSymbol),
@@ -448,10 +500,15 @@ function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addres
     contractDetails: getContractDetails(addresses),
     faqs: getFAQs(lstSymbol, underlyingSymbol),
     investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
+    isPreview: isPreview
   }
 }
 
 export const HyperLSTStrategies: IStrategyMetadata<UniversalStrategySettings>[] =
   [
-    getStrategySettings('xSTRK', 'STRK', hyperxSTRK),
+    getStrategySettings('xSTRK', 'STRK', hyperxSTRK, false),
+    getStrategySettings('xWBTC', 'WBTC', hyperxWBTC, true),
+    getStrategySettings('xtBTC', 'tBTC', hyperxtBTC, true),
+    getStrategySettings('xsBTC', 'solvBTC', hyperxsBTC, true),
+    getStrategySettings('xLBTC', 'LBTC', hyperxLBTC, true),
   ]

package/src/strategies/universal-strategy.tsx

@@ -203,6 +203,14 @@ export class UniversalStrategy<
    * @returns {Promise<number>} The weighted average APY across all pools
    */
   async netAPY(): Promise<{ net: number, splits: { apy: number, id: string }[] }> {
+    if (this.metadata.isPreview) {
+      return { net: 0, splits: [{
+        apy: 0, id: 'base'
+      }, {
+        apy: 0, id: 'defispring'
+      }] };
+    }
+    
     const prevAUM = await this.getPrevAUM();
    
     // get Vesu pools, positions and APYs
@@ -302,20 +310,20 @@ export class UniversalStrategy<
     const underlying = this.asset();
     let vesuAum = Web3Number.fromWei("0", underlying.decimals);
     
+    let tokenUnderlyingPrice = await this.pricer.getPrice(this.asset().symbol);
+    
     // handle collateral
     if (legAUM[0].token.address.eq(underlying.address)) {
       vesuAum = vesuAum.plus(legAUM[0].amount);
     } else {
-      const tokenPrice = await this.pricer.getPrice(legAUM[1].token.symbol);
-      vesuAum = vesuAum.plus(legAUM[1].usdValue / tokenPrice.price);
+      vesuAum = vesuAum.plus(legAUM[1].usdValue / tokenUnderlyingPrice.price);
     }
 
     // handle debt
     if (legAUM[1].token.address.eq(underlying.address)) {
       vesuAum = vesuAum.minus(legAUM[1].amount);
     } else {
-      const tokenPrice = await this.pricer.getPrice(legAUM[1].token.symbol);
-      vesuAum = vesuAum.minus(legAUM[1].usdValue / tokenPrice.price);
+      vesuAum = vesuAum.minus(legAUM[1].usdValue / tokenUnderlyingPrice.price);
     };
 
     logger.verbose(`${this.getTag()} Vesu AUM: ${vesuAum}, legCollateral: ${legAUM[0].amount.toNumber()}, legDebt: ${legAUM[1].amount.toNumber()}`);