@strkfarm/sdk 2.0.0-dev.43 → 2.0.0-dev.45

package/src/modules/pricer.ts

@@ -1,6 +1,6 @@
 import axios from "axios";
 import { FatalError, Global } from "@/global";
-import { TokenInfo } from "@/interfaces/common";
+import { PriceMethod, TokenInfo } from "@/interfaces/common";
 import { IConfig } from "@/interfaces/common";
 import { Web3Number } from "@/dataTypes";
 import { PricerBase } from "./pricerBase";
@@ -14,8 +14,6 @@ export interface PriceInfo {
     timestamp: Date
 }
 
-type PriceMethod = 'AvnuApi' | 'Coinbase' | 'Coinmarketcap' | 'Ekubo' | 'Avnu';
-
 const PRICE_METHOD_PRIORITY: PriceMethod[] = [
     'AvnuApi',
     'Coinbase',
@@ -164,22 +162,15 @@ export class Pricer extends PricerBase {
     }
 
     async _getPrice(token: TokenInfo): Promise<number> {
-        const pinned = this.methodToUse[token.symbol];
-        if (pinned) {
-            logger.verbose(`Fetching price of ${token.symbol} using pinned ${pinned}`);
-            try {
-                return await this._tryPriceMethod(token, pinned);
-            } catch (error: any) {
-                console.warn(`${pinned}: pinned price failed [${token.symbol}]: `, error.message);
-                delete this.methodToUse[token.symbol];
-            }
-        }
+        const methodsToTry = this._getMethodsToTry(token);
 
-        for (const method of PRICE_METHOD_PRIORITY) {
+        for (const method of methodsToTry) {
             logger.verbose(`Fetching price of ${token.symbol} using ${method}`);
             try {
                 const result = await this._tryPriceMethod(token, method);
-                this.methodToUse[token.symbol] = method;
+                if (!token.priceMethod) {
+                    this.methodToUse[token.symbol] = method;
+                }
                 return result;
             } catch (error: any) {
                 console.warn(`${method}: price err [${token.symbol}]: `, error.message);
@@ -189,6 +180,27 @@ export class Pricer extends PricerBase {
         throw new FatalError(`Price not found for ${token.symbol}`);
     }
 
+    protected _getMethodsToTry(token: TokenInfo): PriceMethod[] {
+        const methods: PriceMethod[] = [];
+
+        if (token.priceMethod) {
+            methods.push(token.priceMethod);
+        }
+
+        const pinned = this.methodToUse[token.symbol];
+        if (pinned && pinned !== token.priceMethod) {
+            methods.push(pinned);
+        }
+
+        for (const method of PRICE_METHOD_PRIORITY) {
+            if (!methods.includes(method)) {
+                methods.push(method);
+            }
+        }
+
+        return methods;
+    }
+
     protected async _tryPriceMethod(token: TokenInfo, method: PriceMethod): Promise<number> {
         switch (method) {
             case 'AvnuApi':

package/src/modules/zkLend.ts

@@ -2,7 +2,7 @@ import axios from "axios";
 import BigNumber from "bignumber.js";
 import { Web3Number } from "@/dataTypes/bignumber.browser";
 import { FatalError, Global } from "@/global";
-import { TokenInfo } from "@/interfaces";
+import { TokenIndexingType, TokenInfo } from "@/interfaces";
 import { ILending, ILendingPosition, LendingToken, MarginType } from "@/interfaces/lending";
 import { ContractAddr } from "@/dataTypes/address";
 import { IConfig } from "@/interfaces";
@@ -42,7 +42,8 @@ export class ZkLend extends ILending implements ILending {
                     decimals: pool.token.decimals,
                     borrowFactor: Web3Number.fromWei(pool.borrow_factor.value, pool.borrow_factor.decimals),
                     collareralFactor,
-                    displayDecimals: 2
+                    displayDecimals: 2,
+                    indexingType: TokenIndexingType.IGNORE,
                 }
                 this.tokens.push(token);
             });

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

@@ -4,13 +4,15 @@ import { PricerBase } from "@/modules/pricerBase";
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { Global } from "@/global";
 import { ApproveCallParams, APYType, AvnuSwapCallParams, BaseAdapterConfig, CommonAdapter, ManageCall, PositionInfo, TokenTransferAdapter, VesuModifyPositionAdapter, VesuMultiplyAdapter, VesuPools, VesuSupplyOnlyAdapter } from "./universal-adapters";
+import { VesuAdapter } from "./universal-adapters/vesu-adapter";
 import { AVNU_EXCHANGE } from "./universal-adapters/adapter-utils";
 import { DepegRiskLevel, LiquidationRiskLevel, SmartContractRiskLevel, TechnicalRiskLevel } from "@/interfaces/risks";
 import { AvnuWrapper, EkuboQuoter, ERC20, LSTAPRService, PricerFromApi, PricerLST } from "@/modules";
 import { assert, logger } from "@/utils";
+import { findMaxInputWithSlippage } from "@/utils/math-utils";
 import { SingleActionAmount, SingleTokenInfo, UserPositionCard, UserPositionCardsInput } from "./base-strategy";
 import { SVKStrategy } from "./svk-strategy";
-import { Call, Contract, uint256 } from "starknet";
+import { Call, Contract, num, uint256, BlockIdentifier } from "starknet";
 import ERC4626Abi from "@/data/erc4626.abi.json";
 import { AdapterOptimizer } from "./universal-adapters/adapter-optimizer";
 import { LSTPriceType } from "./types";
@@ -544,48 +546,318 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
     splits: { apy: number; id: string }[];
   }> {
     const unusedBalance = await this.getUnusedBalance();
-    const maxDeposits = await this.maxNewDeposits({ isAPYComputation: true });
-    const lstAPY = await this.getLSTAPR(this.getLSTUnderlyingTokenInfo().address);
+    const maxNewDeposits = await this.maxNewDeposits({
+      isAPYComputation: true,
+    });
+    const lstAPY = await this.getLSTAPR(
+      this.getLSTUnderlyingTokenInfo().address,
+    );
 
-    if (maxDeposits * 1.5 < unusedBalance.amount.toNumber()) {
+    // if unused balance is > max servicable from loan, we are limited by the max borrowing we can do
+    // we also allow accepting little higher deposits (1.5x) to have room for future looping when theres more liquidity or debt cap rises
+    if (maxNewDeposits * 1.5 < unusedBalance.amount.toNumber()) {
+      // we have excess, just use real APY
       logger.verbose(
         `${this.getTag()}::netAPY: unused balance is > max servicable from loan, lstAPY: ${lstAPY}`,
       );
-      // TODO, need to add the unused balance APY
-      const output = await super.netAPY();
+      const { positions, baseAPYs, rewardAPYs } = await this.getVesuAPYs();
+      const unusedBalanceAPY = await this.getUnusedBalanceAPY();
+      baseAPYs.push(...[unusedBalanceAPY.apy]);
+      rewardAPYs.push(0);
+
+      const weights = positions.map((p: VaultPosition, index: number) => p.usdValue * (index % 2 == 0 ? 1 : -1));
+      weights.push(unusedBalanceAPY.weight);
+
+      const prevAUM = await this.getPrevAUM();
+      const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+      const prevAUMUSD = prevAUM.multipliedBy(price.price);
+      const output = await this.returnNetAPY(baseAPYs, rewardAPYs, weights, prevAUMUSD);
       output.splits.push({ apy: lstAPY, id: "lst_apy" });
       return output;
     } else {
+      // we have little bit room to accept more deposits, we use theoretical max APY
       logger.verbose(
         `${this.getTag()}::netAPY: we can take more deposits, use theoretical max APY`,
       );
-      const output = await super.netAPY();
+      const { positions, baseAPYs, rewardAPYs } = await this.getVesuAPYs();
+      const weights = positions.map(
+        (p: VaultPosition, index: number) => p.usdValue * (index % 2 == 0 ? 1 : -1),
+      );
+      const aum = weights.reduce((acc: number, curr: number) => acc + curr, 0);
+      const output = await this.returnNetAPY(
+        baseAPYs,
+        rewardAPYs,
+        weights,
+        new Web3Number(
+          aum.toFixed(9),
+          this.getLSTUnderlyingTokenInfo().decimals,
+        ),
+      );
       output.splits.push({ apy: lstAPY, id: "lst_apy" });
       return output;
     }
   }
 
-  async maxNewDeposits(
-    params: { isAPYComputation: boolean } = { isAPYComputation: false },
-  ) {
-    let numerator = 0;
-    for (let adapter of this.getVesuMultiplyAdapters()) {
-      const maxDepositInfo = await adapter.maxDeposit();
-      numerator += maxDepositInfo.amount.toNumber();
+  async getVesuAPYs() {
+    const vesuAdapters = this.getVesuAdapters();
+    const allVesuPools = await VesuAdapter.getVesuPools();
+    const pools = vesuAdapters.map((vesuAdapter) => {
+      return allVesuPools.pools.find(p => vesuAdapter.config.poolId.eqString(num.getHexString(p.id)));
+    });
+    logger.verbose(`${this.metadata.name}::netAPY: vesu-pools: ${JSON.stringify(pools)}`);
+    if (pools.some(p => !p)) {
+      throw new Error('Pool not found');
     }
-    return numerator;
+    const positions = await this.getVesuPositions();
+    logger.verbose(`${this.metadata.name}::netAPY: positions: ${JSON.stringify(positions)}`);
+    const baseAPYs: number[] = [];
+    const rewardAPYs: number[] = [];
+
+    for (const [index, pool] of pools.entries()) {
+      const vesuAdapter = vesuAdapters[index];
+      const collateralAsset = pool.assets.find((a: any) => a.symbol.toLowerCase() === vesuAdapter.config.collateral.symbol.toLowerCase())?.stats!;
+      const debtAsset = pool.assets.find((a: any) => a.symbol.toLowerCase() === vesuAdapter.config.debt.symbol.toLowerCase())?.stats!;
+      const supplyApy = Number(collateralAsset.supplyApy.value || 0) / 1e18;
+
+      const lstAPY = await this.getLSTAPR(vesuAdapter.config.collateral.address);
+      logger.verbose(`${this.metadata.name}::netAPY: ${vesuAdapter.config.collateral.symbol} LST APR from Endur: ${lstAPY}`);
+
+      baseAPYs.push(...[supplyApy + lstAPY, Number(debtAsset.borrowApr.value) / 1e18]);
+      rewardAPYs.push(...[Number(collateralAsset.defiSpringSupplyApr?.value || "0") / 1e18, 0]);
+    }
+    logger.verbose(`${this.metadata.name}::netAPY: baseAPYs: ${JSON.stringify(baseAPYs)}`);
+    logger.verbose(`${this.metadata.name}::netAPY: rewardAPYs: ${JSON.stringify(rewardAPYs)}`);
+
+    assert(baseAPYs.length == positions.length, 'APYs and positions length mismatch');
+
+    return {
+      baseAPYs,
+      rewardAPYs,
+      positions
+    }
+  }
+
+  protected async returnNetAPY(baseAPYs: number[], rewardAPYs: number[], weights: number[], prevAUMUSD: Web3Number) {
+    if (weights.every(p => p == 0)) {
+      return {
+        net: 0, splits: [{
+          apy: 0, id: 'base'
+        }, {
+          apy: 0, id: 'defispring'
+        }]
+      };
+    }
+
+    const baseAPY = this.computeAPY(baseAPYs, weights, prevAUMUSD);
+    const rewardAPY = this.computeAPY(rewardAPYs, weights, prevAUMUSD);
+    const netAPY = baseAPY + rewardAPY;
+    logger.verbose(`${this.metadata.name}::netAPY: net: ${netAPY}, baseAPY: ${baseAPY}, rewardAPY: ${rewardAPY}`);
+    return {
+      net: netAPY, splits: [{
+        apy: baseAPY, id: 'base'
+      }, {
+        apy: rewardAPY, id: 'defispring'
+      }]
+    };
   }
 
   protected async getUnusedBalanceAPY() {
     const unusedBalance = await this.getUnusedBalance();
-    const underlying = this.getLSTUnderlyingTokenInfo();
+    const vesuAdapter = this.getVesuSameTokenAdapter();
+    const underlying = vesuAdapter.config.debt;
     const lstAPY = await this.getLSTAPR(underlying.address);
     return {
       apy: lstAPY,
-      weight: unusedBalance.usdValue,
+      weight: unusedBalance.usdValue
     };
   }
 
+  private computeAPY(apys: number[], weights: number[], currentAUM: Web3Number) {
+    assert(apys.length === weights.length, "APYs and weights length mismatch");
+    const weightedSum = apys.reduce((acc, apy, i) => acc + apy * weights[i], 0);
+    logger.verbose(`${this.getTag()} computeAPY: apys: ${JSON.stringify(apys)}, weights: ${JSON.stringify(weights)}, weightedSum: ${weightedSum}, currentAUM: ${currentAUM}`);
+    return weightedSum / currentAUM.toNumber();
+  }
+
+  getVesuAdapters(): VesuAdapter[] {
+    const multiply = this.getVesuMultiplyAdapters();
+    return multiply.map(m => m._vesuAdapter);
+  }
+
+  async getVesuPositions(blockNumber: BlockIdentifier = 'latest'): Promise<VaultPosition[]> {
+    const adapters = this.getVesuAdapters();
+    const positions: VaultPosition[] = [];
+    for (const adapter of adapters) {
+      positions.push(...await adapter.getPositions(this.config, blockNumber));
+    }
+    return positions;
+  }
+
+  async getUnusedBalance(): Promise<SingleTokenInfo> {
+    const balance = await (new ERC20(this.config)).balanceOf(this.asset().address, this.metadata.additionalInfo.vaultAllocator, this.asset().decimals);
+    const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+    const usdValue = Number(balance.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount: balance,
+      usdValue
+    };
+  }
+
+  async maxNewDeposits(
+    params: { isAPYComputation: boolean } = { isAPYComputation: false },
+  ) {
+    const maxBorrowableAmounts = await this.getMaxBorrowableAmount(params);
+    let numerator = 0;
+
+    for (let adapter of this.getVesuAdapters()) {
+      const maxBorrowableAmountInfo = maxBorrowableAmounts.maxBorrowables.find(
+        (b) => b.borrowableAsset.address.eq(adapter.config.debt.address),
+      );
+      if (!maxBorrowableAmountInfo || !maxBorrowableAmountInfo?.amount) {
+        throw new Error(
+          `Max borrowable amount not found for adapter: ${adapter.config.debt.symbol}`,
+        );
+      }
+
+      numerator +=
+        (this.metadata.additionalInfo.targetHealthFactor *
+          maxBorrowableAmountInfo.amount.toNumber()) /
+        maxBorrowableAmountInfo.ltv;
+    }
+
+    return numerator - maxBorrowableAmounts.netMaxBorrowableAmount.toNumber();
+  }
+
+  async getMaxBorrowableAmount(
+    params: { isAPYComputation: boolean } = { isAPYComputation: false },
+  ) {
+    const vesuAdapters = this.getVesuAdapters();
+    let netMaxBorrowableAmount = Web3Number.fromWei("0", this.getLSTUnderlyingTokenInfo().decimals);
+    const maxBorrowables: {amount: Web3Number, dexSwappableAmount: Web3Number, maxBorrowableAmount: Web3Number, borrowableAsset: TokenInfo, ltv: number, poolId: ContractAddr}[] = [];
+    for (const vesuAdapter of vesuAdapters) {
+      const output = await this.getMaxBorrowableAmountByVesuAdapter(
+        vesuAdapter,
+        params.isAPYComputation,
+      );
+      const ltv = await vesuAdapter.getLTVConfig(this.config);
+      maxBorrowables.push({...output, ltv, poolId: vesuAdapter.config.poolId});
+    }
+    maxBorrowables.sort((a, b) => b.amount.toNumber() - a.amount.toNumber());
+    netMaxBorrowableAmount = maxBorrowables.reduce(
+      (acc, curr) => acc.plus(curr.amount),
+      Web3Number.fromWei("0", this.getLSTUnderlyingTokenInfo().decimals),
+    );
+    return { netMaxBorrowableAmount, maxBorrowables };
+  }
+
+  async getMaxSwappableWithMaxSlippage(
+    fromToken: TokenInfo,
+    toToken: TokenInfo,
+    maxSlippage: number,
+    maxAmount: Web3Number,
+  ) {
+    const output = await findMaxInputWithSlippage({
+      apiGetOutput: async (inputAmount: number): Promise<number> => {
+        const ekuboQuoter = new EkuboQuoter(this.config, this.pricer);
+        await new Promise((resolve) => setTimeout(resolve, 1000)); // artificial delay, to avoid rate limit
+        const quote = await ekuboQuoter.getQuoteExactInput(
+          fromToken.address.address,
+          toToken.address.address,
+          new Web3Number(inputAmount.toFixed(9), fromToken.decimals),
+        );
+        return Web3Number.fromWei(
+          quote.total_calculated.toString(),
+          toToken.decimals,
+        ).toNumber();
+      },
+      maxInput: maxAmount.toNumber(),
+      maxSlippagePercent: maxSlippage,
+      tolerance: 0.001,
+      referenceRate: 1,
+    });
+    return new Web3Number(output.optimalInput, fromToken.decimals);
+  }
+
+  async getMaxBorrowableAmountByVesuAdapter(
+    vesuAdapter: VesuAdapter,
+    isAPYComputation: boolean,
+  ) {
+    const lstAPY = await this.getLSTAPR(
+      this.getLSTUnderlyingTokenInfo().address,
+    );
+    const maxInterestRate = lstAPY * 0.8;
+    const { maxDebtToHave: maxBorrowableAmount, currentDebt } =
+      await vesuAdapter.getMaxBorrowableByInterestRate(
+        this.config,
+        vesuAdapter.config.debt,
+        maxInterestRate,
+      );
+    const debtCap = await vesuAdapter.getDebtCap(this.config);
+
+    if (currentDebt.gte(debtCap)) {
+      return {
+        amount: Web3Number.fromWei("0", vesuAdapter.config.debt.decimals),
+        dexSwappableAmount: Web3Number.fromWei(
+          "0",
+          vesuAdapter.config.debt.decimals,
+        ),
+        maxBorrowableAmount: Web3Number.fromWei(
+          "0",
+          vesuAdapter.config.debt.decimals,
+        ),
+        borrowableAsset: vesuAdapter.config.debt,
+      };
+    }
+
+    const availableToBorrow = debtCap.minus(currentDebt);
+
+    const maxBorrowable = maxBorrowableAmount
+      .minimum(availableToBorrow)
+      .multipliedBy(0.999);
+    // Dont compute precise max swappable for APY computation
+    if (
+      vesuAdapter.config.debt.address.eq(
+        this.getLSTUnderlyingTokenInfo().address,
+      ) ||
+      isAPYComputation
+    ) {
+      return {
+        amount: maxBorrowable,
+        dexSwappableAmount: maxBorrowable,
+        maxBorrowableAmount: maxBorrowable,
+        borrowableAsset: vesuAdapter.config.debt,
+      };
+    }
+    // Want < 0.02% slippage
+    try {
+      const maxSwappable = await this.getMaxSwappableWithMaxSlippage(
+        vesuAdapter.config.debt,
+        this.getLSTUnderlyingTokenInfo(),
+        0.0002,
+        maxBorrowable,
+      );
+      return {
+        amount: maxBorrowable.minimum(maxSwappable),
+        dexSwappableAmount: maxSwappable,
+        maxBorrowableAmount: maxBorrowable,
+        borrowableAsset: vesuAdapter.config.debt,
+      };
+    } catch (error) {
+      logger.warn(`${this.getTag()}: Failed to get max swappable: ${error}`);
+      const maxSwappable = Web3Number.fromWei(
+        "0",
+        vesuAdapter.config.debt.decimals,
+      );
+      return {
+        amount: maxBorrowable.minimum(maxSwappable),
+        dexSwappableAmount: maxSwappable,
+        maxBorrowableAmount: maxBorrowable,
+        borrowableAsset: vesuAdapter.config.debt,
+      };
+    }
+  }
+
   async getAUM(unrealizedAUM: boolean = false): Promise<{ net: SingleTokenInfo, prevAum: Web3Number, splits: PositionInfo[] }> {
     const underlying = this.asset();
     assert(underlying.symbol.startsWith('x'), 'Underlying is not an LST of Endur');
@@ -1002,6 +1274,9 @@ const hyperxWBTC: HyperLSTStrategySettings = {
   borrowable_assets: [{
     tokenInfo: Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!,
     poolId: VesuPools.Re7xBTC,
+  }, {
+    tokenInfo: Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!,
+    poolId: VesuPools.Prime,
   }],
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!,
   quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!.decimals),
@@ -1119,7 +1394,7 @@ function createHyperLSTSettings(
   )!;
   return {
     isPaused: false,
-    liveStatus: StrategyLiveStatus.HOT,
+    liveStatus: lstSymbol === 'xSTRK' ? StrategyLiveStatus.HOT : ((lstSymbol == 'xWBTC' || lstSymbol == 'xtBTC') ? StrategyLiveStatus.ACTIVE : StrategyLiveStatus.DEPRECATED),
     isAudited: true,
     isInstantWithdrawal: false,
     hideHarvestInfo: true,
@@ -1158,8 +1433,7 @@ const HYPER_LST_SECURITY = {
   },
   accessControl: {
     type: AccessControlType.STANDARD_ACCOUNT,
-    addresses: [ContractAddr.from("0x0")],
-    timeLock: "2 Days",
+    addresses: [ContractAddr.from("0x03495dd1e4838aa06666aac236036d86e81a6553e222fc02e70c2cbc0062e8d0")],
   },
 };
 

package/src/strategies/yoloVault.ts

@@ -9,6 +9,7 @@ import {
   RiskFactor,
   SourceCodeType,
   StrategyLiveStatus,
+  TokenIndexingType,
   TokenInfo,
   UnwrapLabsCurator,
   Protocols,
@@ -878,6 +879,7 @@ const vesuPrimeUSDC: TokenInfo = {
   decimals: 18,
   logo: usdc.logo,
   displayDecimals: 2,
+  indexingType: TokenIndexingType.IGNORE,
 };
 
 const strk = Global.getDefaultTokens().find((t) => t.symbol === "STRK")!;