chronikService.ts

import { BlockInfo, ChronikClient, ConnectionStrategy, ScriptUtxo, Tx, WsConfig, WsEndpoint, WsMsgClient, WsSubScriptClient } from 'chronik-client'
import { encodeCashAddress, decodeCashAddress } from 'ecashaddrjs'
import { AddressWithTransaction, BlockchainInfo, TransactionDetails, ProcessedMessages, SubbedAddressesLog, SyncAndSubscriptionReturn, SubscriptionReturn, SimpleBlockInfo } from 'types/chronikTypes'
import { CHRONIK_MESSAGE_CACHE_DELAY, RESPONSE_MESSAGES, XEC_TIMESTAMP_THRESHOLD, XEC_NETWORK_ID, BCH_NETWORK_ID, BCH_TIMESTAMP_THRESHOLD, CHRONIK_FETCH_N_TXS_PER_PAGE, KeyValueT, NETWORK_IDS_FROM_SLUGS, SOCKET_MESSAGES, NETWORK_IDS, NETWORK_TICKERS, MainNetworkSlugsType, MAX_MEMPOOL_TXS_TO_PROCESS_AT_A_TIME, MEMPOOL_PROCESS_DELAY, CHRONIK_INITIALIZATION_DELAY, LATENCY_TEST_CHECK_DELAY, INITIAL_ADDRESS_SYNC_FETCH_CONCURRENTLY, TX_EMIT_BATCH_SIZE, DB_COMMIT_BATCH_SIZE, MAX_TXS_PER_ADDRESS, TX_BATCH_POLLING_DELAY } from 'constants/index'
import { productionAddresses } from 'prisma-local/seeds/addresses'
import prisma from 'prisma-local/clientInstance'
import {
  TransactionWithAddressAndPrices,
  createManyTransactions,
  deleteTransactions,
  fetchUnconfirmedTransactions,
  markTransactionsOrphaned,
  upsertTransaction,
  getSimplifiedTransactions,
  getSimplifiedTrasaction
} from './transactionService'
import {
  updateClientPaymentStatus,
  getClientPayment
} from './clientPaymentService'
import { Address, Prisma, ClientPaymentStatus } from '@prisma/client'
import xecaddr from 'xecaddrjs'
import { getAddressPrefix, satoshisToUnit } from 'utils/index'
import { fetchAddressesArray, fetchAllAddressesForNetworkId, getEarliestUnconfirmedTxTimestampForAddress, getLatestConfirmedTxTimestampForAddress, setSyncing, setSyncingBatch, updateLastSynced } from './addressService'
import * as ws from 'ws'
import { BroadcastTxData } from 'ws-service/types'
import config from 'config'
import io, { Socket } from 'socket.io-client'
import moment from 'moment'
import { OpReturnData, parseError, parseOpReturnData } from 'utils/validators'
import { executeAddressTriggers, executeTriggersBatch } from './triggerService'
import { appendTxsToFile } from 'prisma-local/seeds/transactions'
import { PHASE_PRODUCTION_BUILD } from 'next/dist/shared/lib/constants'
import { AddressType } from 'ecashaddrjs/dist/types'
import { DecimalJsLike } from '@prisma/client/runtime/library'

const decoder = new TextDecoder()

export function getNullDataScriptData (outputScript: string): OpReturnData | null {
  if (outputScript.length < 2 || outputScript.length % 2 !== 0) {
    throw new Error(RESPONSE_MESSAGES.INVALID_OUTPUT_SCRIPT_LENGTH_500(outputScript.length).message)
  }
  const opReturnCode = '6a'
  const encodedProtocolPushData = '04' // '\x04'
  const encodedProtocol = '50415900' // 'PAY\x00'

  const prefixLen = (
    opReturnCode.length +
    encodedProtocolPushData.length +
    encodedProtocol.length +
    2 // version byte
  )

  const regexPattern = new RegExp(
    `${opReturnCode}${encodedProtocolPushData}${encodedProtocol}.{2}`,
    'i'
  )

  if (!regexPattern.test(outputScript.slice(0, prefixLen))) {
    return null
  }

  let dataStartIndex = prefixLen + 2

  if (outputScript.length < dataStartIndex) {
    return null
  }

  let dataPushDataHex = outputScript.slice(prefixLen, dataStartIndex)
  if (dataPushDataHex.toLowerCase() === '4c') {
    dataStartIndex = dataStartIndex + 2
    dataPushDataHex = outputScript.slice(prefixLen + 2, dataStartIndex)
  }
  const dataPushData = parseInt(dataPushDataHex, 16)
  if (outputScript.length < dataStartIndex + dataPushData * 2) {
    return null
  }

  const dataHexBuffer = Buffer.from(
    outputScript.slice(dataStartIndex, dataStartIndex + dataPushData * 2),
    'hex'
  )
  const dataString = decoder.decode(dataHexBuffer)

  const ret: OpReturnData = {
    rawMessage: dataString,
    message: parseOpReturnData(dataString),
    paymentId: ''
  }

  const paymentIdPushDataIndex = dataStartIndex + dataPushData * 2
  const paymentIdStartIndex = paymentIdPushDataIndex + 2
  const hasPaymentId = outputScript.length >= paymentIdStartIndex
  if (!hasPaymentId) {
    return ret
  }

  const paymentIdPushDataHex = outputScript.slice(paymentIdPushDataIndex, paymentIdStartIndex)
  const paymentIdPushData = parseInt(paymentIdPushDataHex, 16)
  let paymentIdString = ''
  if (outputScript.length < paymentIdStartIndex + paymentIdPushData * 2) {
    return ret
  }
  for (let i = 0; i < paymentIdPushData; i++) {
    const hexByte = outputScript.slice(paymentIdStartIndex + (i * 2), paymentIdStartIndex + (i * 2) + 2)
    // we don't decode the hex for the paymentId, since those are just random bytes.
    paymentIdString += hexByte
  }
  ret.paymentId = paymentIdString

  return ret
}

interface ChronikTxWithAddress { tx: Tx, address: Address }
interface FetchedTxsBatch {
  chronikTxs: ChronikTxWithAddress[]
  addressesSynced: string[]
}

export class ChronikBlockchainClient {
  chronik!: ChronikClient
  networkId!: number
  networkSlug!: string
  chronikWSEndpoint!: WsEndpoint
  confirmedTxsHashesFromLastBlock!: string[]
  wsEndpoint!: Socket
  CHRONIK_MSG_PREFIX!: string
  lastProcessedMessages!: ProcessedMessages
  initializing!: boolean
  mempoolTxsBeingProcessed!: number

  private latencyTestFinished: boolean

  constructor (networkSlug: string) {
    this.latencyTestFinished = false
    void (async () => {
      if (process.env.WS_AUTH_KEY === '' || process.env.WS_AUTH_KEY === undefined) {
        throw new Error(RESPONSE_MESSAGES.MISSING_WS_AUTH_KEY_400.message)
      }

      this.initializing = true
      this.mempoolTxsBeingProcessed = 0
      this.networkSlug = networkSlug
      this.networkId = NETWORK_IDS_FROM_SLUGS[networkSlug]
      this.chronik = await ChronikClient.useStrategy(
        ConnectionStrategy.ClosestFirst,
        config.networkBlockchainURLs[networkSlug]
      )
      this.latencyTestFinished = true
      this.chronikWSEndpoint = this.chronik.ws(this.getWsConfig())
      this.confirmedTxsHashesFromLastBlock = []
      void this.chronikWSEndpoint.waitForOpen()
      this.chronikWSEndpoint.subscribeToBlocks()
      this.lastProcessedMessages = { confirmed: {}, unconfirmed: {} }
      this.CHRONIK_MSG_PREFIX = `[CHRONIK — ${networkSlug}]`
      this.wsEndpoint = io(`${config.wsBaseURL}/broadcast`, {
        query: {
          key: process.env.WS_AUTH_KEY
        }
      })
    })()
  }

  private getLastSyncTs (addr: Address): number {
    return (addr.lastSynced != null) ? Math.floor(new Date(addr.lastSynced).getTime() / 1000) : 0
  }

  public async waitForLatencyTest (): Promise<void> {
    while (true) {
      if (this.latencyTestFinished) {
        return
      }
      await new Promise(resolve => setTimeout(resolve, LATENCY_TEST_CHECK_DELAY))
    }
  }

  public getUrls (): string[] {
    return this.chronik.proxyInterface().getEndpointArray().map(e => e.url)
  }

  public setInitialized (): void {
    this.initializing = false
  }

  private clearOldMessages (): void {
    const now = moment().unix()

    for (const key of Object.keys(this.lastProcessedMessages.unconfirmed)) {
      const ageDiffMs = (now - Number(this.lastProcessedMessages.unconfirmed[key])) * 1000
      if (ageDiffMs > CHRONIK_MESSAGE_CACHE_DELAY) {
        const { [key]: _, ...rest } = this.lastProcessedMessages.unconfirmed
        this.lastProcessedMessages.unconfirmed = rest
      }
    }

    for (const key of Object.keys(this.lastProcessedMessages.confirmed)) {
      const ageDiffMs = (now - Number(this.lastProcessedMessages.confirmed[key])) * 1000
      if (ageDiffMs > CHRONIK_MESSAGE_CACHE_DELAY) {
        const { [key]: _, ...rest } = this.lastProcessedMessages.confirmed
        this.lastProcessedMessages.confirmed = rest
      }
    }
  }

  public getSubscribedAddresses (): string[] {
    const ret = this.chronikWSEndpoint.subs.scripts.map((script: WsSubScriptClient) => fromHash160(this.networkSlug, script.scriptType as AddressType, script.payload))
    return [...new Set(ret)]
  }

  private isAlreadyBeingProcessed (txid: string, confirmed: boolean): boolean {
    this.clearOldMessages()
    if (confirmed) {
      const lt = this.lastProcessedMessages.confirmed[txid]
      if (lt === undefined) {
        this.lastProcessedMessages.confirmed[txid] = moment().unix()
        return false
      }
      return true
    } else {
      const lt = this.lastProcessedMessages.unconfirmed[txid]
      if (lt === undefined) {
        this.lastProcessedMessages.unconfirmed[txid] = moment().unix()
        return false
      }
      return true
    }
  }

  private validateNetwork (networkSlug: string): void {
    if (NETWORK_IDS_FROM_SLUGS[networkSlug] !== this.networkId) { throw new Error(RESPONSE_MESSAGES.INVALID_NETWORK_SLUG_400.message) }
  }

  async getBlockchainInfo (networkSlug: string): Promise<BlockchainInfo> {
    this.validateNetwork(networkSlug)
    const blockchainInfo = await this.chronik.blockchainInfo()
    return { height: blockchainInfo.tipHeight, hash: blockchainInfo.tipHash }
  }

  async getBlockInfo (networkSlug: string, height: number): Promise<SimpleBlockInfo> {
    this.validateNetwork(networkSlug)
    const blockInfo: BlockInfo = (await this.chronik.block(height)).blockInfo
    return { hash: blockInfo.hash, height: blockInfo.height, timestamp: blockInfo.timestamp }
  }

  private txThesholdFilter (address: Address) {
    return (t: Tx, _index: number, _array: Tx[]): boolean => {
      return (
        t.block === undefined ||
        (t.block?.timestamp >= XEC_TIMESTAMP_THRESHOLD && address.networkId === XEC_NETWORK_ID) ||
        (t.block?.timestamp >= BCH_TIMESTAMP_THRESHOLD && address.networkId === BCH_NETWORK_ID)
      )
    }
  }

  private getTransactionAmountAndData (transaction: Tx, addressString: string): {amount: Prisma.Decimal, opReturn: string} {
    let totalOutput = 0n
    let totalInput = 0n
    const addressFormat = xecaddr.detectAddressFormat(addressString)
    const script = toHash160(addressString).hash160
    let opReturn = ''

    for (const output of transaction.outputs) {
      if (output.outputScript.includes(script)) {
        totalOutput += output.sats
      }
      if (opReturn === '') {
        const nullScriptData = getNullDataScriptData(output.outputScript)
        if (nullScriptData !== null) {
          opReturn = JSON.stringify(
            nullScriptData
          )
        }
      }
    }

    for (const input of transaction.inputs) {
      if (input?.outputScript?.includes(script) === true) {
        totalInput += input.sats
      }
    }

    const satoshis = totalOutput - totalInput
    const amount = satoshisToUnit(satoshis, addressFormat)

    return {
      amount,
      opReturn
    }
  }

  private getTransactionFromChronikTransaction (transaction: Tx, address: Address): Prisma.TransactionUncheckedCreateInput {
    const { amount, opReturn } = this.getTransactionAmountAndData(transaction, address.address)
    const inputAddresses = this.getSortedInputAddresses(transaction)

    return {
      hash: transaction.txid,
      amount,
      timestamp: transaction.block !== undefined ? transaction.block.timestamp : transaction.timeFirstSeen,
      addressId: address.id,
      confirmed: transaction.block !== undefined,
      isPayment: amount > 0,
      opReturn,
      inputs: {
        create: inputAddresses
      }
    }
  }

  public async getPaginatedTxs (addressString: string, page: number, pageSize: number): Promise<Tx[]> {
    const { type, hash160 } = toHash160(addressString)
    const txsPage = (await this.chronik.script(type, hash160).history(page, pageSize))

    // If there are too many txs, this might be too expensive to sync. Raise an
    // error to skip this address.
    if (txsPage.numTxs > MAX_TXS_PER_ADDRESS) {
      throw new Error(`Address ${addressString} has too many txs to sync (${txsPage.numTxs} > ${MAX_TXS_PER_ADDRESS}).`)
    }

    return txsPage.txs
  }

  /*
   * For each address, fetch pages in parallel (“burst”),
   * then use the burst’s newest/oldest timestamps to decide whether to continue.
   * Yields happen only in the generator body (after each slice finishes, and at final flush).
  */
  private async * fetchLatestTxsForAddresses (
    addresses: Address[]
  ): AsyncGenerator<FetchedTxsBatch> {
    const logPrefix = `${this.CHRONIK_MSG_PREFIX}[PARALLEL FETCHING]`

    const totalCount = addresses.length
    console.log(
      `${logPrefix} >>> Will fetch latest txs for ${totalCount} addresses ` +
      `(addressConcurrency=${INITIAL_ADDRESS_SYNC_FETCH_CONCURRENTLY}, pageConcurrency=1).`
    )

    let chronikTxs: ChronikTxWithAddress[] = []
    const completedAddresses: string[] = []

    // Worker pool: maintain exactly INITIAL_ADDRESS_SYNC_FETCH_CONCURRENTLY active workers
    const activeWorkers = new Set<Promise<void>>()
    let nextAddressIndex = 0

    // Function to process a single address
    const processAddress = async (address: Address, addressIndex: number): Promise<void> => {
      const addrLogPrefix = `${logPrefix} > ${address.address}: (${addressIndex + 1}/${totalCount})`
      const lastSyncedTimestampSeconds = this.getLastSyncTs(address)
      const txThresholdFilter = this.txThesholdFilter(address)

      let nextBurstBasePageIndex = 0
      let hasReachedStoppingCondition = false
      let newTxs = 0

      try {
        while (!hasReachedStoppingCondition) {
          const pageIndex = nextBurstBasePageIndex
          let pageTxs: Tx[] = []

          try {
            pageTxs = await this.getPaginatedTxs(address.address, pageIndex, CHRONIK_FETCH_N_TXS_PER_PAGE)
          } catch (err: any) {
            console.warn(`${addrLogPrefix} page=${pageIndex} failed: ${err.message as string}`)
            pageTxs = []
          }

          if (pageIndex === 0 && pageTxs.length === 0) {
            console.log(`${addrLogPrefix} EMPTY ADDRESS`)
            break
          }

          if (pageTxs.length < CHRONIK_FETCH_N_TXS_PER_PAGE) {
            hasReachedStoppingCondition = true
          }

          const newestTs = Number(pageTxs[0].block?.timestamp ?? pageTxs[0].timeFirstSeen)

          if (newestTs < lastSyncedTimestampSeconds) {
            console.log(`${addrLogPrefix} NO NEW TXS`)
            break
          }

          const oldestTs = Number(pageTxs[pageTxs.length - 1].block?.timestamp ?? pageTxs[pageTxs.length - 1].timeFirstSeen)

          pageTxs = pageTxs
            .filter(txThresholdFilter)
            .filter(t => t.block === undefined || t.block.timestamp >= lastSyncedTimestampSeconds)

          const newTxsInThisPage = pageTxs.length
          if (newTxsInThisPage > 0) {
            chronikTxs.push(...pageTxs.map(tx => ({ tx, address })))
            pageTxs = []
          }

          if (oldestTs < lastSyncedTimestampSeconds) {
            hasReachedStoppingCondition = true
          }

          nextBurstBasePageIndex += 1
          if (newTxsInThisPage === 0 && oldestTs < lastSyncedTimestampSeconds) {
            hasReachedStoppingCondition = true
          }
          newTxs += newTxsInThisPage
        }
        if (newTxs > 0) {
          console.log(`${addrLogPrefix} ${newTxs} new txs.`)
        }
      } catch (err: any) {
        console.error(`${logPrefix}: address job failed: ${err.message as string}`)
      } finally {
        completedAddresses.push(address.address)
      }
    }

    // Start next worker from the queue
    const startNextWorker = (): void => {
      if (nextAddressIndex >= totalCount) {
        // No more addresses
        return
      }

      const currentIndex = nextAddressIndex
      nextAddressIndex++

      const workerPromise = processAddress(addresses[currentIndex], currentIndex).finally(() => {
        activeWorkers.delete(workerPromise)
        // Immediately start next worker if queue has more
        startNextWorker()
      })
      activeWorkers.add(workerPromise)
    }

    // Start initial batch of workers
    const initialBatchSize = Math.min(INITIAL_ADDRESS_SYNC_FETCH_CONCURRENTLY, totalCount)
    for (let i = 0; i < initialBatchSize; i++) {
      startNextWorker()
    }

    // Poll and yield batches while workers are active
    while (activeWorkers.size > 0 || chronikTxs.length > 0) {
      // Yield batches if buffer is large enough. Make sure to drain until there
      // are not enough transactions to fill the batch.
      while (chronikTxs.length >= TX_EMIT_BATCH_SIZE) {
        const chronikTxsSlice = chronikTxs.splice(0, TX_EMIT_BATCH_SIZE)
        yield { chronikTxs: chronikTxsSlice, addressesSynced: [] }
      }

      // If no active workers, yield any remaining transactions (even if < batch size)
      if (activeWorkers.size === 0 && chronikTxs.length > 0) {
        const remaining = chronikTxs.splice(0)
        yield { chronikTxs: remaining, addressesSynced: [] }
      }

      // Yield completed addresses if any
      if (completedAddresses.length > 0) {
        const completed = completedAddresses.splice(0)
        yield { chronikTxs: [], addressesSynced: completed }
      }

      // If no active workers and no more transactions, break
      if (activeWorkers.size === 0 && chronikTxs.length === 0) {
        break
      }

      // Wait a bit for more transactions or worker completion
      await Promise.race([
        Promise.all(Array.from(activeWorkers)).then(() => true),
        new Promise<boolean>(resolve => setTimeout(() => resolve(false), TX_BATCH_POLLING_DELAY))
      ])
    }

    // Wait for all workers to finish (should already be done)
    if (activeWorkers.size > 0) {
      await Promise.all(Array.from(activeWorkers))
    }

    // Final TX flush after all addresses processed
    if (chronikTxs.length > 0) {
      const remaining = chronikTxs
      chronikTxs = []
      yield { chronikTxs: remaining, addressesSynced: [] }
    }
  }

  public async * syncTransactionsForAddress (address: Address, fully = false, runTriggers = false): AsyncGenerator<TransactionWithAddressAndPrices[]> {
    const pageSize = CHRONIK_FETCH_N_TXS_PER_PAGE
    let page = 0
    const earliestUnconfirmedTxTimestamp = await getEarliestUnconfirmedTxTimestampForAddress(address.id)
    const latestTimestamp = earliestUnconfirmedTxTimestamp ?? await getLatestConfirmedTxTimestampForAddress(address.id) ?? 0
    let maxTimestamp = 0

    while (true) {
      let transactions = await this.getPaginatedTxs(address.address, page, pageSize)

      // filter out transactions that happened before a certain date set in constants/index,
      //   this date is understood as the beginning and we don't look past it
      transactions = transactions.filter(this.txThesholdFilter(address))

      if (transactions.length === 0) {
        break
      }
      const latestBlockTimestamp = Number(transactions[0].block?.timestamp)
      if (!fully && latestBlockTimestamp < latestTimestamp) break

      const confirmedTransactions = transactions.filter(t => t.block !== undefined)
      const unconfirmedTransactions = transactions.filter(t => t.block === undefined)

      page += 1

      const transactionsToPersist = [...confirmedTransactions, ...unconfirmedTransactions].map(tx => this.getTransactionFromChronikTransaction(tx, address))
      const persistedTransactions = await createManyTransactions(transactionsToPersist)
      if (persistedTransactions.length > 0) {
        // Track the max timestamp from persisted transactions
        for (const tx of persistedTransactions) {
          maxTimestamp = Math.max(maxTimestamp, tx.timestamp)
        }

        const simplifiedTransactions = getSimplifiedTransactions(persistedTransactions)

        console.log(`${this.CHRONIK_MSG_PREFIX}: added ${simplifiedTransactions.length} txs to ${address.address}`)

        const broadcastTxData: BroadcastTxData = {} as BroadcastTxData
        broadcastTxData.messageType = 'OldTx'
        broadcastTxData.address = address.address
        broadcastTxData.txs = simplifiedTransactions

        this.wsEndpoint.emit(SOCKET_MESSAGES.TXS_BROADCAST, broadcastTxData)
        if (runTriggers) {
          await executeAddressTriggers(broadcastTxData, this.networkId)
        }
      }

      yield persistedTransactions
    }
    await setSyncing(address.address, false)

    // Only update lastSynced if new value is greater than current (or if current is null)
    const currentAddress = await prisma.address.findUnique({
      where: { address: address.address },
      select: { lastSynced: true }
    })
    const currentLastSynced = currentAddress?.lastSynced ?? null
    const newDate = new Date(maxTimestamp * 1000)

    if ((currentLastSynced == null) || currentLastSynced < newDate) {
      await updateLastSynced(address.address, maxTimestamp)
    }
  }

  private async getUtxos (address: string): Promise<ScriptUtxo[]> {
    const { type, hash160 } = toHash160(address)
    const scriptsUtxos = await this.chronik.script(type, hash160).utxos()
    return scriptsUtxos.utxos
  }

  public async getBalance (address: string): Promise<bigint> {
    const utxos = await this.getUtxos(address)
    return utxos.reduce((acc, utxo) => acc + utxo.sats, 0n)
  }

  async getTransactionDetails (hash: string): Promise<TransactionDetails> {
    const tx = await this.chronik.tx(hash)

    const details: TransactionDetails = {
      hash: tx.txid,
      version: tx.version,
      block: {
        hash: tx.block?.hash,
        height: tx.block?.height,
        timestamp: tx.block?.timestamp.toString()
      },
      inputs: [],
      outputs: []
    }
    for (const input of tx.inputs) {
      details.inputs.push({
        value: input.sats,
        address: outputScriptToAddress(this.networkSlug, input.outputScript)
      })
    }
    for (const output of tx.outputs) {
      details.outputs.push({
        value: output.sats,
        address: outputScriptToAddress(this.networkSlug, output.outputScript)
      })
    }
    return details
  }

  private getWsConfig (): WsConfig {
    return {
      onMessage: (msg: WsMsgClient) => { void this.processWsMessage(msg) },
      onError: (e: ws.ErrorEvent) => { console.log(`${this.CHRONIK_MSG_PREFIX}: Chronik webSocket error, type: ${e.type} | message: ${e.message} | error: ${e.error as string}`) },
      onReconnect: (_: ws.Event) => { console.log(`${this.CHRONIK_MSG_PREFIX}: Chronik webSocket unexpectedly closed.`) },
      onConnect: (_: ws.Event) => { console.log(`${this.CHRONIK_MSG_PREFIX}: Chronik webSocket connection (re)established.`) },
      onEnd: (e: ws.Event) => { console.log(`${this.CHRONIK_MSG_PREFIX}: Chronik WebSocket ended, type: ${e.type}.`) },
      autoReconnect: true
    }
  }

  private getSortedInputAddresses (transaction: Tx): Array<{address: string, index: number, amount: Prisma.Decimal}> {
    const addressSatsMap = new Map<string, bigint>()
    transaction.inputs.forEach((inp) => {
      const address = outputScriptToAddress(this.networkSlug, inp.outputScript)
      if (address !== undefined && address !== '') {
        const currentValue = addressSatsMap.get(address) ?? 0n
        addressSatsMap.set(address, currentValue + inp.sats)
      }
    })
    const unitDivisor = this.networkId === XEC_NETWORK_ID
      ? 1e2
      : (this.networkId === BCH_NETWORK_ID ? 1e8 : 1)
    const result: Array<{address: string, index: number, amount: Prisma.Decimal}> = []
    let index = 0
    for (const [address, sats] of addressSatsMap.entries()) {
      const decimal = new Prisma.Decimal(sats.toString())
      const amount = decimal.dividedBy(unitDivisor)
      result.push({ address, index, amount })
      index++
    }
    return result
  }

  private getSortedOutputAddresses (transaction: Tx): Array<{address: string, index: number, amount: Prisma.Decimal}> {
    const addressSatsMap = new Map<string, bigint>()
    transaction.outputs.forEach((out) => {
      const address = outputScriptToAddress(this.networkSlug, out.outputScript)
      if (address !== undefined && address !== '') {
        const currentValue = addressSatsMap.get(address) ?? 0n
        addressSatsMap.set(address, currentValue + out.sats)
      }
    })
    const unitDivisor = this.networkId === XEC_NETWORK_ID
      ? 1e2
      : (this.networkId === BCH_NETWORK_ID ? 1e8 : 1)
    const result: Array<{address: string, index: number, amount: Prisma.Decimal}> = []
    let index = 0
    for (const [address, sats] of addressSatsMap.entries()) {
      const decimal = new Prisma.Decimal(sats.toString())
      const amount = decimal.dividedBy(unitDivisor)
      result.push({ address, index, amount })
      index++
    }
    return result
  }

  public async waitForSyncing (txId: string, addressStringArray: string[]): Promise<void> {
    if (!this.initializing) return
    console.log(`${this.CHRONIK_MSG_PREFIX}: Waiting unblocking addresses for ${txId}`)
    while (true) {
      const addresses = await fetchAddressesArray(addressStringArray)
      if (addresses.every(a => !a.syncing)) {
        console.log(`${this.CHRONIK_MSG_PREFIX}: Finished unblocking addresses for ${txId}`)
        return
      }
      await new Promise(resolve => setTimeout(resolve, CHRONIK_INITIALIZATION_DELAY))
    }
  }

  private async handleUpdateClientPaymentStatus (
    txAmount: string | number | Prisma.Decimal | DecimalJsLike,
    opReturn: string | undefined, status: ClientPaymentStatus,
    txAddress: string): Promise<void> {
    const parsedOpReturn = parseOpReturnData(opReturn ?? '')
    const paymentId = parsedOpReturn.paymentId
    if (paymentId === undefined || paymentId === '') {
      return
    }
    const clientPayment = await getClientPayment(paymentId)
    if (clientPayment === null || clientPayment.status === 'CONFIRMED') {
      return
    }
    if (clientPayment.amount !== null) {
      if (Number(clientPayment.amount) === Number(txAmount) &&
        (clientPayment.addressString === txAddress)) {
        await updateClientPaymentStatus(paymentId, status)
      }
    } else {
      if (clientPayment.addressString === txAddress) {
        await updateClientPaymentStatus(paymentId, status)
      }
    }
  }

  private async fetchTxWithRetry (txid: string, tries = 3, delayMs = 1000): Promise<Tx> {
    for (let i = 0; i < tries; i++) {
      try {
        return await this.chronik.tx(txid)
      } catch (e: any) {
        const msg = String(e?.message ?? e)
        const is404 = /not found in the index|404/.test(msg)
        if (!is404 || i === tries - 1) throw e
        const delay = delayMs * Math.pow(2, i)
        console.error(`Got a 404 Error trying to fetch tx ${txid} on the attempt number ${i + 1}, waiting ${(delay / 1000).toFixed(1)}s...`)
        await new Promise(resolve => setTimeout(resolve, delay))
      }
    }
    throw new Error('unreachable')
  }

  private async processWsMessage (msg: WsMsgClient): Promise<void> {
    if (msg.type === 'Tx') {
      // delete unconfirmed transaction from our database
      // if they were cancelled and not confirmed
      if (msg.msgType === 'TX_REMOVED_FROM_MEMPOOL') {
        console.log(`${this.CHRONIK_MSG_PREFIX}: [${msg.msgType}] ${msg.txid}`)
        const transactionsToDelete = await fetchUnconfirmedTransactions(msg.txid)
        try {
          await deleteTransactions(transactionsToDelete)
        } catch (err: any) {
          const parsedError = parseError(err)
          if (parsedError.message !== RESPONSE_MESSAGES.NO_TRANSACTION_FOUND_404.message) {
            throw err
          }
        }
      } else if (msg.msgType === 'TX_CONFIRMED') {
        try {
          const transaction = await this.fetchTxWithRetry(msg.txid)
          const addressesWithTransactions = await this.getAddressesForTransaction(transaction)
          console.log(`${this.CHRONIK_MSG_PREFIX}: [${msg.msgType}] ${msg.txid}`)
          this.confirmedTxsHashesFromLastBlock = [...this.confirmedTxsHashesFromLastBlock, msg.txid]
          for (const addressWithTransaction of addressesWithTransactions) {
            const { amount, opReturn } = addressWithTransaction.transaction
            await this.handleUpdateClientPaymentStatus(amount, opReturn, 'CONFIRMED' as ClientPaymentStatus, addressWithTransaction.address.address)
          }
        } catch (e: any) {
          const msg404 = String(e?.message ?? e)
          const is404 = /not found in the index|404/.test(msg404)
          if (is404) {
            console.log(`${this.CHRONIK_MSG_PREFIX}: [${msg.msgType}] tx ${msg.txid} not found in chronik, marking as orphaned`)
            await markTransactionsOrphaned(msg.txid)
          } else {
            console.error(`${this.CHRONIK_MSG_PREFIX}: confirmed tx handler failed for ${msg.txid}`, e)
          }
        }
      } else if (msg.msgType === 'TX_ADDED_TO_MEMPOOL') {
        if (this.isAlreadyBeingProcessed(msg.txid, false)) return

        while (this.mempoolTxsBeingProcessed >= MAX_MEMPOOL_TXS_TO_PROCESS_AT_A_TIME) {
          await new Promise(resolve => setTimeout(resolve, MEMPOOL_PROCESS_DELAY))
        }

        this.mempoolTxsBeingProcessed += 1
        try {
          console.log(`${this.CHRONIK_MSG_PREFIX}: [${msg.msgType}] ${msg.txid}`)
          const transaction = await this.fetchTxWithRetry(msg.txid)
          const addressesWithTransactions = await this.getAddressesForTransaction(transaction)
          await this.waitForSyncing(msg.txid, addressesWithTransactions.map(obj => obj.address.address))

          for (const addressWithTransaction of addressesWithTransactions) {
            const { created, tx } = await upsertTransaction(addressWithTransaction.transaction)
            if (tx !== undefined) {
              const broadcastTxData = this.broadcastIncomingTx(addressWithTransaction.address.address, transaction, tx)
              if (created) { // only execute trigger for newly added txs
                await executeAddressTriggers(broadcastTxData, tx.address.networkId)
              }
              const { amount, opReturn } = addressWithTransaction.transaction
              await this.handleUpdateClientPaymentStatus(amount, opReturn, 'ADDED_TO_MEMPOOL' as ClientPaymentStatus, addressWithTransaction.address.address)
            }
          }
        } catch (e) {
          console.error(`${this.CHRONIK_MSG_PREFIX}: mempool handler failed for ${msg.txid}`, e)
        } finally {
          this.mempoolTxsBeingProcessed = Math.max(0, this.mempoolTxsBeingProcessed - 1)
        }
      }
    } else if (msg.type === 'Block') {
      console.log(`${this.CHRONIK_MSG_PREFIX}: [${msg.msgType}] Height: ${msg.blockHeight} Hash: ${msg.blockHash}`)
      if (msg.msgType === 'BLK_FINALIZED') {
        console.log(`${this.CHRONIK_MSG_PREFIX}: [${msg.msgType}] Syncing ${this.confirmedTxsHashesFromLastBlock.length} txs on the block...`)
        while (this.initializing) {
          await new Promise(resolve => setTimeout(resolve, CHRONIK_INITIALIZATION_DELAY))
        }
        await this.syncBlockTransactions(msg.blockHash)
        console.log(`${this.CHRONIK_MSG_PREFIX}: [${msg.msgType}] Syncing done.`)
        const subsCount = this.chronikWSEndpoint.subs.scripts.length
        console.log(`${this.CHRONIK_MSG_PREFIX}: [INFO] *Currently Subscribed to ${subsCount} addresses*`)
        this.confirmedTxsHashesFromLastBlock = []
      }
    } else if (msg.type === 'Error') {
      console.log(`${this.CHRONIK_MSG_PREFIX}: [${msg.type}] ${JSON.stringify(msg.msg)}`)
    }
  }

  private broadcastIncomingTx (addressString: string, chronikTx: Tx, createdTx: TransactionWithAddressAndPrices): BroadcastTxData {
    const broadcastTxData: BroadcastTxData = {} as BroadcastTxData
    broadcastTxData.address = addressString
    broadcastTxData.messageType = 'NewTx'
    const inputAddresses = this.getSortedInputAddresses(chronikTx)
    const outputAddresses = this.getSortedOutputAddresses(chronikTx)
    const newSimplifiedTransaction = getSimplifiedTrasaction(createdTx, inputAddresses, outputAddresses)
    broadcastTxData.txs = [newSimplifiedTransaction]
    try { // emit broadcast for both unconfirmed and confirmed txs
      this.wsEndpoint.emit(SOCKET_MESSAGES.TXS_BROADCAST, broadcastTxData)
    } catch (err: any) {
      console.error(RESPONSE_MESSAGES.COULD_NOT_BROADCAST_TX_TO_WS_SERVER_500.message, err.stack)
    }
    return broadcastTxData
  }

  private async syncBlockTransactions (blockHash: string): Promise<void> {
    let page = 0
    const pageSize = 200
    let blockPageTxs = (await this.chronik.blockTxs(blockHash, page, pageSize)).txs
    let blockTxsToSync: Tx[] = []
    while (blockPageTxs.length > 0 && blockTxsToSync.length !== this.confirmedTxsHashesFromLastBlock.length) {
      const thisBlockTxsToSync = blockPageTxs.filter(tx => this.confirmedTxsHashesFromLastBlock.includes(tx.txid))
      blockTxsToSync = [...blockTxsToSync, ...thisBlockTxsToSync]
      page += 1
      blockPageTxs = (await this.chronik.blockTxs(blockHash, page, pageSize)).txs
    }
    for (const transaction of blockTxsToSync) {
      const addressesWithTransactions = await this.getAddressesForTransaction(transaction)

      for (const addressWithTransaction of addressesWithTransactions) {
        const { created, tx } = await upsertTransaction(addressWithTransaction.transaction)
        if (tx !== undefined) {
          const broadcastTxData = this.broadcastIncomingTx(addressWithTransaction.address.address, transaction, tx)
          if (created) { // only execute trigger for newly added txs
            await executeAddressTriggers(broadcastTxData, tx.address.networkId)
          }
        }
      }
    }
  }

  private getRelatedAddressesForTransaction (transaction: Tx): string[] {
    const inputAddresses = transaction.inputs.map(inp => outputScriptToAddress(this.networkSlug, inp.outputScript))
    const outputAddresses = transaction.outputs.map(out => outputScriptToAddress(this.networkSlug, out.outputScript))
    return [...inputAddresses, ...outputAddresses].filter(a => a !== undefined)
  }

  private async getAddressesForTransaction (transaction: Tx): Promise<AddressWithTransaction[]> {
    const relatedAddresses = this.getRelatedAddressesForTransaction(transaction)
    const addressesFromStringArray = await fetchAddressesArray(relatedAddresses)
    const addressesWithTransactions: AddressWithTransaction[] = addressesFromStringArray.map(
      address => {
        return {
          address,
          transaction: this.getTransactionFromChronikTransaction(transaction, address)
        }
      }
    )
    const zero = new Prisma.Decimal(0)
    return addressesWithTransactions.filter(
      addressWithTransaction => !(zero.equals(addressWithTransaction.transaction.amount as Prisma.Decimal))
    )
  }

  public async subscribeAddresses (addresses: Address[]): Promise<SubscriptionReturn> {
    const failedAddressesWithErrors: KeyValueT<string> = {}
    const subscribedAddresses = this.getSubscribedAddresses()
    addresses = addresses
      .filter(addr => (
        addr.networkId === this.networkId &&
      !subscribedAddresses.includes(addr.address))
      )
    if (addresses.length === 0) return { failedAddressesWithErrors }

    await Promise.all(
      addresses.map(async (address) => {
        try {
          this.chronikWSEndpoint.subscribeToAddress(address.address)
        } catch (err: any) {
          failedAddressesWithErrors[address.address] = err.stack
        }
      })
    )
    return {
      failedAddressesWithErrors
    }
  }

  private async commitTransactionsBatch (
    commitTuples: Array<{ row: Prisma.TransactionUncheckedCreateInput, raw: Tx, addressString: string }>,
    productionAddressesIds: string[],
    runTriggers: boolean
  ): Promise<void> {
    const rows = commitTuples.map(p => p.row)
    const createdTxs = await createManyTransactions(rows)
    console.log(`${this.CHRONIK_MSG_PREFIX} committed — created=${createdTxs.length}/${commitTuples.length}`)

    const createdForProd = createdTxs.filter(t => productionAddressesIds.includes(t.addressId))
    if (createdForProd.length > 0) {
      await appendTxsToFile(createdForProd as unknown as Prisma.TransactionCreateManyInput[])
    }

    if (createdTxs.length > 0) {
      const triggerBatch: BroadcastTxData[] = []
      for (const createdTx of createdTxs) {
        const tuple = commitTuples.find(t => t.row.hash === createdTx.hash)
        if (tuple == null) {
          continue
        }
        const bd = this.broadcastIncomingTx(createdTx.address.address, tuple.raw, createdTx)
        triggerBatch.push(bd)
      }
      if (runTriggers && triggerBatch.length > 0) {
        await executeTriggersBatch(triggerBatch, this.networkId)
      }

      // Release memory
      createdTxs.length = 0
      triggerBatch.length = 0
    }

    // Get the latest timestamp of all committed transactions (including pre-existent) for each address.
    // This is redundant under normal circumstances, but is more robust than only updating for the newly created transactions.
    const addressMaxTimestamp = new Map<string, number>()
    for (const { row, addressString } of commitTuples) {
      const currentMax = addressMaxTimestamp.get(addressString) ?? 0
      addressMaxTimestamp.set(addressString, Math.max(currentMax, row.timestamp))
    }

    // Fetch current lastSynced values for all addresses
    const addressesToUpdate = Array.from(addressMaxTimestamp.keys())
    const currentAddresses = await prisma.address.findMany({
      where: {
        address: { in: addressesToUpdate }
      },
      select: {
        address: true,
        lastSynced: true
      }
    })
    const currentLastSyncedMap = new Map<string, Date | null>(
      currentAddresses.map((a: { address: string, lastSynced: Date | null }) => [a.address, a.lastSynced])
    )

    // Update lastSynced for the processed addresses (only if new value is greater)
    for (const [addr, maxTs] of addressMaxTimestamp) {
      const currentLastSynced = currentLastSyncedMap.get(addr)
      const newDate = new Date(maxTs * 1000)

      // Only update if new value is greater than current (or if current is null)
      if ((currentLastSynced == null) || currentLastSynced < newDate) {
        try {
          await updateLastSynced(addr, maxTs)
        } catch (err: any) {
          console.error(`${this.CHRONIK_MSG_PREFIX}: Failed to update lastSynced for ${addr}: ${err.message as string}`)
        }
      }
    }
  }

  public async syncAddresses (addresses: Address[], runTriggers = false): Promise<SyncAndSubscriptionReturn> {
    const failedAddressesWithErrors: KeyValueT<string> = {}
    const successfulAddressesWithCount: KeyValueT<number> = {}
    const productionAddressesIds = productionAddresses.filter(a => a.networkId === this.networkId).map(a => a.id)

    if (addresses.length === 0) {
      return { failedAddressesWithErrors, successfulAddressesWithCount }
    }

    console.log(`${this.CHRONIK_MSG_PREFIX} Syncing ${addresses.length} addresses...`)
    console.time(`${this.CHRONIK_MSG_PREFIX} syncAddresses`)
    await setSyncingBatch(addresses.map(a => a.address), true)

    const perAddrCount = new Map<string, number>()
    addresses.forEach(a => perAddrCount.set(a.id, 0))

    interface RowWithRaw { row: Prisma.TransactionUncheckedCreateInput, raw: Tx, addressString: string }
    let toCommit: RowWithRaw[] = []

    try {
      const pfx = `${this.CHRONIK_MSG_PREFIX}[PARALLEL FETCHING]`
      console.log(`${pfx} will fetch batches of ${INITIAL_ADDRESS_SYNC_FETCH_CONCURRENTLY} addresses from chronik`)

      for await (const batch of this.fetchLatestTxsForAddresses(addresses)) {
        if (batch.addressesSynced.length > 0) {
          // marcador de slice => desmarca syncing
          await setSyncingBatch(batch.addressesSynced, false)
          continue
        }

        const involvedAddrIds = new Set(batch.chronikTxs.map(({ address }) => address.id))

        try {
          const tupleFromBatch: RowWithRaw[] = batch.chronikTxs.map(({ tx, address }) => {
            const row = this.getTransactionFromChronikTransaction(tx, address)
            return { row, raw: tx, addressString: address.address }
          })

          for (const { row } of tupleFromBatch) {
            perAddrCount.set(row.addressId, (perAddrCount.get(row.addressId) ?? 0) + 1)
          }

          toCommit.push(...tupleFromBatch)
          // Release memory
          tupleFromBatch.length = 0

          if (toCommit.length >= DB_COMMIT_BATCH_SIZE) {
            const commitPairs = toCommit.splice(0, DB_COMMIT_BATCH_SIZE)
            await this.commitTransactionsBatch(commitPairs, productionAddressesIds, runTriggers)
            // Clear commitPairs
            commitPairs.length = 0
          }
        } catch (err: any) {
          console.error(`${this.CHRONIK_MSG_PREFIX}: ERROR in batch (scoped): ${err.message as string}`)
          // Only mark addresses that were actually in this batch
          for (const a of addresses) {
            if (involvedAddrIds.has(a.id)) {
              failedAddressesWithErrors[a.address] = err.stack ?? String(err)
            }
          }
          continue
        }
      }

      // final DB flush (se sobrou menos que DB_COMMIT_BATCH_SIZE)
      if (toCommit.length > 0) {
        await this.commitTransactionsBatch(toCommit, productionAddressesIds, runTriggers)
        toCommit = []
      }

      // build success map
      addresses.forEach(a => {
        successfulAddressesWithCount[a.address] = perAddrCount.get(a.id) ?? 0
      })
    } catch (err: any) {
      console.error(`${this.CHRONIK_MSG_PREFIX}: FATAL ERROR in parallel sync: ${err.message as string}`)
      addresses.forEach(a => {
        if ((perAddrCount.get(a.id) ?? 0) === 0) {
          failedAddressesWithErrors[a.address] = err.stack ?? String(err)
        }
      })
    }

    const failed = Object.keys(failedAddressesWithErrors)
    const total = Object.values(successfulAddressesWithCount).reduce((p, c) => p + c, 0)
    console.log(`${this.CHRONIK_MSG_PREFIX} Finished syncing ${total} txs for ${addresses.length} addresses with ${failed.length} errors.`)
    console.timeEnd(`${this.CHRONIK_MSG_PREFIX} syncAddresses`)

    return { failedAddressesWithErrors, successfulAddressesWithCount }
  }

  public async syncMissedTransactions (): Promise<void> {
    const addresses = await fetchAllAddressesForNetworkId(this.networkId)
    try {
      const { failedAddressesWithErrors, successfulAddressesWithCount } = await this.syncAddresses(addresses, true)
      Object.keys(failedAddressesWithErrors).forEach((addr) => {
        console.error(`${this.CHRONIK_MSG_PREFIX}: When syncing missing addresses for address ${addr} encountered error: ${failedAddressesWithErrors[addr]}`)
      })
      console.log(`${this.CHRONIK_MSG_PREFIX}: Missed txs successfully synced per address:`)
      Object.keys(successfulAddressesWithCount).forEach((addr) => {
        if (successfulAddressesWithCount[addr] > 0) {
          console.log(`${this.CHRONIK_MSG_PREFIX}:> ${addr} — ${successfulAddressesWithCount[addr]}.`)
        }
      })
    } catch (err: any) {
      console.error(`${this.CHRONIK_MSG_PREFIX}: ERROR: (skipping anyway) initial missing transactions sync failed: ${err.message as string} ${err.stack as string}`)
    }
  }

  public async subscribeInitialAddresses (): Promise<void> {
    const addresses = await fetchAllAddressesForNetworkId(this.networkId)
    try {
      await this.subscribeAddresses(addresses)
    } catch (err: any) {
      console.error(`${this.CHRONIK_MSG_PREFIX}: ERROR: (skipping anyway) initial chronik subscription failed: ${err.message as string} ${err.stack as string}`)
    }
  }

  public async getLastBlockTimestamp (): Promise<number> {
    const blockchainInfo = await this.getBlockchainInfo(this.networkSlug)
    const lastBlockInfo = await this.getBlockInfo(this.networkSlug, blockchainInfo.height)
    return lastBlockInfo.timestamp
  }
}

export function fromHash160 (networkSlug: string, type: AddressType, hash160: string): string {
  const buffer = Buffer.from(hash160, 'hex')

  // Because ecashaddrjs only accepts Uint8Array as input type, convert
  const hash160ArrayBuffer = new ArrayBuffer(buffer.length)
  const hash160Uint8Array = new Uint8Array(hash160ArrayBuffer)
  for (let i = 0; i < hash160Uint8Array.length; i += 1) {
    hash160Uint8Array[i] = buffer[i]
  }

  return encodeCashAddress(
    networkSlug,
    type,
    hash160Uint8Array
  )
}

export function toHash160 (address: string): {type: AddressType, hash160: string} {
  try {
    const { type, hash } = decodeCashAddress(address)
    return { type, hash160: hash }
  } catch (err) {
    console.log('[CHRONIK]: Error converting address to hash160')
    throw err
  }
}

// returns P2SH (type 76a914...88ac) or P2PKH (type a914...87) address
export function outputScriptToAddress (networkSlug: string, outputScript: string | undefined): string | undefined {
  if (outputScript === undefined) return undefined

  const typeTestSlice = outputScript.slice(0, 4)
  let addressType
  let hash160
  switch (typeTestSlice) {
    case '76a9':
      addressType = 'p2pkh'
      hash160 = outputScript.substring(
        outputScript.indexOf('76a914') + '76a914'.length,
        outputScript.lastIndexOf('88ac')
      )
      break
    case 'a914':
      addressType = 'p2sh'
      hash160 = outputScript.substring(
        outputScript.indexOf('a914') + 'a914'.length,
        outputScript.lastIndexOf('87')
      )
      break
    default:
      return undefined
  }

  if (hash160.length !== 40) return undefined

  return fromHash160(networkSlug, addressType as AddressType, hash160)
}

class MultiBlockchainClient {
  private clients!: Record<MainNetworkSlugsType, ChronikBlockchainClient>
  public initializing: boolean

  constructor () {
    console.log('Initializing MultiBlockchainClient...')
    this.initializing = true
    void (async () => {
      const asyncOperations: Array<Promise<void>> = []
      this.clients = {
        ecash: this.instantiateChronikClient('ecash', asyncOperations),
        bitcoincash: this.instantiateChronikClient('bitcoincash', asyncOperations)
      }
      await Promise.all(asyncOperations)
      this.setInitialized()
      console.log('Finished initializing MultiBlockchainClient.')
    })()
  }

  public setInitialized (): void {
    this.initializing = false
    this.clients.ecash.setInitialized()
    this.clients.bitcoincash.setInitialized()
  }

  public async waitForStart (): Promise<void> {
    while (this.initializing) {
      await new Promise(resolve => setTimeout(resolve, LATENCY_TEST_CHECK_DELAY))
    }
  }

  public getUrls (): Record<MainNetworkSlugsType, string[]> {
    return {
      ecash: this.clients.ecash.getUrls(),
      bitcoincash: this.clients.bitcoincash.getUrls()
    }
  }

  private isRunningApp (): boolean {
    if (
      process.env.NEXT_PHASE !== PHASE_PRODUCTION_BUILD &&
      process.env.NODE_ENV !== 'test' &&
      process.env.JOBS_ENV === undefined
    ) {
      return true
    }
    return false
  }

  private instantiateChronikClient (networkSlug: string, asyncOperations: Array<Promise<void>>): ChronikBlockchainClient {
    console.log(`[CHRONIK — ${networkSlug}] Instantiating client...`)
    const newClient = new ChronikBlockchainClient(networkSlug)

    // Subscribe addresses & Sync lost transactions on DB upon client initialization
    if (this.isRunningApp()) {
      asyncOperations.push(
        (async () => {
          await newClient.waitForLatencyTest()
          console.log(`[CHRONIK — ${networkSlug}] Subscribing addresses in database...`)
          await newClient.subscribeInitialAddresses()
        })()
      )
    } else if (process.env.NODE_ENV === 'test' || process.env.JOBS_ENV !== undefined) {
      asyncOperations.push(
        (async () => {
          await newClient.waitForLatencyTest()
        })()
      )
    }

    console.log(`Finished instantiating ${networkSlug} client.`)
    return newClient
  }

  public getAllSubscribedAddresses (): SubbedAddressesLog {
    const ret = {} as any
    for (const key of Object.keys(this.clients)) {
      ret[key] = this.clients[key as MainNetworkSlugsType]?.getSubscribedAddresses()
    }
    return ret
  }

  public async subscribeAddresses (addresses: Address[]): Promise<void> {
    let failedAddressesWithErrors: KeyValueT<string> = {}
    await Promise.all(
      Object.keys(this.clients).map(async (networkSlug) => {
        const addressesOfNetwork = addresses.filter(
          (address) => address.networkId === NETWORK_IDS[NETWORK_TICKERS[networkSlug]]
        )
        const client = this.clients[networkSlug as MainNetworkSlugsType]
        const thisNetworkRes = await client.subscribeAddresses(addressesOfNetwork)
        failedAddressesWithErrors = { ...failedAddressesWithErrors, ...thisNetworkRes.failedAddressesWithErrors }
      })
    )
    Object.keys(failedAddressesWithErrors).forEach((addr) => {
      console.error(`[CHRONIK]: When syncing missing addresses for address ${addr} encountered error: ${failedAddressesWithErrors[addr]}`)
    })
  }

  public async syncAddresses (addresses: Address[], runTriggers = false): Promise<SyncAndSubscriptionReturn> {
    let failedAddressesWithErrors: KeyValueT<string> = {}
    let successfulAddressesWithCount: KeyValueT<number> = {}

    for (const networkSlug of Object.keys(this.clients)) {
      const thisNetworkAddresses = addresses.filter(a => a.networkId === NETWORK_IDS_FROM_SLUGS[networkSlug])
      const ret = await this.clients[networkSlug as MainNetworkSlugsType].syncAddresses(thisNetworkAddresses, runTriggers)
      failedAddressesWithErrors = { ...failedAddressesWithErrors, ...ret.failedAddressesWithErrors }
      successfulAddressesWithCount = { ...successfulAddressesWithCount, ...ret.successfulAddressesWithCount }
    }
    return {
      failedAddressesWithErrors,
      successfulAddressesWithCount
    }
  }

  public async getTransactionDetails (hash: string, networkSlug: string): Promise<TransactionDetails> {
    return await this.clients[networkSlug as MainNetworkSlugsType].getTransactionDetails(hash)
  }

  public async getLastBlockTimestamp (networkSlug: string): Promise<number> {
    return await this.clients[networkSlug as MainNetworkSlugsType].getLastBlockTimestamp()
  }

  public async getBalance (address: string): Promise<bigint> {
    const networkSlug = getAddressPrefix(address)
    return await this.clients[networkSlug as MainNetworkSlugsType].getBalance(address)
  }

  public async syncMissedTransactions (): Promise<void> {
    await this.waitForStart()
    await this.clients.ecash.syncMissedTransactions()
    await this.clients.bitcoincash.syncMissedTransactions()
  }

  public async syncAndSubscribeAddresses (addresses: Address[]): Promise<SyncAndSubscriptionReturn> {
    await this.subscribeAddresses(addresses)
    return await this.syncAddresses(addresses)
  }

  public async destroy (): Promise<void> {
    await Promise.all(
      Object.values(this.clients).map(async (c) => {
        try {
          c.chronikWSEndpoint.close()
          c.wsEndpoint.close()
        } catch (err: any) {
          console.error(`Failed to close connections for client: ${err.message as string}`)
        }
      })
    )
  }
}

export interface NodeJsGlobalMultiBlockchainClient extends NodeJS.Global {
  multiBlockchainClient?: MultiBlockchainClient
}
declare const global: NodeJsGlobalMultiBlockchainClient

if (global.multiBlockchainClient === undefined) {
  global.multiBlockchainClient = new MultiBlockchainClient()
}

export const multiBlockchainClient: MultiBlockchainClient = global.multiBlockchainClient