API.ts

import { Signature } from '@shardeum-foundation/lib-crypto-utils'
import { FastifyInstance, FastifyRequest } from 'fastify'
import { Server, IncomingMessage, ServerResponse } from 'http'
import { config, updateConfig, Config as ConfigInterface } from './Config'
import * as Crypto from './Crypto'
import * as State from './State'
import * as NodeList from './NodeList'
import * as P2P from './P2P'
import * as Storage from './archivedCycle/Storage'
import * as Data from './Data/Data'
import * as Cycles from './Data/Cycles'
import * as Utils from './Utils'
import { addHashesGossip } from './archivedCycle/Gossip'
import * as Logger from './Logger'
import { P2P as P2PTypes } from '@shardeum-foundation/lib-types'
import { Readable } from 'stream'
import { nestedCountersInstance } from './profiler/nestedCounters'
import { profilerInstance } from './profiler/profiler'
import * as CycleDB from './dbstore/cycles'
import * as AccountDB from './dbstore/accounts'
import * as TransactionDB from './dbstore/transactions'
import * as ReceiptDB from './dbstore/receipts'
import * as OriginalTxDB from './dbstore/originalTxsData'
import * as Collector from './Data/Collector'
import * as GossipData from './Data/GossipData'
import * as AccountDataProvider from './Data/AccountDataProvider'
import { getGlobalNetworkAccount } from './GlobalAccount'
import { cycleRecordWithShutDownMode } from './Data/Cycles'
import { isDebugMiddleware } from './DebugMode'
import { Utils as StringUtils } from '@shardeum-foundation/lib-types'
import { receivedReceiptCount, verifiedReceiptCount, successReceiptCount, failureReceiptCount } from './primary-process'
import * as ServiceQueue from './ServiceQueue'
import ticketRoutes from './routes/tickets'
import { Cycle } from './dbstore/types'
import { allowedArchiversManager } from './shardeum/allowedArchiversManager'
import { CheckpointBucket, CheckpointRadixEntry, CheckpointType } from './checkpoint/CheckpointData'
import { getCheckpointManager } from './checkpoint/Utils'
import { CheckpointStatusType, isBucketVerified } from './dbstore/checkpointStatus'
import { ArchiverLogging } from './profiler/archiverLogging'
import { checkpointStatusMap, CheckpointStatusResponse } from './checkpoint/CheckpointData'
const { version } = require('../package.json') // eslint-disable-line @typescript-eslint/no-var-requires
const TXID_LENGTH = 64
const {
  MAX_CYCLES_PER_REQUEST,
  MAX_ORIGINAL_TXS_PER_REQUEST,
  MAX_RECEIPTS_PER_REQUEST,
  MAX_ACCOUNTS_PER_REQUEST,
  MAX_BETWEEN_CYCLES_PER_REQUEST,
} = config.REQUEST_LIMIT

let reachabilityAllowed = true

export function registerRoutes(server: FastifyInstance<Server, IncomingMessage, ServerResponse>): void {
  type Request = FastifyRequest<{
    Body: {
      sender: string
      sign: Signature
    }
  }>

  /**
   * ENTRY POINT: New Shardus network
   *
   * Consensus node zero (CZ) posts IP and port to archiver node zero (AZ).
   *
   * AZ adds CZ to nodelist, sets CZ as dataSender, and responds with
   * nodelist + archiver join request
   *
   * CZ adds AZ's join reqeuest to cycle zero and sets AZ as cycleRecipient
   */
  type NodeListRequest = FastifyRequest<{
    Body: P2P.FirstNodeInfo & Crypto.SignedMessage
  }>

  server.get('/myip', function (request, reply) {
    const ip = request.raw.socket.remoteAddress
    reply.send({ ip })
  })

  server.post('/nodelist', (request: NodeListRequest, reply) => {
    profilerInstance.profileSectionStart('POST_nodelist')
    try {
      nestedCountersInstance.countEvent('consensor', 'POST_nodelist', 1)
      const signedFirstNodeInfo = request.body

      ArchiverLogging.logValidatorConnection({
        validatorId: signedFirstNodeInfo.nodeInfo.publicKey,
        archiverId: config.ARCHIVER_IP,
        timestamp: Date.now(),
        status: 'CONNECTING',
        handshake: {
          success: false,
          duration: 0,
        },
      })

      if (State.isFirst && NodeList.isEmpty() && !NodeList.foundFirstNode) {
        try {
          let err = Utils.validateTypes(signedFirstNodeInfo, {
            nodeInfo: 'o',
            sign: 'o',
          })
          if (err) {
            ArchiverLogging.logValidatorConnection({
              validatorId: signedFirstNodeInfo.nodeInfo.publicKey,
              archiverId: config.ARCHIVER_IP,
              timestamp: Date.now(),
              status: 'ERROR',
              handshake: {
                success: false,
                duration: Date.now() - request.raw.socket.remotePort,
                error: err,
              },
            })
            reply.send({ success: false, error: err })
            return
          }
          err = Utils.validateTypes(signedFirstNodeInfo.nodeInfo, {
            externalIp: 's',
            externalPort: 'n',
            publicKey: 's',
          })
          if (err) {
            reply.send({ success: false, error: err })
            return
          }
          err = Utils.validateTypes(signedFirstNodeInfo.sign, {
            owner: 's',
            sig: 's',
          })
          if (err) {
            reply.send({ success: false, error: err })
            return
          }
          if (signedFirstNodeInfo.nodeInfo.publicKey !== signedFirstNodeInfo.sign.owner) {
            Logger.mainLogger.error('nodeInfo.publicKey does not match signature owner', signedFirstNodeInfo)
            reply.send({ success: false, error: 'nodeInfo.publicKey does not match signature owner' })
            return
          }
          const isSignatureValid = Crypto.verify(signedFirstNodeInfo)
          if (!isSignatureValid) {
            Logger.mainLogger.error('Invalid signature', signedFirstNodeInfo)
            reply.send({ success: false, error: 'Invalid signature' })
            return
          }
        } catch (e) {
          Logger.mainLogger.error(e)
          reply.send({ success: false, error: 'Signature verification failed' })
          return
        }
        const ip = signedFirstNodeInfo.nodeInfo.externalIp
        const port = signedFirstNodeInfo.nodeInfo.externalPort
        const publicKey = signedFirstNodeInfo.nodeInfo.publicKey
        if (config.restrictFirstNodeSelectionByPublicKey) {
          if (publicKey !== config.firstNodePublicKey) {
            Logger.mainLogger.error('Invalid publicKey of first node info', signedFirstNodeInfo)
            reply.send({ success: false, error: 'Invalid publicKey of first node info' })
            return
          }
        }
        if (NodeList.foundFirstNode) {
          const res = NodeList.getCachedNodeList()
          reply.send(res)
          return
        }
        NodeList.toggleFirstNode()
        const firstNode: NodeList.ConsensusNodeInfo = {
          ip,
          port,
          publicKey,
        }

        Data.initSocketClient(firstNode)

        ArchiverLogging.logValidatorConnection({
          validatorId: signedFirstNodeInfo.nodeInfo.publicKey,
          archiverId: config.ARCHIVER_IP,
          timestamp: Date.now(),
          status: 'CONNECTED',
          handshake: {
            success: true,
            duration: Date.now() - request.raw.socket.remotePort,
          },
        })

        // Add first node to NodeList
        NodeList.addNodes(NodeList.NodeStatus.SYNCING, [firstNode])
        // Setting current time for realUpdatedTimes to refresh the nodelist and full-nodelist cache
        NodeList.realUpdatedTimes.set('/nodelist', Date.now())
        NodeList.realUpdatedTimes.set('/full-nodelist', Date.now())
        // Set first node as dataSender
        const firstDataSender: Data.DataSender = {
          nodeInfo: firstNode,
          types: [P2PTypes.SnapshotTypes.TypeNames.CYCLE, P2PTypes.SnapshotTypes.TypeNames.STATE_METADATA],
          contactTimeout: Data.createContactTimeout(firstNode.publicKey, 'This timeout is created for the first node'),
        }
        Data.addDataSender(firstDataSender)
        let res: P2P.FirstNodeResponse

        if (config.experimentalSnapshot) {
          const data = {
            nodeList: [firstNode],
          }
          if (cycleRecordWithShutDownMode) {
            // For restore network to start the network from the 'restart' mode
            data['restartCycleRecord'] = cycleRecordWithShutDownMode
            data['dataRequestCycle'] = cycleRecordWithShutDownMode.counter
          } else {
            // For new network to start the network from the 'forming' mode
            data['joinRequest'] = P2P.createArchiverJoinRequest()
            data['dataRequestCycle'] = Cycles.getCurrentCycleCounter()
          }
          res = Crypto.sign<P2P.FirstNodeResponse>(data)
        } else {
          res = Crypto.sign<P2P.FirstNodeResponse>({
            nodeList: [firstNode],
            joinRequest: P2P.createArchiverJoinRequest(),
            dataRequestCycle: Data.createDataRequest<P2PTypes.CycleCreatorTypes.CycleRecord>(
              P2PTypes.SnapshotTypes.TypeNames.CYCLE,
              Cycles.getCurrentCycleCounter(),
              publicKey
            ),
            dataRequestStateMetaData: Data.createDataRequest<P2PTypes.SnapshotTypes.StateMetaData>(
              P2PTypes.SnapshotTypes.TypeNames.STATE_METADATA,
              Cycles.lastProcessedMetaData,
              publicKey
            ),
          })
        }

        reply.send(res)
      } else {
        // Note, this is doing the same thing as GET /nodelist. However, it has been kept for backwards
        // compatibility.
        const res = NodeList.getCachedNodeList()
        reply.send(res)
      }
    } finally {
      profilerInstance.profileSectionEnd('POST_nodelist')
    }
  })

  server.get('/nodelist', (_request, reply) => {
    profilerInstance.profileSectionStart('GET_nodelist')
    try {
      nestedCountersInstance.countEvent('consensor', 'GET_nodelist')

      const res = NodeList.getCachedNodeList()
      reply.send(res)
    } finally {
      profilerInstance.profileSectionEnd('GET_nodelist')
    }
  })

  server.get('/network-txs-list', (_request, reply) => {
    profilerInstance.profileSectionStart('GET_network-txs-list')
    try {
      nestedCountersInstance.countEvent('consensor', 'network-txs-list')

      const res = ServiceQueue.getTxList()
      reply.send(res)
    } finally {
      profilerInstance.profileSectionEnd('GET_network-txs-list')
    }
  })

  type FullNodeListRequest = FastifyRequest<{
    Querystring: {
      activeOnly: 'true' | 'false'
      syncingOnly: 'true' | 'false'
      standbyOnly: 'true' | 'false'
    }
  }>

  server.get('/full-nodelist', (_request: FullNodeListRequest, reply) => {
    profilerInstance.profileSectionStart('FULL_nodelist')
    try {
      nestedCountersInstance.countEvent('consensor', 'FULL_nodelist')
      const query = _request.query
      let activeOnly = false
      let syncingOnly = false
      let standbyOnly = false
      if (query.activeOnly === 'true') activeOnly = true
      if (query.syncingOnly === 'true') syncingOnly = true
      if (query.standbyOnly === 'true') standbyOnly = true
      const res = NodeList.getCachedFullNodeList(activeOnly, syncingOnly, standbyOnly)
      reply.send(res)
    } finally {
      profilerInstance.profileSectionEnd('FULL_nodelist')
    }
  })

  server.get(
    '/removed',
    {
      preHandler: async (_request, reply) => {
        isDebugMiddleware(_request, reply)
      },
    },
    (_request: FullNodeListRequest, reply) => {
      profilerInstance.profileSectionStart('removed')
      nestedCountersInstance.countEvent('consensor', 'removed')
      reply.send({ removedAndApopedNodes: Cycles.removedAndApopedNodes })
      profilerInstance.profileSectionEnd('removed')
    }
  )

  server.get('/archivers', (_request, reply) => {
    profilerInstance.profileSectionStart('GET_archivers')
    try {
      nestedCountersInstance.countEvent('consensor', 'GET_archivers')
      const activeArchivers = State.activeArchivers
        .filter(
          (archiver) =>
            State.archiversReputation.has(archiver.publicKey) &&
            State.archiversReputation.get(archiver.publicKey) === 'up'
        )
        .map(({ publicKey, ip, port }) => ({ publicKey, ip, port }))

      const res = Crypto.sign({
        activeArchivers,
      })
      reply.send(res)
    } finally {
      profilerInstance.profileSectionEnd('GET_archivers')
    }
  })

  server.get('/allowed-archivers', async (_request, reply) => {
    profilerInstance.profileSectionStart('GET_allowed_archivers')
    try {
      const config = allowedArchiversManager.getCurrentConfig()
      if (!config) {
        return reply.status(500).send({
          error: 'Internal server error',
        })
      }
      return reply.send(config)
    } catch (error) {
      Logger.mainLogger.error('Error serving allowed-archivers:', error)
      return reply.status(500).send({
        error: 'Internal server error',
      })
    } finally {
      profilerInstance.profileSectionEnd('GET_allowed_archivers')
    }
  })

  server.get('/nodeInfo', (request, reply) => {
    if (reachabilityAllowed) {
      reply.send({
        publicKey: config.ARCHIVER_PUBLIC_KEY,
        ip: config.ARCHIVER_IP,
        port: config.ARCHIVER_PORT,
        version,
        time: Date.now(),
      })
    } else {
      request.raw.socket.destroy()
    }
  })

  server.get('/checkpoint-status', (_request, reply) => {
    profilerInstance.profileSectionStart('GET_checkpoint_status')
    try {
      // Check if the limit query parameter is provided
      const queryLimit =
        _request.query && typeof (_request.query as { limit?: string | number }).limit !== 'undefined'
          ? Number((_request.query as { limit?: string | number }).limit)
          : undefined
      const maxLimit = Number(config.checkpoint.statusArraySize) || 5000
      let limit: number

      if (queryLimit === undefined || isNaN(queryLimit)) {
        limit = Number(config.checkpoint.statusApiLimit) || 100
      } else if (queryLimit > 0 && queryLimit <= maxLimit) {
        limit = queryLimit
      } else {
        reply.send({
          success: false,
          error: `Invalid limit: must be > 0 and <= ${maxLimit}`,
        })
        return
      }

      const latestEntries = checkpointStatusMap.getLatestCycles(limit)

      if (latestEntries.length === 0) {
        reply.send({
          success: false,
          error: 'No checkpoint statuses found',
        })
        return
      }

      const entries: CheckpointStatusResponse = {}
      for (const [cycle, hashes] of latestEntries) {
        entries[cycle] = {
          cycleHash: hashes.cycleHash!,
          receiptHash: hashes.receiptHash!,
          originalTxHash: hashes.originalTxHash!,
        }
      }

      reply.send({
        success: true,
        data: entries,
      })
    } catch (error) {
      Logger.mainLogger.error('Error serving checkpoint-status:', error)
      reply.send({
        success: false,
        error: 'Internal server error',
      })
    } finally {
      profilerInstance.profileSectionEnd('GET_checkpoint_status')
    }
  })

  type CycleInfoRequest = FastifyRequest<{
    Body: {
      start: number
      end: number
      count: number
      download: boolean
    }
  }>

  server.post('/cycleinfo', async (_request: CycleInfoRequest & Request, reply) => {
    profilerInstance.profileSectionStart('POST_cycleinfo')
    try {
      const requestData = _request.body
      const result = validateRequestData(
        requestData,
        {
          start: 'n?',
          end: 'n?',
          count: 'n?',
          download: 'b?',
          sender: 's',
          sign: 'o',
        },
        true
      )
      if (!result.success) {
        reply.send(Crypto.sign({ success: false, error: result.error }))
        return
      }
      const { start, end, count, download } = _request.body
      if (download !== undefined && typeof download !== 'boolean') {
        reply.send(Crypto.sign({ success: false, error: `Invalid download flag` }))
        return
      }
      const isDownload: boolean = download === true
      let cycleInfo = []
      if (count) {
        if (count <= 0 || Number.isNaN(count)) {
          reply.send(Crypto.sign({ success: false, error: `Invalid count` }))
          return
        }
        if (count > MAX_CYCLES_PER_REQUEST) {
          reply.send(Crypto.sign({ success: false, error: `Max count is ${MAX_CYCLES_PER_REQUEST}.` }))
          return
        }
        cycleInfo = await CycleDB.queryLatestCycleRecords(count)
      } else if (start || start === 0) {
        const from = start
        const to = end ? end : from
        if (!(from >= 0 && to >= from) || Number.isNaN(from) || Number.isNaN(to)) {
          Logger.mainLogger.error(`Invalid start and end counters`)
          reply.send(Crypto.sign({ success: false, error: `Invalid start and end counters` }))
          return
        }
        const cycleCount = to - from
        if (cycleCount > MAX_CYCLES_PER_REQUEST) {
          Logger.mainLogger.error(`Exceed maximum limit of ${MAX_CYCLES_PER_REQUEST} cycles`)
          reply.send(Crypto.sign({ success: false, error: `Exceed maximum limit of ${MAX_CYCLES_PER_REQUEST} cycles` }))
          return
        }
        cycleInfo = await CycleDB.queryCycleRecordsBetween(from, to)
        if (isDownload) {
          const dataInBuffer = Buffer.from(StringUtils.safeStringify(cycleInfo), 'utf-8')
          const dataInStream = Readable.from(dataInBuffer)
          const filename = `cycle_records_from_${from}_to_${to}`

          reply.headers({
            'content-disposition': `attachment; filename="${filename}"`,
            'content-type': 'application/octet-stream',
          })
          reply.send(dataInStream)
          return
        }
      } else {
        reply.send(
          Crypto.sign({
            success: false,
            error: 'not specified which cycle to show',
          })
        )
        return
      }
      const res = Crypto.sign({
        cycleInfo,
      })
      reply.send(res)
    } finally {
      profilerInstance.profileSectionEnd('POST_cycleinfo')
    }
  })

  type CycleInfoCountRequest = FastifyRequest<{
    Params: { count: string }
  }>

  server.get('/cycleinfo/:count', async (_request: CycleInfoCountRequest, reply) => {
    profilerInstance.profileSectionStart('GET_cycleinfo')
    try {
      const err = Utils.validateTypes(_request.params, { count: 's' })
      if (err) {
        reply.send({ success: false, error: err })
        return
      }
      let count: number = parseInt(_request.params.count)
      if (count <= 0 || Number.isNaN(count)) {
        reply.send({ success: false, error: `Invalid count` })
        return
      }
      if (count > MAX_CYCLES_PER_REQUEST) count = MAX_CYCLES_PER_REQUEST
      const res = await Cycles.getLatestCycleRecords(count)
      reply.send(res)
    } finally {
      profilerInstance.profileSectionEnd('GET_cycleinfo')
    }
  })

  type ReceiptRequest = FastifyRequest<{
    Body: {
      count: number
      start: number
      end: number
      startCycle: number
      endCycle: number
      type: string
      page: number
      txId: string
      txIdList: string[]
    }
  }>

  server.post('/originalTx', async (_request: ReceiptRequest & Request, reply) => {
    profilerInstance.profileSectionStart('POST_originalTx')
    try {
      const requestData = _request.body
      const result = validateRequestData(requestData, {
        count: 'n?',
        start: 'n?',
        end: 'n?',
        startCycle: 'n?',
        endCycle: 'n?',
        type: 's?',
        page: 'n?',
        txId: 's?',
        txIdList: 'a?',
        sender: 's',
        sign: 'o',
      })
      if (!result.success) {
        reply.send(Crypto.sign({ success: false, error: result.error }))
        return
      }
      const { count, start, end, startCycle, endCycle, type, page, txId, txIdList } = _request.body
      let originalTxs: (OriginalTxDB.OriginalTxData | OriginalTxDB.OriginalTxDataCount)[] | number = []
      if (count) {
        if (count <= 0 || Number.isNaN(count)) {
          reply.send(Crypto.sign({ success: false, error: `Invalid count` }))
          return
        }
        if (count > MAX_ORIGINAL_TXS_PER_REQUEST) {
          reply.send(Crypto.sign({ success: false, error: `Max count is ${MAX_ORIGINAL_TXS_PER_REQUEST}` }))
          return
        }
        originalTxs = await OriginalTxDB.queryLatestOriginalTxs(count)
      } else if (txId) {
        if (txId.length !== TXID_LENGTH) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Invalid txId ${txId}`,
            })
          )
          return
        }
        const originalTx = await OriginalTxDB.queryOriginalTxDataByTxId(txId)
        if (originalTx) originalTxs.push(originalTx)
      } else if (txIdList) {
        if (txIdList.length > MAX_ORIGINAL_TXS_PER_REQUEST) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Exceed maximum limit of ${MAX_ORIGINAL_TXS_PER_REQUEST} original transactions`,
            })
          )
          return
        }
        for (const [txId, txTimestamp] of txIdList) {
          if (typeof txId !== 'string' || txId.length !== TXID_LENGTH || typeof txTimestamp !== 'number') {
            reply.send(
              Crypto.sign({
                success: false,
                error: `Invalid txId ${txId} in the List`,
              })
            )
            return
          }

          const originalTx = await OriginalTxDB.queryOriginalTxDataByTxId(txId, txTimestamp)
          if (originalTx) originalTxs.push(originalTx)
        }
      } else if (start || start === 0) {
        const from = start
        const to = end ? end : from
        if (!(from >= 0 && to >= from) || Number.isNaN(from) || Number.isNaN(to)) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Invalid start and end counters`,
            })
          )
          return
        }
        const count = to - from
        if (count > MAX_ORIGINAL_TXS_PER_REQUEST) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Exceed maximum limit of ${MAX_ORIGINAL_TXS_PER_REQUEST} original transactions`,
            })
          )
          return
        }
        originalTxs = await OriginalTxDB.queryOriginalTxsData(from, count + 1)
      } else if (startCycle || startCycle === 0) {
        const from = startCycle
        const to = endCycle ? endCycle : from
        if (!(from >= 0 && to >= from) || Number.isNaN(from) || Number.isNaN(to)) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Invalid startCycle and endCycle counters`,
            })
          )
          return
        }
        const count = to - from
        if (count > MAX_BETWEEN_CYCLES_PER_REQUEST) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Exceed maximum limit of ${MAX_BETWEEN_CYCLES_PER_REQUEST} cycles`,
            })
          )
          return
        }
        if (type === 'tally') {
          originalTxs = await OriginalTxDB.queryOriginalTxDataCountByCycles(from, to)
        } else if (type === 'count') {
          originalTxs = await OriginalTxDB.queryOriginalTxDataCount(from, to)
        } else {
          let skip = 0
          const limit = MAX_ORIGINAL_TXS_PER_REQUEST
          if (page) {
            if (page < 1 || Number.isNaN(page)) {
              reply.send(Crypto.sign({ success: false, error: `Invalid page number` }))
              return
            }
            skip = page - 1
            if (skip > 0) skip = skip * limit
          }
          originalTxs = await OriginalTxDB.queryOriginalTxsData(skip, limit, from, to)
        }
      }
      const res = Crypto.sign({
        originalTxs,
      })
      reply.send(res)
    } finally {
      profilerInstance.profileSectionEnd('POST_originalTx')
    }
  })

  server.post('/receipt', async (_request: ReceiptRequest & Request, reply) => {
    profilerInstance.profileSectionStart('POST_receipt')
    try {
      const requestData = _request.body
      const result = validateRequestData(requestData, {
        count: 'n?',
        start: 'n?',
        end: 'n?',
        startCycle: 'n?',
        endCycle: 'n?',
        type: 's?',
        page: 'n?',
        txId: 's?',
        txIdList: 'a?',
        sender: 's',
        sign: 'o',
      })
      if (!result.success) {
        reply.send(Crypto.sign({ success: false, error: result.error }))
        return
      }
      const { count, start, end, startCycle, endCycle, type, page, txId, txIdList } = _request.body
      let receipts: (ReceiptDB.Receipt | ReceiptDB.ReceiptCount)[] | number = []
      if (count) {
        if (count <= 0 || Number.isNaN(count)) {
          reply.send(Crypto.sign({ success: false, error: `Invalid count` }))
          return
        }
        if (count > MAX_RECEIPTS_PER_REQUEST) {
          reply.send(Crypto.sign({ success: false, error: `Max count is ${MAX_RECEIPTS_PER_REQUEST}` }))
          return
        }
        receipts = await ReceiptDB.queryLatestReceipts(count)
      } else if (txId) {
        if (txId.length !== TXID_LENGTH) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Invalid txId ${txId}`,
            })
          )
          return
        }
        const receipt = await ReceiptDB.queryReceiptByReceiptId(txId)
        if (receipt) receipts.push(receipt)
      } else if (txIdList) {
        if (txIdList.length > MAX_RECEIPTS_PER_REQUEST) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Exceed maximum limit of ${MAX_RECEIPTS_PER_REQUEST} receipts`,
            })
          )
          return
        }
        for (const [txId, txTimestamp] of txIdList) {
          if (typeof txId !== 'string' || txId.length !== TXID_LENGTH || typeof txTimestamp !== 'number') {
            reply.send(
              Crypto.sign({
                success: false,
                error: `Invalid txId ${txId} in the List`,
              })
            )
            return
          }
          const receipt = await ReceiptDB.queryReceiptByReceiptId(txId, txTimestamp)
          if (receipt) receipts.push(receipt)
        }
      } else if (start || start === 0) {
        const from = start
        const to = end ? end : from
        if (!(from >= 0 && to >= from) || Number.isNaN(from) || Number.isNaN(to)) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Invalid start and end counters`,
            })
          )
          return
        }
        const count = to - from
        if (count > MAX_RECEIPTS_PER_REQUEST) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Exceed maximum limit of ${MAX_RECEIPTS_PER_REQUEST} receipts`,
            })
          )
          return
        }
        receipts = await ReceiptDB.queryReceipts(from, count + 1)
      } else if (startCycle || startCycle === 0) {
        const from = startCycle
        const to = endCycle ? endCycle : from
        if (!(from >= 0 && to >= from) || Number.isNaN(from) || Number.isNaN(to)) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Invalid startCycle and endCycle counters`,
            })
          )
          return
        }
        const count = to - from
        if (count > MAX_BETWEEN_CYCLES_PER_REQUEST) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Exceed maximum limit of ${MAX_BETWEEN_CYCLES_PER_REQUEST} cycles`,
            })
          )
          return
        }
        if (type === 'tally') {
          receipts = await ReceiptDB.queryReceiptCountByCycles(from, to)
        } else if (type === 'count') {
          receipts = await ReceiptDB.queryReceiptCountBetweenCycles(from, to)
        } else {
          let skip = 0
          const limit = MAX_RECEIPTS_PER_REQUEST
          if (page) {
            if (page < 1 || Number.isNaN(page)) {
              reply.send(Crypto.sign({ success: false, error: `Invalid page number` }))
              return
            }
            skip = page - 1
            if (skip > 0) skip = skip * limit
          }
          receipts = await ReceiptDB.queryReceiptsBetweenCycles(skip, limit, from, to)
        }
      }
      const res = Crypto.sign({
        receipts,
      })
      reply.send(res)
    } finally {
      profilerInstance.profileSectionEnd('POST_receipt')
    }
  })

  type AccountRequest = FastifyRequest<{
    Body: {
      count: number
      start: number
      end: number
      startCycle: number
      endCycle: number
      page: number
      accountId: string
    }
  }>

  server.post('/account', async (_request: AccountRequest & Request, reply) => {
    profilerInstance.profileSectionStart('POST_account')
    try {
      const requestData = _request.body
      const result = validateRequestData(requestData, {
        count: 'n?',
        start: 'n?',
        end: 'n?',
        startCycle: 'n?',
        endCycle: 'n?',
        page: 'n?',
        accountId: 's?',
        sender: 's',
        sign: 'o',
      })
      if (!result.success) {
        reply.send(Crypto.sign({ success: false, error: result.error }))
        return
      }
      let accounts: AccountDB.AccountsCopy | AccountDB.AccountsCopy[] | number = []
      let totalAccounts = 0
      let res
      const { count, start, end, startCycle, endCycle, page, accountId } = _request.body
      if (count) {
        if (count <= 0 || Number.isNaN(count)) {
          reply.send(Crypto.sign({ success: false, error: `Invalid count` }))
          return
        }
        if (count > MAX_ACCOUNTS_PER_REQUEST) {
          reply.send(Crypto.sign({ success: false, error: `Max count is ${MAX_ACCOUNTS_PER_REQUEST}` }))
          return
        }
        accounts = await AccountDB.queryLatestAccounts(count)
        res = { accounts }
      } else if (start || start === 0) {
        const from = start
        const to = end ? end : from
        if (!(from >= 0 && to >= from) || Number.isNaN(from) || Number.isNaN(to)) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Invalid start and end counters`,
            })
          )
          return
        }
        const count = to - from
        if (count > MAX_ACCOUNTS_PER_REQUEST) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Exceed maximum limit of ${MAX_ACCOUNTS_PER_REQUEST} accounts`,
            })
          )
          return
        }
        accounts = await AccountDB.queryAccounts(from, count + 1)
        res = { accounts }
      } else if (startCycle || startCycle === 0) {
        const from = startCycle
        const to = endCycle ? endCycle : from
        if (!(from >= 0 && to >= from) || Number.isNaN(from) || Number.isNaN(to)) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Invalid startCycle and endCycle counters`,
            })
          )
          return
        }
        const count = to - from
        if (count > MAX_BETWEEN_CYCLES_PER_REQUEST) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Exceed maximum limit of ${MAX_BETWEEN_CYCLES_PER_REQUEST} cycles to query accounts Count`,
            })
          )
          return
        }
        totalAccounts = await AccountDB.queryAccountCountBetweenCycles(from, to)
        if (page) {
          if (page < 1 || Number.isNaN(page)) {
            reply.send(Crypto.sign({ success: false, error: `Invalid page number` }))
            return
          }
          let skip = page - 1
          const limit = MAX_ACCOUNTS_PER_REQUEST
          if (skip > 0) skip = skip * limit
          accounts = await AccountDB.queryAccountsBetweenCycles(skip, limit, from, to)
          res = { accounts, totalAccounts }
        } else {
          res = { totalAccounts }
        }
      } else if (accountId) {
        accounts = await AccountDB.queryAccountByAccountId(accountId)
        res = { accounts }
      } else {
        reply.send(
          Crypto.sign({
            success: false,
            error: 'not specified which account to show',
          })
        )
        return
      }
      reply.send(Crypto.sign(res))
    } finally {
      profilerInstance.profileSectionEnd('POST_account')
    }
  })

  type TransactionRequest = FastifyRequest<{
    Body: {
      count: number
      start: number
      end: number
      startCycle: number
      endCycle: number
      txId: string
      page: number
      appReceiptId: string
    }
  }>

  server.post('/transaction', async (_request: TransactionRequest & Request, reply) => {
    profilerInstance.profileSectionStart('POST_transaction')
    try {
      const requestData = _request.body
      const result = validateRequestData(requestData, {
        count: 'n?',
        start: 'n?',
        end: 'n?',
        txId: 's?',
        appReceiptId: 's?',
        startCycle: 'n?',
        endCycle: 'n?',
        page: 'n?',
        sender: 's',
        sign: 'o',
      })
      if (!result.success) {
        reply.send(Crypto.sign({ success: false, error: result.error }))
        return
      }
      const { count, start, end, txId, appReceiptId, startCycle, endCycle, page } = _request.body
      let transactions: TransactionDB.Transaction | TransactionDB.Transaction[] = []
      let totalTransactions = 0
      let res
      if (count) {
        if (count <= 0 || Number.isNaN(count)) {
          reply.send(Crypto.sign({ success: false, error: `Invalid count` }))
          return
        }
        if (count > MAX_ACCOUNTS_PER_REQUEST) {
          reply.send(Crypto.sign({ success: false, error: `Max count is ${MAX_ACCOUNTS_PER_REQUEST}` }))
          return
        }
        transactions = await TransactionDB.queryLatestTransactions(count)
        res = { transactions }
      } else if (start || start === 0) {
        const from = start
        const to = end ? end : from
        if (!(from >= 0 && to >= from) || Number.isNaN(from) || Number.isNaN(to)) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Invalid start and end counters`,
            })
          )
          return
        }
        const count = to - from
        if (count > MAX_ACCOUNTS_PER_REQUEST) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Exceed maximum limit of ${MAX_ACCOUNTS_PER_REQUEST} transactions`,
            })
          )
          return
        }
        transactions = await TransactionDB.queryTransactions(from, count + 1)
        res = { transactions }
      } else if (startCycle || startCycle === 0) {
        const from = startCycle
        const to = endCycle ? endCycle : from
        if (!(from >= 0 && to >= from) || Number.isNaN(from) || Number.isNaN(to)) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Invalid startCycle and endCycle counters`,
            })
          )
          return
        }
        const count = to - from
        if (count > MAX_BETWEEN_CYCLES_PER_REQUEST) {
          reply.send(
            Crypto.sign({
              success: false,
              error: `Exceed maximum limit of ${MAX_BETWEEN_CYCLES_PER_REQUEST} cycles to query transactions Count`,
            })
          )
          return
        }
        totalTransactions = await TransactionDB.queryTransactionCountBetweenCycles(from, to)
        if (page) {
          if (page < 1 || Number.isNaN(page)) {
            reply.send(Crypto.sign({ success: false, error: `Invalid page number` }))
            return
          }
          let skip = page - 1
          const limit = MAX_ACCOUNTS_PER_REQUEST
          if (skip > 0) skip = skip * limit
          transactions = await TransactionDB.queryTransactionsBetweenCycles(skip, limit, from, to)
          res = { transactions, totalTransactions }
        } else {
          res = { totalTransactions }
        }
      } else if (txId) {
        transactions = await TransactionDB.queryTransactionByTxId(txId)
        res = { transactions }
      } else if (appReceiptId) {
        transactions = await TransactionDB.queryTransactionByAccountId(appReceiptId)
        res = { transactions }
      } else {
        res = {
          success: false,
          error: 'not specified which transaction to show',
        }
        reply.send(Crypto.sign(res))
        return
      }
      reply.send(Crypto.sign(res))
    } finally {
      profilerInstance.profileSectionEnd('POST_transaction')
    }
  })

  server.post('/totalData', async (_request: Request, reply) => {
    profilerInstance.profileSectionStart('POST_totalData')
    try {
      const requestData = _request.body
      const result = validateRequestData(requestData, {
        sender: 's',
        sign: 'o',
      })
      if (!result.success) {
        reply.send(Crypto.sign({ success: false, error: result.error }))
        return
      }
      const totalCycles = await CycleDB.queryCyleCount()
      const totalAccounts = await AccountDB.queryAccountCount()
      const totalTransactions = await TransactionDB.queryTransactionCount()
      const totalReceipts = await ReceiptDB.queryReceiptCount()
      const totalOriginalTxs = await OriginalTxDB.queryOriginalTxDataCount()

      // Get the last five minutes bucket status for each checkpoint manager
      const cycleLastFiveMinutesGiveUpBucketStatus = getCheckpointManager(
        CheckpointType.Cycle
      )?.hasLastFailedBucketExceededDuration()
      const originalTxLastFiveMinutesGiveUpBucketStatus = getCheckpointManager(
        CheckpointType.OriginalTx
      )?.hasLastFailedBucketExceededDuration()
      const receiptLastFiveMinutesGiveUpBucketStatus = getCheckpointManager(
        CheckpointType.Receipt
      )?.hasLastFailedBucketExceededDuration()

      reply.send(
        Crypto.sign({
          totalCycles,
          totalAccounts,
          totalTransactions,
          totalReceipts,
          totalOriginalTxs,
          cycleLastFiveMinutesGiveUpBucketStatus,
          originalTxLastFiveMinutesGiveUpBucketStatus,
          receiptLastFiveMinutesGiveUpBucketStatus,
        })
      )
    } finally {
      profilerInstance.profileSectionEnd('POST_totalData')
    }
  })

  type GossipDataRequest = FastifyRequest<{
    Body: GossipData.GossipData
  }>

  server.post('/gossip-data', async (_request: GossipDataRequest, reply) => {
    profilerInstance.profileSectionStart('POST_gossip-data')
    try {
      const gossipPayload = _request.body
      if (config.VERBOSE) Logger.mainLogger.debug('Gossip Data received', StringUtils.safeStringify(gossipPayload))
      const result = Collector.validateGossipData(gossipPayload)
      if (!result.success) {
        reply.send({ success: false, error: result.error })
        return
      }
      const res = Crypto.sign({
        success: true,
      })
      reply.send(res)
      Collector.processGossipData(gossipPayload)
    } finally {
      profilerInstance.profileSectionEnd('POST_gossip-data')
    }
  })

  type AccountDataRequest = FastifyRequest<{
    Body: AccountDataProvider.AccountDataRequestSchema | AccountDataProvider.AccountDataByListRequestSchema
  }>
  type ConfigPatchRequest = FastifyRequest<{
    Body: Partial<ConfigInterface>
  }>

  server.post('/get_account_data_archiver', async (_request: AccountDataRequest, reply) => {
    profilerInstance.profileSectionStart('POST_get_account_data')
    try {
      const payload = _request.body as AccountDataProvider.AccountDataRequestSchema
      if (config.VERBOSE) Logger.mainLogger.debug('Account Data received', StringUtils.safeStringify(payload))
      const result = AccountDataProvider.validateAccountDataRequest(payload)
      // Logger.mainLogger.debug('Account Data validation result', result)
      if (!result.success) {
        reply.send({ success: false, error: result.error })
        return
      }
      if (payload.maxRecords > config.maxRecordsPerRequest || payload.maxRecords <= 0) {
        reply.send({
          success: false,
          error: `Invalid AccountBucket size. Size was ${payload.maxRecords}. Must be greater than 0 and less than ${config.maxRecordsPerRequest}.`,
        })
        return
      }
      const data = await AccountDataProvider.provideAccountDataRequest(payload)
      // Logger.mainLogger.debug('Account Data result', data)
      const res = Crypto.sign({
        success: true,
        data,
      })
      reply.send(res)
    } finally {
      profilerInstance.profileSectionEnd('POST_get_account_data')
    }
  })

  server.post('/get_account_data_by_list_archiver', async (_request: AccountDataRequest, reply) => {
    profilerInstance.profileSectionStart('POST_get_account_data_by_list')
    try {
      const payload = _request.body as AccountDataProvider.AccountDataByListRequestSchema
      if (config.VERBOSE) Logger.mainLogger.debug('Account Data By List received', StringUtils.safeStringify(payload))
      const result = AccountDataProvider.validateAccountDataByListRequest(payload)
      // Logger.mainLogger.debug('Account Data By List validation result', result)
      if (!result.success) {
        reply.send({ success: false, error: result.error })
        return
      }
      const accountData = await AccountDataProvider.provideAccountDataByListRequest(payload)
      Logger.mainLogger.debug(
        '[DEBUG RESTORE] Account Data By List result',
        accountData.map((account) => `${account.accountId}: ${account.stateId}`)
      )
      const res = Crypto.sign({
        success: true,
        accountData,
      })
      reply.send(res)
    } finally {
      profilerInstance.profileSectionEnd('POST_get_account_data_by_list')
    }
  })

  server.post('/get_globalaccountreport_archiver', async (_request: AccountDataRequest, reply) => {
    profilerInstance.profileSectionStart('GET_globalaccountreport_archiver')
    try {
      const payload = _request.body as AccountDataProvider.GlobalAccountReportRequestSchema
      if (config.VERBOSE) Logger.mainLogger.debug('Global Account Report received', StringUtils.safeStringify(payload))
      const result = AccountDataProvider.validateGlobalAccountReportRequest(payload)
      // Logger.mainLogger.debug('Global Account Report validation result', result)
      if (!result.success) {
        reply.send({ success: false, error: result.error })
        return
      }
      const report = await AccountDataProvider.provideGlobalAccountReportRequest()
      Logger.mainLogger.debug(
        '[DEBUG RESTORE] Global Account Report result',
        report.accounts.map((account) => `${account.id}: ${account.hash}`)
      )
      const res = Crypto.sign(report)
      reply.send(res)
    } finally {
      profilerInstance.profileSectionEnd('GET_globalaccountreport_archiver')
    }
  })

  /**
   * This endpoint is used to update the archiver config.
   * @script A test script to hit this endpoint is available at `scripts/update_config.ts`
   */
  server.patch(
    '/set-config',
    {
      preHandler: async (_request, reply) => {
        isDebugMiddleware(_request, reply)
      },
    },
    async (_request: ConfigPatchRequest, reply) => {
      const RESTRICTED_PARAMS = [
        'ARCHIVER_IP',
        'ARCHIVER_PORT',
        'ARCHIVER_HASH_KEY',
        'ARCHIVER_SECRET_KEY',
        'ARCHIVER_PUBLIC_KEY',
      ]
      try {
        const { sign, ...newConfig } = _request.body
        const validKeys = new Set(Object.keys(config))
        const payloadKeys = Object.keys(newConfig)
        const invalidKeys = payloadKeys.filter((key) => !validKeys.has(key) || RESTRICTED_PARAMS.includes(key))

        if (invalidKeys.length > 0)
          throw new Error(`Invalid/Unauthorised config properties provided: ${invalidKeys.join(', ')}`)

        if (config.VERBOSE)
          Logger.mainLogger.debug('Archiver config update executed: ', StringUtils.safeStringify(newConfig))

        const updatedConfig = updateConfig(newConfig)
        reply.send({ success: true, ...updatedConfig, ARCHIVER_SECRET_KEY: '' })
      } catch (error) {
        reply.status(400).send({ success: false, reason: error.message })
      }
    }
  )

  // Config Endpoint
  server.get(
    '/config',
    {
      preHandler: async (_request, reply) => {
        isDebugMiddleware(_request, reply)
      },
    },
    (_request, reply) => {
      reply.send({ ...config, ARCHIVER_SECRET_KEY: '' }) // send the config without the secret key
    }
  )

  // dataSenders Endpoint
  server.get(
    '/dataSenders',
    {
      preHandler: async (_request, reply) => {
        isDebugMiddleware(_request, reply)
      },
    },
    (_request, reply) => {
      const data = {
        dataSendersSize: Data.dataSenders.size,
        socketClientsSize: Data.socketClients.size,
      }
      if (_request.query && _request.query['dataSendersList'] === 'true')
        data['dataSendersList'] = Array.from(Data.dataSenders.values()).map(
          (item) => item.nodeInfo.ip + ':' + item.nodeInfo.port
        )
      reply.send(data)
    }
  )

  const enableLoseYourself = false // set this to `true` during testing, but never commit as `true`

  server.get(
    '/lose-yourself',
    // this debug endpoint is in support of development and testing of
    // lost archiver detection
    {
      preHandler: async (_request, reply) => {
        isDebugMiddleware(_request, reply)
      },
    },
    (_request, reply) => {
      if (enableLoseYourself) {
        Logger.mainLogger.debug('/lose-yourself: exit(1)')

        reply.send({ status: 'success', message: 'will exit' })

        // We don't call exitArchiver() here because that awaits Data.sendLeaveRequest(...),
        // but we're simulating a lost node.
        process.exit(1)
      } else {
        Logger.mainLogger.debug('/lose-yourself: not enabled. no action taken.')
        reply.send({ status: 'failure', message: 'not enabled' })
        // set enableLoseYourself to true--but never commit!
      }
    }
  )

  // ping the archiver to see if it's alive
  server.get(
    '/ping',
    // this debug endpoint is in support of development and testing of
    // lost archiver detection
    {
      preHandler: async (_request, reply) => {
        isDebugMiddleware(_request, reply)
      },
    },
    (request, reply) => {
      if (reachabilityAllowed) {
        reply.status(200).send('pong!')
      } else {
        request.raw.socket.destroy()
      }
    }
  )

  server.get(
    '/set-reachability',
    {
      schema: {
        querystring: {
          properties: {
            value: {
              type: 'boolean',
            },
          },
        },
      },
      preHandler: async (request, reply) => {
        isDebugMiddleware(request, reply)
      },
    },
    async (request, reply) => {
      const msg = `/set-reachability`
      console.log(msg)
      Logger.mainLogger.info(msg)
      const value = (request.query as { value: boolean }).value
      if (typeof value !== 'boolean') {
        Logger.mainLogger.info('/set-reachability: value must be a boolean')
        reply.status(400).send('value must be a boolean')
      } else {
        const msg = `/set-reachability: ${value}`
        console.log(msg)
        Logger.mainLogger.info(msg)
        reachabilityAllowed = value
      }
    }
  )

  server.get(
    '/verified-receipt-counter',
    {
      preHandler: async (_request, reply) => {
        isDebugMiddleware(_request, reply)
      },
    },
    (_request, reply) => {
      reply.send({
        receivedReceiptCount,
        verifiedReceiptCount,
        successReceiptCount,
        failureReceiptCount,
      })
    }
  )

  server.get('/status', async (_request, reply) => {
    Logger.mainLogger.debug('Status request received')
    const status = {
      isActive: State.isActive,
    }

    Logger.mainLogger.debug('Status response', status)
    const res = Crypto.sign({
      status,
    })
    reply.send(res)
  })

  // Old snapshot ArchivedCycle endpoint;
  if (!config.experimentalSnapshot) {
    type FullArchiveRequest = FastifyRequest<{
      Querystring: {
        start: string
        end: string
      }
    }>

    server.get('/full-archive', async (_request: FullArchiveRequest, reply) => {
      const err = Utils.validateTypes(_request.query, { start: 's', end: 's' })
      if (err) {
        reply.send({ success: false, error: err })
        return
      }
      const { start, end } = _request.query
      const from = start ? parseInt(start) : 0
      const to = end ? parseInt(end) : from
      if (!(from >= 0 && to >= from) || Number.isNaN(from) || Number.isNaN(to)) {
        reply.send({ success: false, error: `Invalid start and end counters` })
        return
      }
      const count = to - from
      if (count > MAX_BETWEEN_CYCLES_PER_REQUEST) {
        reply.send({
          success: false,
          error: `Exceed maximum limit of ${MAX_BETWEEN_CYCLES_PER_REQUEST} cycles`,
        })
        return
      }
      let archivedCycles = []
      archivedCycles = await Storage.queryAllArchivedCyclesBetween(from, to)
      const res = Crypto.sign({
        archivedCycles,
      })
      reply.send(res)
    })

    type FullArchiveCountRequest = FastifyRequest<{
      Params: {
        count: string
      }
    }>

    server.get('/full-archive/:count', async (_request: FullArchiveCountRequest, reply) => {
      const err = Utils.validateTypes(_request.params, { count: 's' })
      if (err) {
        reply.send({ success: false, error: err })
        return
      }

      const count: number = parseInt(_request.params.count)
      if (count <= 0 || Number.isNaN(count)) {
        reply.send({ success: false, error: `Invalid count` })
        return
      }
      if (count > MAX_BETWEEN_CYCLES_PER_REQUEST) {
        reply.send({ success: false, error: `Max count is ${MAX_BETWEEN_CYCLES_PER_REQUEST}` })
        return
      }
      const archivedCycles = await Storage.queryAllArchivedCycles(count)
      const res = Crypto.sign({
        archivedCycles,
      })
      reply.send(res)
    })

    type GossipHashesRequest = FastifyRequest<{
      Body: {
        sender: string
        data: any // eslint-disable-line @typescript-eslint/no-explicit-any
      }
    }>

    server.post('/gossip-hashes', async (_request: GossipHashesRequest, reply) => {
      const gossipMessage = _request.body
      Logger.mainLogger.debug('Gossip received', StringUtils.safeStringify(gossipMessage))
      addHashesGossip(gossipMessage.sender, gossipMessage.data)
      const res = Crypto.sign({
        success: true,
      })
      reply.send(res)
    })
  }

  type GetNetworkAccountRequest = FastifyRequest<{
    Querystring: { hash: 'true' | 'false' }
  }>

  server.get('/get-network-account', (_request: GetNetworkAccountRequest, reply) => {
    const useHash = _request.query?.hash !== 'false'

    const response = useHash
      ? { networkAccountHash: getGlobalNetworkAccount(useHash) }
      : { networkAccount: getGlobalNetworkAccount(useHash) }

    // We might want to sign this response
    reply.send(Crypto.sign(response))
  })

  // Register ticket routes
  server.register(ticketRoutes, { prefix: '/tickets' })

  server.post('/shareCheckpointRadixDigests', async (req: any, reply) => {
    try {
      const result = validateRequestData(req.body, {
        sender: 's',
        sign: 'o',
        senderAddress: 's',
        bucketID: 's',
        radixDigests: 's',
        checkpointType: 'n',
        startTime: 'n',
        endTime: 'n',
      })
      if (!result.success) {
        reply.send({ success: false, error: result.error })
        return
      }
      const { bucketID, radixDigests, senderAddress, checkpointType } = req.body

      // Identify the correct manager based on the checkpoint type
      const manager = getCheckpointManager(checkpointType)
      let bucket = manager.checkpointBuckets.get(bucketID)
      if (!bucket) {
        Logger.mainLogger.info(`missing bucket for bucketID=${bucketID}, checkpoint type ${checkpointType}`)
        nestedCountersInstance.countEvent(
          'checkpoint',
          `missing bucket for bucketID=${bucketID}, checkpoint type ${checkpointType}`
        )
        if (config.VERBOSE) {
          Logger.mainLogger.debug(
            `Bucket not found: No bucket with ID=${bucketID} for checkpoint type ${checkpointType}.`
          )
        }
        const startTime = req.body.startTime
        const endTime = req.body.endTime
        bucket = new CheckpointBucket(
          startTime,
          endTime,
          bucketID,
          manager.validateData,
          manager.updateData,
          manager.checkpointType
        )
        manager.checkpointBuckets.set(bucketID, bucket)
        Logger.mainLogger.info(
          `Successfully created missing bucket with ID=${bucketID} for checkpoint type ${checkpointType}`
        )
      }

      // Process received digests
      Logger.mainLogger.info(`Processing received digests for bucket ID=${bucketID} from ${senderAddress}.`)
      manager.onHashDigestsReceived(senderAddress, bucketID, StringUtils.safeJsonParse(radixDigests))

      reply.status(200).send({
        success: true,
      })
    } catch (err) {
      Logger.mainLogger.error(
        `Error processing shareCheckpointRadixDigests for checkpoint type ${req.body.checkpointType}: ${err.message}`
      )
      reply.status(500).send({ success: false, error: 'Server error' })
    }
  })

  server.post('/exchangeCheckpointRadixEntries', async (req: any, reply) => {
    try {
      const result = validateRequestData(req.body, {
        sender: 's',
        sign: 'o',
        bucketID: 's',
        entries: 's',
        checkpointType: 'n',
      })
      if (!result.success) {
        reply.send({ success: false, error: result.error })
        return
      }
      const { bucketID, entries, checkpointType } = req.body
      const parsedEntries = StringUtils.safeJsonParse(entries)

      const manager = getCheckpointManager(checkpointType)
      const bucket = manager.checkpointBuckets.get(bucketID)
      if (!bucket) {
        if (config.VERBOSE) {
          Logger.mainLogger.debug(
            `Bucket not found: No bucket with ID=${bucketID} for checkpoint type ${checkpointType}.`
          )
        }
        reply.status(404).send({ success: false, error: `Bucket not found for ID=${bucketID}.` })
        return
      }

      // Get our entries to share back
      const ourEntries: CheckpointRadixEntry<Cycle>[] = []

      // For each incoming entry, get our corresponding entry
      for (const incomingEntry of parsedEntries) {
        const radix = incomingEntry.digest.radix
        const ourEntry = bucket.radixEntries.get(radix)
        if (ourEntry) {
          ourEntry.updateDigest()
          ourEntries.push(ourEntry)
        }
      }

      // Process their entries
      bucket.onExchangeRadixEntries(bucketID, parsedEntries)

      // Send our entries back
      const res = Crypto.sign({
        bucketID,
        entries: ourEntries,
        success: true,
      })
      reply.send(res)
    } catch (err) {
      Logger.mainLogger.error(
        `Error processing exchangeCheckpointRadixEntries for checkpoint type ${req.body.checkpointType}: ${err.message}`
      )
      reply.status(500).send({
        success: false,
        error: `Server error in exchangeCheckpointRadixEntries for type ${req.body.checkpointType}`,
      })
    }
  })

  type BucketVerificationRequest = FastifyRequest<{
    Body: { bucketID: string; endBucketID?: string }
  }>

  server.post('/bucket-verification', async (request: BucketVerificationRequest & Request, reply) => {
    try {
      const requestData = request.body
      const result = validateRequestData(requestData, {
        bucketID: 's',
        endBucketID: '?s',
        sender: 's',
        sign: 'o',
      })
      if (!result.success) {
        reply.code(400).send({
          success: false,
          error: result.error,
        })
        return
      }

      const bucketID = parseInt(requestData.bucketID, 10)
      let endBucketID: number | undefined = undefined

      if (requestData.endBucketID) {
        endBucketID = parseInt(requestData.endBucketID, 10)
        if (isNaN(endBucketID) || endBucketID < 0) {
          reply.code(400).send({
            success: false,
            error: 'Invalid endBucketID. Must be a non-negative integer.',
          })
          return
        }
      }

      if (isNaN(bucketID) || bucketID < 0) {
        reply.code(400).send({
          success: false,
          error: 'Invalid bucketID. Must be a non-negative integer.',
        })
        return
      }

      const isVerified = await isBucketVerified(bucketID, endBucketID)

      const response = Crypto.sign({
        success: true,
        isVerified,
      })

      reply.send(response)
    } catch (error) {
      Logger.mainLogger.error(`Error checking bucket verification status:`, error)
      reply.code(500).send({
        success: false,
        error: 'Internal server error while checking bucket verification status',
      })
    }
  })
}

export const validateRequestData = (
  data: unknown & { sender: string; sign: Signature },
  expectedDataType: Record<string, unknown>,
  skipArchiverCheck = false
): { success: boolean; error?: string } => {
  try {
    let err = Utils.validateTypes(data, expectedDataType)
    if (err) {
      Logger.mainLogger.error('Invalid request data ', err)
      return { success: false, error: 'Invalid request data ' + err }
    }
    err = Utils.validateTypes(data.sign, { owner: 's', sig: 's' })
    if (err) {
      Logger.mainLogger.error('Invalid request data signature ', err)
      return { success: false, error: 'Invalid request data signature ' + err }
    }
    if (data.sign.owner !== data.sender) {
      Logger.mainLogger.error('Data sender publicKey and sign owner key does not match')
      return { success: false, error: 'Data sender publicKey and sign owner key does not match' }
    }
    if (!skipArchiverCheck && config.limitToArchiversOnly) {
      // Check if the sender is in the allowed archivers list
      const isAllowedArchiver = allowedArchiversManager.isArchiverAllowed(data.sender)

      // Check if the sender is in the active archiver list or is the devPublicKey
      const isActiveArchiver = State.activeArchivers.some((archiver) => archiver.publicKey === data.sender)

      const approvedSender =
        isAllowedArchiver || (isAllowedArchiver && isActiveArchiver) || config.DevPublicKey === data.sender

      if (!approvedSender) {
        return {
          success: false,
          error: isAllowedArchiver
            ? 'Archiver is not in the allowed archiver list'
            : 'Data request sender is not an authorized archiver',
        }
      }
    }
    if (!Crypto.verify(data)) {
      Logger.mainLogger.error('Invalid signature', data)
      return { success: false, error: 'Invalid signature' }
    }
    return { success: true }
  } catch (e) {
    Logger.mainLogger.error('Error validating request data', e)
    return { success: false, error: 'Error validating request data' }
  }
}

export enum RequestDataType {
  CYCLE = 'cycleinfo',
  RECEIPT = 'receipt',
  ORIGINALTX = 'originalTx',
  ACCOUNT = 'account',
  TRANSACTION = 'transaction',
  TOTALDATA = 'totalData',
  CHECKPOINT = 'checkpoint',
}

interface QueryParams {
  startCycle?: number
  endCycle?: number
  start?: number
  end?: number
  type?: string
  page?: number
  count?: number
  archiver?: State.ArchiverNodeInfo
}

export const queryFromArchivers = async (
  type: RequestDataType,
  queryParameters: QueryParams,
  timeoutInSecond?: number
): Promise<unknown | null> => {
  let bucketID: number | undefined
  const params = queryParameters as any
  let checkpointStatusType: CheckpointStatusType | undefined
  let bucketRange: { start: number; end: number } | undefined

  // Extract bucket ID based on the request type and parameters
  switch (type) {
    case RequestDataType.CYCLE:
      // For cycle info, use start or end as bucket ID
      if (params.start !== undefined && params.end !== undefined) {
        // If both start and end are provided, we'll check the entire range
        bucketRange = {
          start: params.start,
          end: params.end,
        }
        bucketID = params.start // Default to start for single bucket check fallback
      } else if (params.start !== undefined) {
        bucketID = params.start
      } else if (params.end !== undefined) {
        bucketID = params.end
      }
      checkpointStatusType = CheckpointStatusType.CYCLE
      break
    case RequestDataType.RECEIPT:
      checkpointStatusType = CheckpointStatusType.RECEIPT
      break
    case RequestDataType.ORIGINALTX:
      checkpointStatusType = CheckpointStatusType.ORIGINAL_TX
      break
    case RequestDataType.ACCOUNT:
    case RequestDataType.TRANSACTION:
      // For other data types, check if startCycle or endCycle is specified
      if (params.startCycle !== undefined && params.endCycle !== undefined) {
        // If both startCycle and endCycle are provided, we'll check the entire range
        bucketRange = {
          start: params.startCycle,
          end: params.endCycle,
        }
        bucketID = params.startCycle // Default to startCycle for single bucket check fallback
      } else if (params.startCycle !== undefined) {
        bucketID = params.startCycle
      } else if (params.endCycle !== undefined) {
        bucketID = params.endCycle
      }
      break
  }

  const data = {
    ...queryParameters,
    sender: config.ARCHIVER_PUBLIC_KEY,
  }
  const signedDataToSend = Crypto.sign(data)
  let url
  switch (type) {
    case RequestDataType.CYCLE:
      url = `/cycleinfo`
      break
    case RequestDataType.RECEIPT:
      url = `/receipt`
      break
    case RequestDataType.ORIGINALTX:
      url = `/originalTx`
      break
    case RequestDataType.ACCOUNT:
      url = `/account`
      break
    case RequestDataType.TRANSACTION:
      url = `/transaction`
      break
    case RequestDataType.TOTALDATA:
      url = `/totalData`
      break
  }

  const maxNumberofArchiversToRetry = 3
  let archiversToTry: any[]

  if (params.archiver) {
    archiversToTry = [params.archiver]
  } else {
    archiversToTry = Utils.getRandomItemFromArr(State.otherArchivers, 0, maxNumberofArchiversToRetry)
  }

  // Try to find an archiver with verified data if checkpoint is enabled and we have bucket information
  if (
    config.checkpoint.bucketConfig.allowCheckpointUpdates &&
    archiversToTry.length > 0 &&
    (bucketRange !== undefined || bucketID !== undefined)
  ) {
    // Try to find an archiver with verified data for the bucket range or single bucket
    const verifiedArchiver = await findVerifiedArchiver(archiversToTry, bucketRange, bucketID, timeoutInSecond)

    if (verifiedArchiver) {
      try {
        const response = await P2P.postJson(
          `http://${verifiedArchiver.ip}:${verifiedArchiver.port}${url}`,
          signedDataToSend,
          timeoutInSecond
        )

        // Validate response using Crypto.verify
        if (response) {
          const signatureVerificationResult = Crypto.verify(response as { sender: string; sign: Signature })
          if (signatureVerificationResult) {
            return response
          } else {
            if (config.VERBOSE) {
              Logger.mainLogger.error(
                `Invalid response format from verified archiver ${verifiedArchiver.ip}:${verifiedArchiver.port} for ${type}`
              )
            }
          }
        }
      } catch (error) {
        Logger.mainLogger.error(
          `Error querying data from verified archiver ${verifiedArchiver.ip}:${verifiedArchiver.port}:`,
          error
        )
      }
    }
  }

  // If no archiver had verified data or checkpoint is disabled, try any archiver
  for (let retry = 0; retry < maxNumberofArchiversToRetry; retry++) {
    const archiver = archiversToTry[retry] || archiversToTry[0]
    if (!archiver) continue

    try {
      const response = await P2P.postJson(
        `http://${archiver.ip}:${archiver.port}${url}`,
        signedDataToSend,
        timeoutInSecond
      )

      // Validate response using Crypto.verify
      if (response) {
        const signatureVerificationResult = Crypto.verify(response as { sender: string; sign: Signature })
        if (signatureVerificationResult) {
          return response
        } else {
          Logger.mainLogger.error(`Invalid response format from archiver ${archiver.ip}:${archiver.port} for ${type}`)
        }
      }
    } catch (e) {
      Logger.mainLogger.error(
        `Error while querying ${archiver.ip}:${archiver.port}${url} for data ${StringUtils.safeStringify(queryParameters)}`,
        e
      )
    }
  }

  return null
}

// Helper function to find an archiver with verified data
async function findVerifiedArchiver(
  archivers: any[],
  bucketRange?: { start: number; end: number },
  singleBucketID?: number,
  timeoutInSecond?: number
): Promise<any | null> {
  for (const archiver of archivers) {
    if (!archiver) continue

    try {
      if (bucketRange) {
        // Check verification for the bucket range
        const verificationData = {
          bucketID: bucketRange.start.toString(),
          endBucketID: bucketRange.end.toString(),
          sender: config.ARCHIVER_PUBLIC_KEY,
        }
        const signedBucketVerificationDataToSend = Crypto.sign(verificationData)
        const verificationResponse: { success?: boolean; isVerified?: boolean; sign?: Signature; sender?: string } =
          await P2P.postJson(
            `http://${archiver.ip}:${archiver.port}/bucket-verification`,
            signedBucketVerificationDataToSend,
            timeoutInSecond
          )

        if (verificationResponse?.success && verificationResponse?.isVerified) {
          const signatureVerificationResult = Crypto.verify(verificationResponse as { sender: string; sign: Signature })
          if (signatureVerificationResult) {
            return archiver
          }
        }
      } else if (singleBucketID !== undefined) {
        // Check verification for a single bucket
        const verificationData = {
          bucketID: singleBucketID.toString(),
          sender: config.ARCHIVER_PUBLIC_KEY,
        }
        const signedBucketVerificationDataToSend = Crypto.sign(verificationData)
        const verificationResponse: { sender?: string; sign?: Signature; success?: boolean; isVerified?: boolean } =
          await P2P.postJson(
            `http://${archiver.ip}:${archiver.port}/bucket-verification`,
            signedBucketVerificationDataToSend,
            timeoutInSecond
          )

        if (verificationResponse?.success && verificationResponse?.isVerified) {
          const signatureVerificationResult = Crypto.verify(verificationResponse as { sender: string; sign: Signature })
          if (signatureVerificationResult) {
            return archiver
          }
        }
      }
    } catch (error) {
      Logger.mainLogger.error(`Error checking bucket verification for archiver ${archiver.ip}:${archiver.port}:`, error)
    }
  }

  return null
}