@xyo-network/chain-mempool 1.16.3

package/src/server/routes/dataLake/archivistMiddleware.ts

@@ -0,0 +1,86 @@
+import { setRawResponseFormat } from '@xylabs/express'
+import { asHash } from '@xylabs/hex'
+import { isDefined } from '@xylabs/typeof'
+import type {
+  ArchivistInstance,
+  ArchivistNextOptions, NextOptions,
+} from '@xyo-network/archivist-model'
+import { asArchivistInstance } from '@xyo-network/archivist-model'
+import type { ModuleIdentifier } from '@xyo-network/module-model'
+import type { NodeInstance } from '@xyo-network/node-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload } from '@xyo-network/payload-model'
+import { isAnyPayload, isSequence } from '@xyo-network/payload-model'
+import type { Router } from 'express'
+import express from 'express'
+import type { Request } from 'express-serve-static-core'
+
+const resolveArchivist = async (node: NodeInstance, archivistModuleIdentifier: ModuleIdentifier): Promise<ArchivistInstance> => {
+  const mod = await node.resolve(archivistModuleIdentifier)
+  return asArchivistInstance(mod, { required: true })
+}
+
+let archivistInstance: ArchivistInstance | undefined
+
+const getArchivist = async (node: NodeInstance, archivistModuleIdentifier: ModuleIdentifier): Promise<ArchivistInstance> => {
+  if (isDefined(archivistInstance)) return archivistInstance
+  archivistInstance = await resolveArchivist(node, archivistModuleIdentifier)
+  return archivistInstance
+}
+
+type ArchivistMiddlewareOptions = {
+  archivistModuleIdentifier: ModuleIdentifier
+  node: NodeInstance
+}
+
+export const archivistMiddleware = (options: ArchivistMiddlewareOptions): Router => {
+  const { node, archivistModuleIdentifier } = options
+  const router = express.Router({ mergeParams: true })
+
+  router.post('/insert', async (req, res) => {
+    setRawResponseFormat(res)
+    const body = Array.isArray(req.body) ? req.body : [req.body]
+    const payloads = (await PayloadBuilder.hashPairs<Payload>(body)).map(p => p[0])
+    const archivist = await getArchivist(node, archivistModuleIdentifier)
+    const result = await archivist.insert(payloads)
+    res.status(200).json(result)
+  })
+
+  router.get('/next', async (req: Request<Partial<NextOptions>>, res) => {
+    setRawResponseFormat(res)
+    const cursor = isSequence(req.query.cursor) ? req.query.cursor : undefined
+    const limit = isDefined(req.query.limit) ? Number(req.query.limit) : undefined
+    const open = isDefined(req.query.open) ? Boolean(req.query.open) : undefined
+    const order = req.query.order === 'asc' ? 'asc' : 'desc'
+    const options: ArchivistNextOptions = {
+      limit, open, order, cursor,
+    }
+    const archivist = await getArchivist(node, archivistModuleIdentifier)
+    const result = await archivist.next(options)
+    res.status(200).json(result)
+  })
+  router.post('/next', async (req: Request<{}, {}, ArchivistNextOptions | undefined>, res) => {
+    setRawResponseFormat(res)
+    const options = req.body
+    const archivist = await getArchivist(node, archivistModuleIdentifier)
+    const result = await (isDefined(options) ? archivist.next(options) : archivist.next())
+    res.status(200).json(result)
+  })
+
+  router.get('/get/:hash', async (req, res) => {
+    setRawResponseFormat(res)
+    const { hash: rawHash } = req.params
+    const hash = asHash(rawHash)
+    if (isDefined(hash)) {
+      const archivist = await getArchivist(node, archivistModuleIdentifier)
+      const [payload] = await archivist.get([hash])
+      if (isAnyPayload(payload)) {
+        res.json(payload)
+        return
+      }
+    }
+    res.status(400).send()
+  })
+
+  return router
+}

package/src/server/routes/dataLake/index.ts

@@ -0,0 +1 @@
+export * from './addDataLakeRoutes.ts'

package/src/server/routes/healthz/addHealthRoutes.ts

@@ -0,0 +1,14 @@
+import type { Express } from 'express'
+import { StatusCodes } from 'http-status-codes'
+
+export const addHealthRoutes = (app: Express) => {
+  app.get('/healthz', (_req, res) => {
+    res.status(StatusCodes.OK).send()
+  })
+  app.get('/livez', (_req, res) => {
+    res.status(StatusCodes.OK).send()
+  })
+  app.get('/readyz', (_req, res) => {
+    res.status(StatusCodes.OK).send()
+  })
+}

package/src/server/routes/healthz/index.ts

@@ -0,0 +1 @@
+export * from './addHealthRoutes.ts'

package/src/server/routes/index.ts

@@ -0,0 +1,3 @@
+export * from './address/index.ts'
+export * from './addRoutes.ts'
+export * from './healthz/index.ts'

package/src/server/server.ts

@@ -0,0 +1,63 @@
+import { assertEx } from '@xylabs/assert'
+import type { Logger } from '@xylabs/logger'
+import { isDefined, isString } from '@xylabs/typeof'
+import { boot } from '@xyo-network/bios'
+import type { BiosExternalInterface } from '@xyo-network/bios-model'
+import type { NodeInstance } from '@xyo-network/node-model'
+import { HDWallet } from '@xyo-network/wallet'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+
+import { getNode } from '../manifest/index.ts'
+import { getApp } from './app.ts'
+
+const hostname = '::'
+// const hostname = '0.0.0.0'
+
+// TODO: Make nodejs version of bios support round tripping mnemonic between boots
+const getSeedPhrase = async (bios: BiosExternalInterface, config: Config, logger?: Logger): Promise<string> => {
+  const storedSeedPhrase = await bios.seedPhraseStore.get('os')
+  logger?.debug(`[API] Stored mnemonic: ${storedSeedPhrase}`)
+  const { mnemonic } = config.api
+  if (isString(storedSeedPhrase) && isString(mnemonic)) {
+    logger?.warn('[API] Stored mnemonic does not match supplied. Updating stored mnemonic to supplied.')
+    await bios.seedPhraseStore.set('os', mnemonic)
+  } else {
+    let seedPhrase: string
+    if (isString(mnemonic)) {
+      seedPhrase = mnemonic
+    } else {
+      seedPhrase = HDWallet.generateMnemonic()
+      logger?.log('[API] No mnemonic provided, using random mnemonic. This is not recommended for production use.')
+      logger?.log(`[API] Mnemonic: ${seedPhrase}`)
+    }
+    await bios.seedPhraseStore.set('os', seedPhrase)
+  }
+  return assertEx(await bios.seedPhraseStore.get('os'), () => 'Unable to acquire mnemonic from bios')
+}
+
+interface GetServerContext {
+  config: Config
+  logger?: Logger
+  node?: NodeInstance
+}
+
+export const getServer = async (context: GetServerContext) => {
+  const {
+    config, logger, node,
+  } = context
+  const { mnemonic, port } = context.config.mempool
+  const bios = await boot()
+  const seedPhrase = isDefined(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger)
+  const wallet = await HDWallet.fromPhrase(seedPhrase)
+  const nodeContext = {
+    wallet, logger, config,
+  }
+  const resolvedNode: NodeInstance = node ?? await getNode(nodeContext)
+  const mods = await resolvedNode.resolve('*')
+  const startResults = await Promise.all(mods.map(mod => mod.start?.() ?? true))
+  assertEx(startResults.every(r => r === true), () => '[Mempool] Not all modules started successfully')
+  const app = getApp(resolvedNode)
+  const server = app.listen(port, hostname, () => logger?.log(`[Mempool] Server listening at http://${hostname}:${port}`))
+  server.setTimeout(20_000)
+  return server
+}