@xyo-network/chain-bridge 1.15.2

package/src/server/routes/address/post/post.ts

@@ -0,0 +1,77 @@
+import { assertEx } from '@xylabs/assert'
+import { asyncHandler } from '@xylabs/express'
+import {
+  asAddress, isAddress,
+  toAddress,
+} from '@xylabs/hex'
+import type { JsonObject } from '@xylabs/object'
+import { isQueryBoundWitness, type QueryBoundWitness } from '@xyo-network/boundwitness-model'
+import { ModuleErrorBuilder } from '@xyo-network/module-abstract'
+import type { ModuleInstance, ModuleQueryResult } from '@xyo-network/module-model'
+import type { ModuleError, Payload } from '@xyo-network/payload-model'
+import type { RequestHandler } from 'express'
+import { StatusCodes } from 'http-status-codes'
+
+import type { AddressPathParams } from '../AddressPathParams.ts'
+import { getQueryConfig } from './getQueryConfig.ts'
+
+type PostAddressRequestBody = [QueryBoundWitness, undefined | Payload[]]
+
+const handler: RequestHandler<AddressPathParams, ModuleQueryResult | ModuleError, PostAddressRequestBody> = async (req, res, next) => {
+  const returnError = (code: number, message = 'An error occurred', details?: JsonObject) => {
+    const error = new ModuleErrorBuilder().message(message).details(details).build()
+    res.locals.rawResponse = false
+    res.status(code).json(error)
+    next()
+  }
+
+  const { address } = req.params
+  const { node } = req.app
+  const [bw, payloads] = Array.isArray(req.body) ? req.body : []
+  if (!isAddress(address)) {
+    return returnError(StatusCodes.BAD_REQUEST, 'Missing address')
+  }
+
+  if (!bw) {
+    return returnError(StatusCodes.BAD_REQUEST, 'Missing boundwitness')
+  }
+
+  if (!isQueryBoundWitness(bw)) {
+    return returnError(StatusCodes.BAD_REQUEST, 'Invalid query boundwitness')
+  }
+
+  let modules: ModuleInstance[] = []
+  const normalizedAddress = toAddress(address)
+  if (node.address === normalizedAddress) modules = [node]
+  else {
+    const typedAddress = asAddress(address)
+    const byAddress = (typedAddress === undefined) ? undefined : await node.resolve(typedAddress, { maxDepth: 10 })
+
+    if (byAddress) modules = [byAddress]
+    else {
+      const byName = await node.resolve(address, { direction: 'down' })
+      if (byName) {
+        const moduleAddress = assertEx(byName?.address, () => 'Error redirecting to module by address')
+        res.redirect(StatusCodes.TEMPORARY_REDIRECT, `/${moduleAddress}`)
+        return
+      } else {
+        return returnError(StatusCodes.NOT_FOUND, 'Module not found', { address })
+      }
+    }
+  }
+
+  if (modules.length > 0) {
+    const mod = modules[0]
+    const queryConfig = getQueryConfig(mod, req, bw, payloads)
+    try {
+      const queryResult = await mod.query(bw, payloads, queryConfig)
+      res.json(queryResult)
+    } catch (ex) {
+      return returnError(StatusCodes.INTERNAL_SERVER_ERROR, 'Query Failed', { message: (ex as Error)?.message ?? 'Unknown Error' })
+    }
+  } else {
+    return returnError(StatusCodes.NOT_FOUND, 'Module not found', { address })
+  }
+}
+
+export const postAddress = asyncHandler(handler)

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

@@ -0,0 +1,9 @@
+import type { Express } from 'express'
+
+import { archivistMiddleware } from './archivistMiddleware.ts'
+
+export const addDataLakeRoutes = (app: Express) => {
+  const { node } = app
+  const archivistModuleIdentifier = 'Chain:Finalized'
+  app.use('/chain', archivistMiddleware({ node, archivistModuleIdentifier }))
+}

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/get.ts

@@ -0,0 +1,20 @@
+import type { NoReqParams } from '@xylabs/express'
+import { setRawResponseFormat } from '@xylabs/express'
+import type { RequestHandler } from 'express'
+import { ReasonPhrases } from 'http-status-codes'
+
+const message = ReasonPhrases.OK
+
+const handler: RequestHandler<NoReqParams> = (_req, res) => {
+  setRawResponseFormat(res)
+  const date = new Date()
+  const {
+    cpuUsage, memoryUsage, uptime,
+  } = process
+  const data = {
+    cpuUsage: cpuUsage(), date, memoryUsage: memoryUsage(), message, uptime: uptime(),
+  }
+  res.status(200).send(data)
+}
+
+export const getHealthz = handler

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

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

package/src/server/routes/index.ts

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

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

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

package/src/server/routes/rpc/routes/addRpcRoutes.ts

@@ -0,0 +1,22 @@
+import { setRawResponseFormat } from '@xylabs/express'
+import { NodeXyoViewer } from '@xyo-network/chain-rpc'
+import {
+  NodeXyoRunner, rpcEngineFromConnection,
+  XyoBaseConnection,
+} from '@xyo-network/xl1-rpc'
+import type { Express } from 'express'
+
+export const addRpcRoutes = (app: Express) => {
+  const { node } = app
+  const runner = new NodeXyoRunner(node)
+  const viewer = new NodeXyoViewer(node)
+  const connection = new XyoBaseConnection({ runner, viewer })
+  const engine = rpcEngineFromConnection(connection)
+
+  app.post('/rpc', (req, res) => {
+    setRawResponseFormat(res)
+    engine.handle(req.body, (_, rpcResponse) => {
+      res.json(rpcResponse)
+    })
+  })
+}

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

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

package/src/server/server.ts

@@ -0,0 +1,59 @@
+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(`[Bridge] Stored mnemonic: ${storedSeedPhrase}`)
+  const { mnemonic } = config.api
+  if (isString(storedSeedPhrase) && isString(mnemonic)) {
+    logger?.warn('[Bridge] 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('[Bridge] No mnemonic provided, using random mnemonic. This is not recommended for production use.')
+      logger?.log(`[Bridge] 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.api
+  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 app = getApp(node ?? await getNode(nodeContext))
+  const server = app.listen(port, hostname, () => logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`))
+  server.setTimeout(20_000)
+  return server
+}