feat: add yieldMTD, yieldQTD, yieldYTD (#204)

Fixes #176

Author: filo87

schema.graphql

@@ -174,6 +174,10 @@ type Tranche @entity {
   yield90DaysAnnualized: BigInt
   yieldSinceInception: BigInt
   yieldSinceLastPeriod: BigInt
+  yieldMTD: BigInt
+  yieldQTD: BigInt
+  yieldYTD: BigInt
+
 }
 
 type TrancheSnapshot @entity {

src/mappings/handlers/blockHandlers.ts

@@ -37,6 +37,10 @@ async function _handleBlock(block: SubstrateBlock): Promise<void> {
     const lastPeriodStart = new Date(blockPeriodStart.valueOf() - SNAPSHOT_INTERVAL_SECONDS * 1000)
     const daysAgo30 = new Date(blockPeriodStart.valueOf() - 30 * 24 * 3600 * 1000)
     const daysAgo90 = new Date(blockPeriodStart.valueOf() - 90 * 24 * 3600 * 1000)
+    const beginningOfMonth = new Date(lastPeriodStart.getFullYear(), lastPeriodStart.getMonth(), 1)
+    const quarter = Math.floor(lastPeriodStart.getMonth() / 3)
+    const beginningOfQuarter = new Date(lastPeriodStart.getFullYear(), quarter * 3, 1)
+    const beginningOfYear = new Date(lastPeriodStart.getFullYear(), 0, 1)
 
     // Update Pool States
     const pools = await PoolService.getCfgActivePools()
@@ -57,6 +61,9 @@ async function _handleBlock(block: SubstrateBlock): Promise<void> {
         await tranche.updateDebt(trancheData[tranche.trancheId].data.debt.toBigInt())
         await tranche.computeYield('yieldSinceLastPeriod', lastPeriodStart)
         await tranche.computeYield('yieldSinceInception')
+        await tranche.computeYield('yieldYTD', beginningOfYear)
+        await tranche.computeYield('yieldQTD', beginningOfQuarter)
+        await tranche.computeYield('yieldMTD', beginningOfMonth)
         await tranche.computeYieldAnnualized('yield30DaysAnnualized', blockPeriodStart, daysAgo30)
         await tranche.computeYieldAnnualized('yield90DaysAnnualized', blockPeriodStart, daysAgo90)
         await tranche.save()

src/mappings/services/trancheService.ts

@@ -104,12 +104,12 @@ export class TrancheService extends Tranche {
       return this
     }
     const accruedFees = bnToBn(navResponse.unwrap().navFees.toBigInt())
-    if (!this.tokenSupply || this.tokenSupply === BigInt(0) ) {
+    if (!this.tokenSupply || this.tokenSupply === BigInt(0)) {
       logger.warn(`Token supply equal 0! Cannot perform division. Token price: ${price}`)
       this.tokenPrice = price
       return this
     }
-    this.tokenPrice =  nToBigInt(bnToBn(price).sub(accruedFees.mul(WAD).div(bnToBn(this.tokenSupply))))
+    this.tokenPrice = nToBigInt(bnToBn(price).sub(accruedFees.mul(WAD).div(bnToBn(this.tokenSupply))))
     logger.info(`Updating price for tranche ${this.id} to: ${this.tokenPrice} (ACCOUNTING FOR ACCRUED FEES)`)
     return this
   }
@@ -134,9 +134,9 @@ export class TrancheService extends Tranche {
     return this
   }
 
-  public async computeYield(yieldField: string, referencePeriodStart?: Date) {
+  public async computeYield(yieldField: BigIntFields<TrancheService>, referencePeriodStart?: Date) {
     logger.info(
-      `Computing yield for tranche ${this.trancheId} of ` +
+      `Computing yield ${yieldField} for tranche ${this.trancheId} of ` +
         `pool ${this.poolId} with reference date ${referencePeriodStart}`
     )
 
@@ -167,9 +167,13 @@ export class TrancheService extends Tranche {
     return this
   }
 
-  public async computeYieldAnnualized(yieldField: string, currentPeriodStart: Date, referencePeriodStart: Date) {
+  public async computeYieldAnnualized(
+    yieldField: BigIntFields<TrancheService>,
+    currentPeriodStart: Date,
+    referencePeriodStart: Date
+  ) {
     logger.info(
-      `Computing annualized yield for tranche ${this.trancheId} of ` +
+      `Computing annualized yield ${yieldField} for tranche ${this.trancheId} of ` +
         `pool ${this.poolId} with reference date ${referencePeriodStart}`
     )
     const trancheSnapshots = await TrancheSnapshot.getByPeriodStart(referencePeriodStart)
@@ -246,3 +250,5 @@ export class TrancheService extends Tranche {
     this.isActive = true
   }
 }
+
+type BigIntFields<T> = { [K in keyof T]: T[K] extends bigint ? K : never }[keyof T]