Add fee transactions report

src/Reports/Processor.test.ts

@@ -1,6 +1,7 @@
 import { expect } from 'chai'
 import { processor } from './Processor.js'
 import { mockPoolSnapshots } from '../tests/mocks/mockPoolSnapshots.js'
+import { mockFeeTransactions } from '../tests/mocks/mockPoolFeeTransactions.js'
 import { mockTrancheSnapshots } from '../tests/mocks/mockTrancheSnapshots.js'
 import { mockPoolFeeSnapshots } from '../tests/mocks/mockPoolFeeSnapshot.js'
 import { mockPoolMetadata } from '../tests/mocks/mockPoolMetadata.js'
@@ -510,6 +511,19 @@ describe('Processor', () => {
       }
     })
   })
+
+  describe('fee transactions processor', () => {
+    it('should return empty array when no transactions found', () => {
+      expect(processor.feeTransactions({ poolFeeTransactions: [] })).to.deep.equal([])
+    })
+    it('should process fee transactions correctly', () => {
+      const result = processor.feeTransactions({ poolFeeTransactions: mockFeeTransactions })
+      expect(result).to.have.lengthOf(2)
+    })
+    // TODO: add tests for filtering by transaction type
+    // find mapping for transaction type
+  })
+
   describe('applyGrouping', () => {
     const applyGrouping = processor['applyGrouping']
     const mockData = [

src/Reports/Processor.ts

@@ -14,6 +14,9 @@ import {
   AssetTransactionReport,
   AssetTransactionsData,
   AssetTransactionReportFilter,
+  FeeTransactionsData,
+  FeeTransactionReportFilter,
+  FeeTransactionReport,
 } from './types.js'
 
 export class Processor {
@@ -212,41 +215,57 @@ export class Processor {
 
   assetTransactions(data: AssetTransactionsData, filter?: AssetTransactionReportFilter): AssetTransactionReport[] {
     return data.assetTransactions
-      .filter((day) => {
+      .filter((tx) => {
         if (!filter?.transactionType || filter.transactionType === 'all') {
           return true
         }
         if (filter.transactionType === 'created') {
-          return day.type === 'CREATED'
+          return tx.type === 'CREATED'
         }
         if (filter.transactionType === 'financed') {
-          return day.type === 'BORROWED'
+          return tx.type === 'BORROWED'
         }
         if (filter.transactionType === 'repaid') {
-          return day.type === 'REPAID'
+          return tx.type === 'REPAID'
         }
         if (filter.transactionType === 'priced') {
-          return day.type === 'PRICED'
+          return tx.type === 'PRICED'
         }
         if (filter.transactionType === 'closed') {
-          return day.type === 'CLOSED'
+          return tx.type === 'CLOSED'
         }
         if (filter.transactionType === 'cashTransfer') {
-          return day.type === 'CASH_TRANSFER'
+          return tx.type === 'CASH_TRANSFER'
         }
         return true
       })
-      .filter((day) => {
-        return !filter?.assetId || filter.assetId === day.asset.id.split('-')[1]
+      .filter((tx) => {
+        return !filter?.assetId || filter.assetId === tx.asset.id.split('-')[1]
       })
-      .map((day) => ({
+      .map((tx) => ({
         type: 'assetTransactions',
-        timestamp: day.timestamp.toISOString(),
-        assetId: day.asset.id,
-        epoch: day.epochId,
-        transactionType: day.type,
-        amount: day.amount,
-        transactionHash: day.hash,
+        timestamp: tx.timestamp.toISOString(),
+        assetId: tx.asset.id,
+        epoch: tx.epochId,
+        transactionType: tx.type,
+        amount: tx.amount,
+        transactionHash: tx.hash,
+      }))
+  }
+
+  feeTransactions(data: FeeTransactionsData, filter?: FeeTransactionReportFilter): FeeTransactionReport[] {
+    return data.poolFeeTransactions
+      .filter((tx) => {
+        if (!filter?.transactionType || filter.transactionType === 'all') {
+          return true
+        }
+        return filter.transactionType === tx.type
+      })
+      .map((tx) => ({
+        type: 'feeTransactions',
+        timestamp: tx.timestamp,
+        feeId: tx.feeId,
+        amount: tx.amount,
       }))
   }
 

src/Reports/index.ts

@@ -6,6 +6,11 @@ import {
   trancheSnapshotsPostProcess,
   trancheSnapshotsQuery,
 } from '../queries/trancheSnapshots.js'
+import {
+  poolFeeTransactionQuery,
+  poolFeeTransactionPostProcess,
+  PoolFeeTransactionFilter,
+} from '../queries/poolFeeTransactions.js'
 import { combineLatest } from 'rxjs'
 import { processor } from './Processor.js'
 
@@ -116,6 +121,10 @@ export class Reports extends Entity {
           ...dateFilter,
           poolId: { equalTo: this.pool.id },
         })
+        const poolFeeTransactions$ = this.poolFeeTransactionsQuery({
+          ...dateFilter,
+          poolFee: { poolId: { equalTo: this.pool.id } },
+        })
 
         switch (type) {
           case 'balanceSheet':
@@ -147,6 +156,10 @@ export class Reports extends Entity {
             return combineLatest([assetTransactions$, metadata$]).pipe(
               map(([assetTransactions]) => processor.assetTransactions({ assetTransactions }, filter) as T[])
             )
+          case 'feeTransactions':
+            return combineLatest([poolFeeTransactions$]).pipe(
+              map(([poolFeeTransactions]) => processor.feeTransactions({ poolFeeTransactions }, filter) as T[])
+            )
           default:
             throw new Error(`Unsupported report type: ${type}`)
         }
@@ -176,4 +189,8 @@ export class Reports extends Entity {
   assetTransactionsQuery(filter?: AssetTransactionFilter) {
     return this._root._queryIndexer(assetTransactionsQuery, { filter }, assetTransactionsPostProcess)
   }
+
+  poolFeeTransactionsQuery(filter?: PoolFeeTransactionFilter) {
+    return this._root._queryIndexer(poolFeeTransactionQuery, { filter }, poolFeeTransactionPostProcess)
+  }
 }

src/Reports/types.ts

@@ -1,6 +1,7 @@
 import { AssetTransaction, AssetTransactionType } from '../queries/assetTransactions.js'
 import { InvestorTransaction, SubqueryInvestorTransactionType } from '../queries/investorTransactions.js'
 import { PoolFeeSnapshotsByDate } from '../queries/poolFeeSnapshots.js'
+import { PoolFeeTransaction } from '../queries/poolFeeTransactions.js'
 import { PoolSnapshot } from '../queries/poolSnapshots.js'
 import { TrancheSnapshotsByDate } from '../queries/trancheSnapshots.js'
 import { PoolMetadata } from '../types/poolMetadata.js'
@@ -172,3 +173,23 @@ export type AssetTransactionReportFilter = {
   assetId?: string
   transactionType?: 'created' | 'financed' | 'repaid' | 'priced' | 'closed' | 'cashTransfer' | 'all'
 }
+
+/**
+ * Fee transactions types
+ */
+export type FeeTransactionsData = {
+  poolFeeTransactions: PoolFeeTransaction[]
+}
+
+export type FeeTransactionReport = {
+  type: 'feeTransactions'
+  timestamp: string
+  feeId: string
+  amount: Currency
+}
+
+export type FeeTransactionReportFilter = {
+  from?: string
+  to?: string
+  transactionType?: 'directChargeMade' | 'directChargeCanceled' | 'accrued' | 'paid' | 'all'
+}

src/queries/assetTransactions.ts

@@ -105,22 +105,22 @@ type SubqueryAssetTransactions = {
 
 export const assetTransactionsPostProcess = (data: SubqueryAssetTransactions): AssetTransaction[] => {
   return (
-    data.assetTransactions.nodes.map((day) => {
-      const decimals = day.pool.currency.decimals
+    data.assetTransactions.nodes.map((tx) => {
+      const decimals = tx.pool.currency.decimals
       return {
-        ...day,
-        settlementPrice: day.settlementPrice ? new Price(day.settlementPrice) : null,
-        amount: new Currency(day?.amount ?? 0n, decimals),
-        principalAmount: day.principalAmount ? new Currency(day.principalAmount, decimals) : undefined,
-        interestAmount: day.interestAmount ? new Currency(day.interestAmount, decimals) : undefined,
-        realizedProfitFifo: day.realizedProfitFifo ? new Currency(day.realizedProfitFifo, decimals) : undefined,
-        sumRealizedProfitFifo: day.asset.sumRealizedProfitFifo
-          ? new Currency(day.asset.sumRealizedProfitFifo, decimals)
+        ...tx,
+        settlementPrice: tx.settlementPrice ? new Price(tx.settlementPrice) : null,
+        amount: new Currency(tx?.amount ?? 0n, decimals),
+        principalAmount: tx.principalAmount ? new Currency(tx.principalAmount, decimals) : undefined,
+        interestAmount: tx.interestAmount ? new Currency(tx.interestAmount, decimals) : undefined,
+        realizedProfitFifo: tx.realizedProfitFifo ? new Currency(tx.realizedProfitFifo, decimals) : undefined,
+        sumRealizedProfitFifo: tx.asset.sumRealizedProfitFifo
+          ? new Currency(tx.asset.sumRealizedProfitFifo, decimals)
           : undefined,
-        unrealizedProfitAtMarketPrice: day.asset.unrealizedProfitAtMarketPrice
-          ? new Currency(day.asset.unrealizedProfitAtMarketPrice, decimals)
+        unrealizedProfitAtMarketPrice: tx.asset.unrealizedProfitAtMarketPrice
+          ? new Currency(tx.asset.unrealizedProfitAtMarketPrice, decimals)
           : undefined,
-        timestamp: new Date(`${day.timestamp}+00:00`),
+        timestamp: new Date(`${tx.timestamp}+00:00`),
       }
     }) || ([] satisfies AssetTransaction[])
   )

src/queries/poolFeeTransactions.ts

@@ -0,0 +1,72 @@
+import { Currency } from '../utils/BigInt.js'
+
+export type PoolFeeTransactionFilter = Partial<
+  Record<keyof SubqueryPoolFeeTransaction['poolFeeTransactions']['nodes'][0], any>
+>
+
+export type PoolFeeTransaction = {
+  feeId: string
+  type: string
+  timestamp: string
+  blockNumber: string
+  epochNumber: number
+  amount: Currency
+}
+
+export type SubqueryPoolFeeTransaction = {
+  poolFeeTransactions: {
+    nodes: {
+      id: string
+      type: string
+      timestamp: string
+      blockNumber: string
+      epochNumber: number
+      amount: string
+      poolFee: {
+        feeId: string
+        pool: {
+          currency: {
+            decimals: number
+          }
+        }
+      }
+    }[]
+  }
+}
+
+export function poolFeeTransactionPostProcess(data: SubqueryPoolFeeTransaction): PoolFeeTransaction[] {
+  return data.poolFeeTransactions.nodes.map((tx) => ({
+    feeId: tx.id,
+    type: tx.type,
+    timestamp: tx.timestamp,
+    blockNumber: tx.blockNumber,
+    epochNumber: tx.epochNumber,
+    amount: new Currency(tx.amount, tx.poolFee.pool.currency.decimals),
+  }))
+}
+
+export const poolFeeTransactionQuery = `
+query($filter: PoolFeeTransactionFilter) {
+  poolFeeTransactions(
+    orderBy: TIMESTAMP_ASC,
+    filter: $filter
+    ) {
+    nodes {
+      id
+      type
+      timestamp
+      blockNumber
+      epochNumber
+      amount
+      poolFee {
+        feeId
+        pool {
+          currency {
+            decimals
+          }
+        }
+      }
+    }
+  }
+}
+`

src/tests/mocks/mockPoolFeeTransactions.ts

@@ -0,0 +1,20 @@
+import { Currency } from '../../utils/BigInt.js'
+
+export const mockFeeTransactions = [
+  {
+    feeId: 'fee-1',
+    type: 'ACCRUED',
+    timestamp: '2024-01-01T00:00:00Z',
+    blockNumber: '1',
+    epochNumber: 1,
+    amount: new Currency(1000000n, 6),
+  },
+  {
+    feeId: 'fee-2',
+    type: 'PAID',
+    timestamp: '2024-01-02T00:00:00Z',
+    blockNumber: '2',
+    epochNumber: 2,
+    amount: new Currency(2000000n, 6),
+  },
+]