feat(Health): upsert number of attempts to anchor an IPFS directory h…

…ash (#896)

upsert a tracker with the number of attempts for each HashTxId event

References: #832 #896

src/Health/HealthController.ts

@@ -3,24 +3,18 @@ import * as Pino from 'pino'
 import { pick, pipeP } from 'ramda'
 
 import { childWithFileName } from 'Helpers/Logging'
-import { IPFSHashFailure, ClaimIPFSHashPair } from 'Interfaces'
+import { HealthError, IPFSHashFailure, TransactionAnchorRetryInfo } from 'Interfaces'
 import { IPFSHashTxId } from 'Messaging/Messages'
-
-import { BlockchainInfo, WalletInfo, NetworkInfo, IPFSInfo, EstimatedSmartFeeInfo, HealthDAO } from './HealthDAO'
-import { TransactionAnchorRetryInfo, IPFSDirectoryHashDAO } from './IPFSDirectoryHashDAO'
-
+import { BlockchainInfo, EstimatedSmartFeeInfo, HealthDAO, IPFSInfo, NetworkInfo, WalletInfo } from './HealthDAO'
 import { IPFS } from './IPFS'
+import { IPFSDirectoryHashDAO } from './IPFSDirectoryHashDAO'
 
 enum LogTypes {
   info = 'info',
   trace = 'trace',
   error = 'error',
 }
 
-export interface HealthError {
-  readonly error: string
-}
-
 export interface HealthControllerConfiguration {
   readonly lowWalletBalanceInBitcoin: number
   readonly feeEstimateMinTargetBlock: number
@@ -159,6 +153,11 @@ export class HealthController {
     return transactionAnchorRetryInfo
   }
 
+  private async upsertIpfsDirectoryHashTxId(ipfsHashTxId: IPFSHashTxId): Promise<IPFSHashTxId> {
+    await this.ipfsDirectoryHashDAO.updateAnchorAttemptsInfo(ipfsHashTxId)
+    return ipfsHashTxId
+  }
+
   private async removeIPFSDirectoryHashByTransactionId(transactionIds: ReadonlyArray<string>): Promise<void> {
     await this.ipfsDirectoryHashDAO.deleteByTransactionIds(transactionIds)
   }
@@ -173,6 +172,12 @@ export class HealthController {
     )
   }
 
+  public upsertIpfsHashTxId = pipeP(
+    this.log(LogTypes.trace)('updating ipfsDirectoryHash info'),
+    this.upsertIpfsDirectoryHashTxId,
+    this.log(LogTypes.trace)('updated ipfsDirectoryHash info'),
+  )
+
   public purgeIpfsDirectoryHashByTransactionIds = pipeP(
     this.log(LogTypes.trace)('purging IPFSDirectoryHash for transactionIds'),
     this.removeIPFSDirectoryHashByTransactionId,

src/Health/HealthDAO.ts

@@ -1,5 +1,6 @@
 import { Collection, Db } from 'mongodb'
-import { TransactionAnchorRetryInfo } from './IPFSDirectoryHashDAO'
+
+import { TransactionAnchorRetryInfo } from 'Interfaces'
 
 export interface BlockchainInfo {
   readonly blocks: number
@@ -124,7 +125,9 @@ export class HealthDAO {
     )
   }
 
-  readonly updateTransactionAnchorRetryInfo: updateTransactionAnchorRetryInfo = async transactionAnchorRetryInfo => {
+  readonly updateTransactionAnchorRetryInfo: updateTransactionAnchorRetryInfo = async (
+    transactionAnchorRetryInfo: TransactionAnchorRetryInfo,
+    ) => {
     await this.collection.updateOne(
       { name: 'transactionAnchorRetryInfo' },
       {

src/Health/IPFSDirectoryHashDAO.ts

@@ -1,21 +1,15 @@
+import { TransactionAnchorRetryInfo } from 'Interfaces'
+import { IPFSHashTxId } from 'Messaging/Messages'
 import { Collection } from 'mongodb'
 import { isNil } from 'ramda'
 
-import { IPFSHashTxId } from 'Messaging/Messages'
-
 type updateAnchorAttemptsInfo = (x: IPFSHashTxId) => Promise<void>
 
 export interface AnchorRetryDAOResult {
   readonly _id: number
   readonly count: number
 }
 
-export interface TransactionAnchorRetryEntry {
-  readonly attempts: number
-  readonly count: number
-}
-
-export type TransactionAnchorRetryInfo = ReadonlyArray<TransactionAnchorRetryEntry>
 export type getTransactionAnchorRetryInfo = () => Promise<TransactionAnchorRetryInfo>
 type deleteByTransactionIds = (transactionIds: ReadonlyArray<string>) => Promise<void>
 

src/Health/Router.ts

@@ -42,6 +42,7 @@ export class Router {
   async start() {
     await this.messaging.consume(this.exchange.getHealth, this.onGetHealth)
     await this.messaging.consumeClaimsNotDownloaded(this.onClaimsNotDownloaded)
+    await this.messaging.consumeIPFSHashTxId(this.ipfsHashTxIdConsumer)
     await this.messaging.consumeBlockDownloaded(this.blockDownloadedConsumer)
   }
 
@@ -70,13 +71,26 @@ export class Router {
     }
   }
 
+  ipfsHashTxIdConsumer = async (hashTxId: IPFSHashTxId): Promise<void> => {
+    const logger = this.logger.child({ method: 'ipfsHashTxIdConsumer' })
+
+    logger.debug({ hashTxId }, 'IPFS Directory Hash assigned a transactionId, updating counts')
+    try {
+      await this.controller.upsertIpfsHashTxId(hashTxId)
+      logger.info({ hashTxId }, 'Updated count for IPFS Directory Hash')
+    } catch (error) {
+      logger.error({ error }, 'Failed to upsert IPFSDirectoryHash')
+    }
+  }
+
   blockDownloadedConsumer = async (blockDownloaded: BlockDownloaded): Promise<void> => {
     const logger = this.logger.child({ method: 'blockDownloadedConsumer' })
 
     logger.debug({ blockDownloaded }, 'Block downloaded, removing associated transactions')
     try {
       const transactionIds = blockDownloaded.poetBlockAnchors.map(_ => _.transactionId)
       await this.controller.purgeIpfsDirectoryHashByTransactionIds(transactionIds)
+      logger.info({ blockDownloaded }, 'Block downloaded, associated transactions removed')
     } catch (error) {
       logger.error({ error }, 'Failed to remove transactions')
     }

src/Interfaces.ts

@@ -27,3 +27,14 @@ const hasFailureType = has('failureType')
 const hasFailureReason = has('failureReason')
 const hasFailureTime = has('failureTime')
 export const isIPFSHashFailure = allPass([hasIPFSFileHash, hasFailureReason, hasFailureType, hasFailureTime])
+
+export interface HealthError {
+  readonly error: string
+}
+
+export interface TransactionAnchorRetryEntry {
+  readonly attempts: number
+  readonly count: number
+}
+
+export type TransactionAnchorRetryInfo = ReadonlyArray<TransactionAnchorRetryEntry>