maintenance-worker.ts

import { mergeDeepLeft, path, pipe } from 'ramda'
import { IRunnable } from '../@types/base'

import { createLogger } from '../factories/logger-factory'
import { delayMs } from '../utils/misc'
import { INip05VerificationRepository } from '../@types/repositories'
import { InvoiceStatus } from '../@types/invoice'
import { IPaymentsService } from '../@types/services'
import { Nip05Verification } from '../@types/nip05'
import { Settings } from '../@types/settings'
import { verifyNip05Identifier } from '../utils/nip05'

const UPDATE_INVOICE_INTERVAL = 60000
const NIP05_REVERIFICATION_BATCH_SIZE = 50

const debug = createLogger('maintenance-worker')

export class MaintenanceWorker implements IRunnable {
  private interval: NodeJS.Timeout | undefined

  public constructor(
    private readonly process: NodeJS.Process,
    private readonly paymentsService: IPaymentsService,
    private readonly settings: () => Settings,
    private readonly nip05VerificationRepository: INip05VerificationRepository,
  ) {
    this.process
      .on('SIGINT', this.onExit.bind(this))
      .on('SIGHUP', this.onExit.bind(this))
      .on('SIGTERM', this.onExit.bind(this))
      .on('uncaughtException', this.onError.bind(this))
      .on('unhandledRejection', this.onError.bind(this))
  }

  public run(): void {
    this.interval = setInterval(() => this.onSchedule(), UPDATE_INVOICE_INTERVAL)
  }

  private async onSchedule(): Promise<void> {
    const currentSettings = this.settings()

    await this.processNip05Reverifications(currentSettings)

    if (!path(['payments','enabled'], currentSettings)) {
      return
    }

    const invoices = await this.paymentsService.getPendingInvoices()
    debug('found %d pending invoices', invoices.length)
    const delay = () => delayMs(100 + Math.floor(Math.random() * 10))

    let successful = 0

    for (const invoice of invoices) {
      try {
        debug('getting invoice %s from payment processor: %o', invoice.id, invoice)
        const updatedInvoice = await this.paymentsService.getInvoiceFromPaymentsProcessor(invoice)
        await delay()
        debug('updating invoice status %s: %o', updatedInvoice.id, updatedInvoice)

        if (typeof updatedInvoice.id !== 'string' || typeof updatedInvoice.status !== 'string') {
          continue
        }
        const { id, status } = updatedInvoice

        await this.paymentsService.updateInvoiceStatus({ id, status })

        if (
          invoice.status !== updatedInvoice.status
          && updatedInvoice.status == InvoiceStatus.COMPLETED
          && updatedInvoice.confirmedAt
        ) {
          debug('confirming invoice %s & notifying %s', invoice.id, invoice.pubkey)

          const update = pipe(
            mergeDeepLeft(updatedInvoice),
            mergeDeepLeft({ amountPaid: invoice.amountRequested }),
          )(invoice)

          await Promise.all([
            this.paymentsService.confirmInvoice(update),
            this.paymentsService.sendInvoiceUpdateNotification(update),
          ])

          await delay()
        }
        successful++
      } catch (error) {
        console.error('Unable to update invoice from payment processor. Reason:', error)
      }

      debug('updated %d of %d invoices successfully', successful, invoices.length)
    }
  }

  private async processNip05Reverifications(currentSettings: Settings): Promise<void> {
    const nip05Settings = currentSettings.nip05
    if (!nip05Settings || nip05Settings.mode === 'disabled') {
      return
    }

    try {
      const updateFrequency = nip05Settings.verifyUpdateFrequency ?? 86400000
      const maxFailures = nip05Settings.maxConsecutiveFailures ?? 20

      const pendingVerifications = await this.nip05VerificationRepository.findPendingVerifications(
        updateFrequency,
        maxFailures,
        NIP05_REVERIFICATION_BATCH_SIZE,
      )

      if (!pendingVerifications.length) {
        return
      }

      debug('found %d NIP-05 verifications to re-check', pendingVerifications.length)

      for (const verification of pendingVerifications) {
        try {
          const verified = await verifyNip05Identifier(verification.nip05, verification.pubkey)
          const now = new Date()

          const updated: Nip05Verification = {
            ...verification,
            isVerified: verified,
            lastVerifiedAt: verified ? now : verification.lastVerifiedAt,
            lastCheckedAt: now,
            failureCount: verified ? 0 : verification.failureCount + 1,
            updatedAt: now,
          }

          await this.nip05VerificationRepository.upsert(updated)
          await delayMs(200 + Math.floor(Math.random() * 100))
        } catch (error) {
          debug('failed to re-verify NIP-05 for %s: %o', verification.pubkey, error)
        }
      }
    } catch (error) {
      debug('NIP-05 re-verification batch failed: %o', error)
    }
  }

  private onError(error: Error) {
    debug('error: %o', error)
    throw error
  }

  private onExit() {
    debug('exiting')
    this.close(() => {
      this.process.exit(0)
    })
  }

  public close(callback?: () => void) {
    debug('closing')
    clearInterval(this.interval)
    if (typeof callback === 'function') {
      callback()
    }
  }
}