@strkfarm/sdk 1.1.8 → 1.1.9

package/src/strategies/universal-strategy.tsx

@@ -13,13 +13,24 @@ import { AvnuWrapper, ERC20 } from "@/modules";
 import { AVNU_MIDDLEWARE } from "./universal-adapters/adapter-utils";
 import { VesuHarvests } from "@/modules/harvests";
 
+export interface UniversalManageCall {
+  proofs: string[];
+  manageCall: ManageCall;
+  step: UNIVERSAL_MANAGE_IDS;
+}
+
 export interface UniversalStrategySettings {
   vaultAddress: ContractAddr,
   manager: ContractAddr,
   vaultAllocator: ContractAddr,
   redeemRequestNFT: ContractAddr,
   aumOracle: ContractAddr,
+
+  // Individual merkle tree leaves
   leafAdapters: LeafAdapterFn<any>[],
+
+  // Useful for returning adapter class objects that can compute
+  // certain things for us (e.g. positions, hfs)
   adapters: {id: string, adapter: BaseAdapter}[],
   targetHealthFactor: number,
   minHealthFactor: number
@@ -192,28 +203,38 @@ export class UniversalStrategy<
    * @returns {Promise<number>} The weighted average APY across all pools
    */
   async netAPY(): Promise<{ net: number, splits: { apy: number, id: string }[] }> {
-    const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
-    const pools = await VesuAdapter.getVesuPools();
-    const pool1 = pools.pools.find(p => vesuAdapter1.config.poolId.eqString(num.getHexString(p.id)));
-    const pool2 = pools.pools.find(p => vesuAdapter2.config.poolId.eqString(num.getHexString(p.id)));
-    if (!pool1 || !pool2) {
+    const prevAUM = await this.getPrevAUM();
+   
+    // get Vesu pools, positions and APYs
+    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');
     };
-    const collateralAsset1 = pool1.assets.find((a: any) => a.symbol === vesuAdapter1.config.collateral.symbol)?.stats!;
-    const debtAsset1 = pool1.assets.find((a: any) => a.symbol === vesuAdapter1.config.debt.symbol)?.stats!;
-    const collateralAsset2 = pool2.assets.find((a: any) => a.symbol === vesuAdapter2.config.collateral.symbol)?.stats!;
-    const debtAsset2 = pool2.assets.find((a: any) => a.symbol === vesuAdapter2.config.debt.symbol)?.stats!;
-
-    // supplyApy: { value: '8057256029163289', decimals: 18 },
-    // defiSpringSupplyApr: { value: '46856062629264560', decimals: 18 },
-    // borrowApr: { value: '12167825982336000', decimals: 18 },
-    const collateral1APY = Number(collateralAsset1.supplyApy.value) / 1e18;
-    const debt1APY = Number(debtAsset1.borrowApr.value) / 1e18;
-    const collateral2APY = Number(collateralAsset2.supplyApy.value) / 1e18;
-    const debt2APY = Number(debtAsset2.borrowApr.value) / 1e18;
-
-    const positions = await this.getVaultPositions();
+    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 === vesuAdapter.config.collateral.symbol)?.stats!;
+      const debtAsset = pool.assets.find((a: any) => a.symbol === vesuAdapter.config.debt.symbol)?.stats!;
+      const supplyApy = Number(collateralAsset.supplyApy.value || 0) / 1e18;
+      const lstAPY = Number(collateralAsset.lstApr?.value || 0) / 1e18;
+      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)}`);
+
+    // Else further compute will fail
+    assert(baseAPYs.length == positions.length, 'APYs and positions length mismatch');
+
+    // If no positions, return 0
     if (positions.every(p => p.amount.isZero())) {
       return { net: 0, splits: [{
         apy: 0, id: 'base'
@@ -221,12 +242,13 @@ export class UniversalStrategy<
         apy: 0, id: 'defispring'
       }]};
     }
+
+    // Compute APy using weights
     const weights = positions.map((p, index) => p.usdValue * (index % 2 == 0 ? 1 : -1));
-    const baseAPYs = [collateral1APY, debt1APY, collateral2APY, debt2APY];
-    assert(positions.length == baseAPYs.length, "Positions and APYs length mismatch");
-    const rewardAPYs = [Number(collateralAsset1.defiSpringSupplyApr.value) / 1e18, 0, Number(collateralAsset2.defiSpringSupplyApr.value) / 1e18, 0];
-    const baseAPY = this.computeAPY(baseAPYs, weights);
-    const rewardAPY = this.computeAPY(rewardAPYs, weights);
+    const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+    const prevAUMUSD = prevAUM.multipliedBy(price.price);
+    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: [{
@@ -236,11 +258,11 @@ export class UniversalStrategy<
     }] };
   }
 
-  private computeAPY(apys: number[], weights: number[]) {
+  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);
-    const totalWeight = weights.reduce((acc, weight) => acc + weight, 0);
-    return weightedSum / totalWeight;
+    logger.verbose(`${this.getTag()} computeAPY: apys: ${JSON.stringify(apys)}, weights: ${JSON.stringify(weights)}, weightedSum: ${weightedSum}, currentAUM: ${currentAUM}`);
+    return weightedSum / currentAUM.toNumber();
   }
 
   /**
@@ -275,33 +297,61 @@ export class UniversalStrategy<
     };
   }
 
-  async getAUM(): Promise<{net: SingleTokenInfo, prevAum: Web3Number, splits: {id: string, aum: Web3Number}[]}> {
+  protected async getVesuAUM(adapter: VesuAdapter) {
+    const legAUM = await adapter.getPositions(this.config);
+    const underlying = this.asset();
+    let vesuAum = Web3Number.fromWei("0", underlying.decimals);
+    
+    // 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);
+    }
+
+    // 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);
+    };
+
+    logger.verbose(`${this.getTag()} Vesu AUM: ${vesuAum}, legCollateral: ${legAUM[0].amount.toNumber()}, legDebt: ${legAUM[1].amount.toNumber()}`);
+    return vesuAum;
+  }
+
+  async getPrevAUM() {
     const currentAUM: bigint = await this.contract.call('aum', []) as bigint;
-    const lastReportTime = await this.contract.call('last_report_timestamp', []);
+    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
+    logger.verbose(`${this.getTag()} Prev AUM: ${prevAum}`);
+    return prevAum;
+  }
+
+  async getAUM(): Promise<{net: SingleTokenInfo, prevAum: Web3Number, splits: {id: string, aum: Web3Number}[]}> {
+    const prevAum = await this.getPrevAUM();
 
     const token1Price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
 
-    // calculate actual aum
-    const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
-    const leg1AUM = await vesuAdapter1.getPositions(this.config);
-    const leg2AUM = await vesuAdapter2.getPositions(this.config);
+    // calculate vesu aum
+    const vesuAdapters = this.getVesuAdapters();
+    let vesuAum = Web3Number.fromWei("0", this.asset().decimals);
+    for (const adapter of vesuAdapters) {
+      vesuAum = vesuAum.plus(await this.getVesuAUM(adapter));
+    }
 
+    // account unused balance as aum as well (from vault allocator)
     const balance = await this.getUnusedBalance();
     logger.verbose(`${this.getTag()} unused balance: ${balance.amount.toNumber()}`);
 
-    const vesuAum = leg1AUM[0].amount
-      .plus(leg2AUM[0].usdValue / token1Price.price)
-      .minus(leg1AUM[1].usdValue / token1Price.price)
-      .minus(leg2AUM[1].amount);
-    logger.verbose(`${this.getTag()} Vesu AUM: leg1: ${leg1AUM[0].amount.toNumber()}, ${leg1AUM[1].amount.toNumber()}, leg2: ${leg2AUM[0].amount.toNumber()}, ${leg2AUM[1].amount.toNumber()}`);
-
+    // Initiate return values
     const zeroAmt = Web3Number.fromWei('0', this.asset().decimals);
     const net = {
       tokenInfo: this.asset(),
       amount: zeroAmt,
       usdValue: 0
     };
-    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
     if (vesuAum.isZero()) {
       return { net, splits: [{
         aum: zeroAmt, id: AUMTypes.FINALISED
@@ -312,20 +362,10 @@ export class UniversalStrategy<
     const aumToken = vesuAum.plus(balance.amount);
     logger.verbose(`${this.getTag()} Actual AUM: ${aumToken}`);
 
-    // calculate estimated growth from strk rewards
-    const netAPY = await this.netAPY();
-    // account only 80% of value
-    const defispringAPY = (netAPY.splits.find(s => s.id === 'defispring')?.apy || 0) * 0.8;
-    if (!defispringAPY) throw new Error('DefiSpring APY not found');
-
-    const timeDiff = (Math.round(Date.now() / 1000) - Number(lastReportTime));
-    const growthRate = timeDiff * defispringAPY / (365 * 24 * 60 * 60);
-    const rewardAssets = prevAum.multipliedBy(growthRate);
-    logger.verbose(`${this.getTag()} DefiSpring AUM time difference: ${timeDiff}`);
-    logger.verbose(`${this.getTag()} Current AUM: ${currentAUM}`);
-    logger.verbose(`${this.getTag()} Net APY: ${JSON.stringify(netAPY)}`);
-    logger.verbose(`${this.getTag()} rewards AUM: ${rewardAssets}`);
+    // compute rewards contribution to AUM
+    const rewardAssets = await this.getRewardsAUM(prevAum);
 
+    // Sum up and return
     const newAUM = aumToken.plus(rewardAssets);
     logger.verbose(`${this.getTag()} New AUM: ${newAUM}`);
     
@@ -341,6 +381,27 @@ export class UniversalStrategy<
     return { net, splits, prevAum };
   }
 
+  // account for future rewards (e.g. defispring rewards)
+  protected async getRewardsAUM(prevAum: Web3Number) {
+    const lastReportTime = await this.contract.call('last_report_timestamp', []);
+    // - calculate estimated growth from strk rewards
+    const netAPY = await this.netAPY();
+    // account only 80% of value
+    const defispringAPY = (netAPY.splits.find(s => s.id === 'defispring')?.apy || 0) * 0.8;
+    if (!defispringAPY) throw new Error('DefiSpring APY not found');
+
+    // compute rewards contribution to AUM
+    const timeDiff = (Math.round(Date.now() / 1000) - Number(lastReportTime));
+    const growthRate = timeDiff * defispringAPY / (365 * 24 * 60 * 60);
+    const rewardAssets = prevAum.multipliedBy(growthRate);
+    logger.verbose(`${this.getTag()} DefiSpring AUM time difference: ${timeDiff}`);
+    logger.verbose(`${this.getTag()} Current AUM: ${prevAum.toString()}`);
+    logger.verbose(`${this.getTag()} Net APY: ${JSON.stringify(netAPY)}`);
+    logger.verbose(`${this.getTag()} rewards AUM: ${rewardAssets}`);
+
+    return rewardAssets;
+  }
+
   getVesuAdapters() {
     const vesuAdapter1 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG1) as VesuAdapter;
     const vesuAdapter2 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG2) as VesuAdapter;
@@ -352,11 +413,24 @@ export class UniversalStrategy<
     return [vesuAdapter1, vesuAdapter2];
   }
 
+  async getVesuPositions(): Promise<VaultPosition[]> {
+    const adapters = this.getVesuAdapters();
+    const positions: VaultPosition[] = [];
+    for (const adapter of adapters) {
+      positions.push(...await adapter.getPositions(this.config));
+    }
+    return positions;
+  }
+
   async getVaultPositions(): Promise<VaultPosition[]> {
-    const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
-    const leg1Positions = await vesuAdapter1.getPositions(this.config);
-    const leg2Positions = await vesuAdapter2.getPositions(this.config);
-    return [...leg1Positions, ...leg2Positions];
+    const vesuPositions = await this.getVesuPositions();
+    const unusedBalance = await this.getUnusedBalance();
+    return [...vesuPositions, {
+      amount: unusedBalance.amount,
+      usdValue: unusedBalance.usdValue,
+      token: this.asset(),
+      remarks: "Unused Balance"
+    }];
   }
 
   getSetManagerCall(strategist: ContractAddr, root = this.getMerkleRoot()) {
@@ -379,7 +453,7 @@ export class UniversalStrategy<
     isDeposit: boolean,
     depositAmount: Web3Number,
     debtAmount: Web3Number
-  }) {
+  }): UniversalManageCall[] {
       assert(params.depositAmount.gt(0) || params.debtAmount.gt(0), 'Either deposit or debt amount must be greater than 0');
       // approve token
       const isToken1 = params.isLeg1 == params.isDeposit; // XOR
@@ -522,7 +596,7 @@ export class UniversalStrategy<
     }
   }
 
-  async getVesuMultiplyCall(params: {
+  async getVesuModifyPositionCall(params: {
     isDeposit: boolean,
     leg1DepositAmount: Web3Number
   }) {
@@ -994,7 +1068,7 @@ function getFAQs(): FAQ[] {
   ];
 }
 
-function getContractDetails(settings: UniversalStrategySettings): {address: ContractAddr, name: string}[] {
+export function getContractDetails(settings: UniversalStrategySettings): {address: ContractAddr, name: string}[] {
   return [
     { address: settings.vaultAddress, name: "Vault" },
     { address: settings.manager, name: "Vault Manager" },

package/src/utils/index.ts

@@ -1,3 +1,4 @@
+
 export * from '@/utils/logger';
 export * from './oz-merkle';
 
@@ -19,4 +20,5 @@ export function assert(condition: boolean, message: string) {
 
 export function getTrovesEndpoint(): string {
     return process.env.TROVES_ENDPOINT || 'https://app.troves.fi';
-}
+}
+

package/src/utils/logger.node.ts

@@ -12,7 +12,7 @@ const colors = {
 winston.addColors(colors);
 
 export const logger = winston.createLogger({
-  level: "verbose", // Set the minimum logging level
+  level: "debug", // Set the minimum logging level
   format: format.combine(
     format.colorize({ all: true }), // Apply custom colors
     format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), // Add timestamp to log messages