@xyo-network/chain-reward-redemption 1.15.10

package/src/manifest/nodeManifest.ts

@@ -0,0 +1,8 @@
+import type { PackageManifestPayload } from '@xyo-network/manifest-model'
+
+import node from './node.json' with { type: 'json' }
+
+/**
+ * Root Node Manifest
+ */
+export const NodeManifest = node as PackageManifestPayload

package/src/manifest/private/index.ts

@@ -0,0 +1,4 @@
+/**
+ * Private Child Manifests
+ */
+export const PrivateChildManifests = []

package/src/manifest/public/index.ts

@@ -0,0 +1,6 @@
+import type { ModuleManifest, PackageManifestPayload } from '@xyo-network/manifest-model'
+
+/**
+ * Public Child Manifests
+ */
+export const PublicChildManifests: ModuleManifest[] = []

package/src/server/app.ts

@@ -0,0 +1,30 @@
+import {
+  customPoweredByHeader, disableCaseSensitiveRouting, disableExpressDefaultPoweredByHeader, getJsonBodyParser, getJsonBodyParserOptions, responseProfiler,
+  standardErrors, standardResponses,
+} from '@xylabs/express'
+import type { NodeInstance } from '@xyo-network/node-model'
+import compression from 'compression'
+import cors from 'cors'
+import type { Express } from 'express'
+import express from 'express'
+
+import { addInstrumentation } from './instrumentation.ts'
+import { addRoutes } from './routes/index.ts'
+
+export const getApp = (node: NodeInstance): Express => {
+  addInstrumentation()
+  const app = express()
+  app.set('etag', false)
+  app.use(cors())
+  app.use(compression())
+  app.use(responseProfiler)
+  app.use(getJsonBodyParser(getJsonBodyParserOptions({ limit: '1mb' })))
+  app.use(standardResponses)
+  disableExpressDefaultPoweredByHeader(app)
+  app.use(customPoweredByHeader)
+  disableCaseSensitiveRouting(app)
+  app.node = node
+  addRoutes(app)
+  app.use(standardErrors)
+  return app
+}

package/src/server/index.ts

@@ -0,0 +1,13 @@
+export * from './app.ts'
+export * from './server.ts'
+
+import type { NodeInstance } from '@xyo-network/node-model'
+
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace Express {
+    interface Application {
+      node: NodeInstance
+    }
+  }
+}

package/src/server/instrumentation.ts

@@ -0,0 +1,15 @@
+import { registerInstrumentations } from '@opentelemetry/instrumentation'
+import { ExpressInstrumentation } from '@opentelemetry/instrumentation-express'
+import { HttpInstrumentation } from '@opentelemetry/instrumentation-http'
+
+/**
+ * Registers OpenTelemetry instrumentations for HTTP and Express.
+ * This function is used to set up the necessary instrumentations for monitoring
+ * HTTP requests and Express applications. Since it monkey patches the Express
+ * router & middleware system, it should be called before any Express applications
+ * are defined.
+ */
+export const addInstrumentation = () => {
+  const instrumentations = [new HttpInstrumentation(), new ExpressInstrumentation()]
+  registerInstrumentations({ instrumentations })
+}

package/src/server/routes/addRoutes.ts

@@ -0,0 +1,9 @@
+import type { Express } from 'express'
+
+import { addDataLakeRoutes } from './dataLake/index.ts'
+import { addRewardRedemptionRoutes } from './rewardRedemption/index.ts'
+
+export const addRoutes = (app: Express) => {
+  addDataLakeRoutes(app)
+  addRewardRedemptionRoutes(app)
+}

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

@@ -0,0 +1,3 @@
+export type AddressPathParams = {
+  address: string
+}

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

@@ -0,0 +1,21 @@
+import type { Express } from 'express'
+import { StatusCodes } from 'http-status-codes'
+
+import { getAddress } from './get/index.ts'
+import { postAddress } from './post/index.ts'
+
+export const addNodeRoutes = (app: Express) => {
+  const defaultModule = app.node
+  const address = defaultModule.address
+  const defaultModuleEndpoint = `/${address}`
+  app.get('/', (_req, res) => res.redirect(StatusCodes.MOVED_TEMPORARILY, defaultModuleEndpoint))
+  app.post('/', (_req, res) => res.redirect(StatusCodes.TEMPORARY_REDIRECT, defaultModuleEndpoint))
+  app.get('/:address', getAddress)
+  app.post('/:address', postAddress)
+  app.get('/:hash', (_req, res) => {
+    res.sendStatus(StatusCodes.NOT_FOUND)
+  })
+  app.post('/:hash', (_req, res) => {
+    res.sendStatus(StatusCodes.NOT_FOUND)
+  })
+}

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

@@ -0,0 +1,33 @@
+import { assertEx } from '@xylabs/assert'
+import { asyncHandler } from '@xylabs/express'
+import { asAddress, toAddress } from '@xylabs/hex'
+import { isModuleIdentifierPart } from '@xyo-network/module-model'
+import type { Payload } from '@xyo-network/payload-model'
+import type { RequestHandler } from 'express'
+import { StatusCodes } from 'http-status-codes'
+
+import type { AddressPathParams } from '../AddressPathParams.ts'
+
+const handler: RequestHandler<AddressPathParams, Payload[]> = async (req, res, next) => {
+  const { address: rawAddress } = req.params
+  const { node } = req.app
+  const address = asAddress(rawAddress)
+  if (address !== undefined) {
+    let mod = node.address === address ? node : (await node.resolve(address, { direction: 'down' }))
+    if (mod) {
+      res.json(await mod.state())
+      return
+    }
+  }
+  if (isModuleIdentifierPart(rawAddress)) {
+    const moduleIdentifier = toAddress(rawAddress)
+    const mod = await node.resolve(moduleIdentifier, { direction: 'down' })
+    if (mod) {
+      const moduleAddress = assertEx(mod?.address, () => 'Error redirecting to module by address')
+      res.redirect(StatusCodes.MOVED_TEMPORARILY, `/${moduleAddress}`)
+      return
+    }
+  }
+  next('route')
+}
+export const getAddress = asyncHandler(handler)

package/src/server/routes/address/get/index.ts

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

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

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

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

@@ -0,0 +1,23 @@
+import type { BoundWitness, QueryBoundWitness } from '@xyo-network/boundwitness-model'
+import { BoundWitnessSchema } from '@xyo-network/boundwitness-model'
+import type { ModuleConfig, ModuleInstance } from '@xyo-network/module-model'
+import { ModuleConfigSchema } from '@xyo-network/module-model'
+import type { Payload } from '@xyo-network/payload-model'
+import type { Request } from 'express'
+
+const DEFAULT_DEPTH = 5 as const
+
+export const getQueryConfig = (mod: ModuleInstance, req: Request, bw: QueryBoundWitness, payloads?: Payload[]): ModuleConfig | undefined => {
+  // TODO: Filter based on query addresses?
+  // Recurse through payloads for nested BWs
+  const nestedBwAddresses
+    = payloads
+      ?.flat(DEFAULT_DEPTH)
+      .filter<BoundWitness>((payload): payload is BoundWitness => payload?.schema === BoundWitnessSchema)
+      .map(bw => bw.addresses) || []
+  // TODO: Do we want to end up with a list of addresses or a list of address lists?
+  const addresses = [bw.addresses, ...nestedBwAddresses].filter(address => address.length > 0)
+  const allowed = addresses.length > 0 ? Object.fromEntries(mod.queries.map(schema => [schema, addresses])) : {}
+  const security = { allowed }
+  return { schema: ModuleConfigSchema, security }
+}

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

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

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 = 'RewardsArchivist'
+  app.use('/data', 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: RequestHandler<NoReqParams> = handler

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

@@ -0,0 +1 @@
+export * from './get.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/routes/rewardRedemption/addRewardRoutes.ts

@@ -0,0 +1,10 @@
+import type { Express } from 'express'
+
+import { getRouteDefinitions } from './routeDefinitions/index.ts'
+
+export const addRewardRedemptionRoutes = (app: Express) => {
+  const routeDefinitions = getRouteDefinitions()
+  for (const definition of routeDefinitions) {
+    app[definition.method](definition.path, definition.handlers)
+  }
+}

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

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

package/src/server/routes/rewardRedemption/middleware/index.ts

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

package/src/server/routes/rewardRedemption/middleware/requestHandlerValidator.ts

@@ -0,0 +1,120 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { ExpressError } from '@xylabs/express'
+import { isPromise } from '@xylabs/typeof'
+import type {
+  NextFunction, Request, RequestHandler, Response,
+} from 'express'
+import { ReasonPhrases, StatusCodes } from 'http-status-codes'
+import type { ZodType } from 'zod'
+import { z } from 'zod'
+
+/**
+ * Empty Zod schema for requests with no parameters.
+ */
+export const EmptyParamsZod = z.object({}).catchall(z.string())
+
+/**
+ * Empty Zod schema for requests with no query parameters.
+ */
+export const EmptyQueryParamsZod = z.object({}).catchall(z.union([z.string(), z.array(z.string())]))
+
+/**
+ * Default validation schemas for request handler validator.
+ */
+export const ValidateRequestDefaults = {
+  params: EmptyParamsZod,
+  query: EmptyQueryParamsZod,
+  body: z.json(),
+  response: z.json(),
+}
+
+type ValidatableRequestKey = 'params' | 'query' | 'body'
+
+/**
+ * Factory for Express middleware that validates request and response objects using Zod schemas.
+ * @param schemas The Zod schemas to use for validation.
+ * @returns A middleware function for validating requests and responses.
+ */
+export function requestHandlerValidator<
+  TParams extends typeof EmptyQueryParamsZod | ZodType<Record<string, string>> = typeof EmptyQueryParamsZod,
+  TQuery extends typeof EmptyQueryParamsZod | ZodType<Record<string, string | string[]>> = typeof EmptyQueryParamsZod,
+  TBody extends ZodType<unknown> = ZodType<unknown>,
+  TResponse extends ZodType<unknown> = ZodType<unknown>,
+>(schemas?: Partial<{
+  body: TBody
+  params: TParams
+  query: TQuery
+  response: TResponse
+}>) {
+  type Params = z.infer<TParams>
+  type Query = z.infer<TQuery>
+  type Body = z.infer<TBody>
+  type Res = z.infer<TResponse>
+  const validators = { ...ValidateRequestDefaults, ...schemas }
+
+  return (handler: (req: Request<Params, Res, Body, Query>, res: Response<Res>, next: NextFunction) => unknown): RequestHandler => {
+    return async (req: Request, res: Response, next: NextFunction) => {
+      const originalJson = res.json.bind(res)
+      try {
+      // Validate incoming request
+        const errors: string[] = []
+        const keys: ValidatableRequestKey[] = ['params', 'query', 'body']
+        for (const key of keys) {
+          const validator = validators[key]
+          const result = validator.safeParse(req[key])
+          if (result.success) {
+            Object.assign(req[key], result.data)
+          } else {
+            errors.push(
+              ...result.error.issues.map(
+                issue => (issue.path.length === 0)
+                  ? `${key}: ${issue.message}`
+                  : `${key}.${issue.path.join('.')}: ${issue.message}`,
+              ),
+            )
+          }
+        }
+
+        // If there were validation errors, short-circuit and return Bad Request
+        if (errors.length > 0) {
+          const message = errors.join('; ')
+          const err: ExpressError = new Error(message)
+          err.name = ReasonPhrases.BAD_REQUEST
+          err.statusCode = StatusCodes.BAD_REQUEST
+          next(err)
+          return false
+        }
+
+        // Wrap res.json to validate outgoing response
+        res.json = (data: any) => {
+          const result = validators.response.safeParse(data)
+          if (result.success) {
+            return originalJson(result.data)
+          } else {
+            const message = result.error.issues.map(
+              issue => (issue.path.length === 0)
+                ? `response: ${issue.message}`
+                : `response.${issue.path.join('.')}: ${issue.message}`,
+            ).join('; ')
+            const err: ExpressError = new Error(message)
+            err.name = ReasonPhrases.INTERNAL_SERVER_ERROR
+            err.statusCode = StatusCodes.INTERNAL_SERVER_ERROR
+
+            // Restore original json function in case the error handler wants to use it
+            res.json = originalJson
+            throw err
+          }
+        }
+
+        // Automatically handle async errors
+        const result = handler(req as any, res as any, next)
+        if (result && isPromise(result)) {
+          await result
+        }
+      } catch (err) {
+        res.json = originalJson
+        next(err)
+      }
+    }
+  }
+}

package/src/server/routes/rewardRedemption/routeDefinitions/getRouteDefinitions.ts

@@ -0,0 +1,9 @@
+import type { RouteDefinition } from './routeDefinition.ts'
+import { postClaim, postRedeem } from './routes/index.ts'
+
+export const getRouteDefinitions = (): RouteDefinition[] => {
+  return [
+    postClaim,
+    postRedeem,
+  ]
+}

package/src/server/routes/rewardRedemption/routeDefinitions/index.ts

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

package/src/server/routes/rewardRedemption/routeDefinitions/pathParams/AddressPathParam.ts

@@ -0,0 +1 @@
+export { EthAddressFromStringZod as AddressPathParam } from '@xylabs/hex'

package/src/server/routes/rewardRedemption/routeDefinitions/pathParams/index.ts

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

package/src/server/routes/rewardRedemption/routeDefinitions/routeDefinition.ts

@@ -0,0 +1,18 @@
+import type { RequestHandler } from 'express'
+
+export type HttpMethod
+  = | 'get'
+    | 'post'
+    | 'put'
+    | 'patch'
+    | 'delete'
+    | 'options'
+    | 'head'
+
+export interface RouteDefinition<
+  H extends RequestHandler = RequestHandler,
+> {
+  handlers: H[] | H
+  method: HttpMethod
+  path: string | RegExp
+}

package/src/server/routes/rewardRedemption/routeDefinitions/routes/claim.ts

@@ -0,0 +1,31 @@
+import { PayloadZodLoose } from '@xyo-network/payload-model'
+import { z } from 'zod'
+
+import { requestHandlerValidator } from '../../middleware/index.ts'
+import { AddressPathParam } from '../pathParams/index.ts'
+import type { RouteDefinition } from '../routeDefinition.ts'
+
+const params = z.object({ address: AddressPathParam })
+const body = PayloadZodLoose
+
+const response = PayloadZodLoose
+
+const validateRequest = requestHandlerValidator({
+  params,
+  body,
+  response,
+})
+
+export const postClaim: RouteDefinition = {
+  method: 'post',
+  path: '/rewards/claim/:address',
+  handlers: validateRequest(async (req, res) => {
+    const { address } = req.params
+    // TODO: Validate ETH address
+    // TODO: Redeem claim for existing rewards
+    // TODO: Return response payload
+    await Promise.resolve()
+    const observation = { schema: 'network.xyo.test' }
+    res.json(observation)
+  }),
+}

package/src/server/routes/rewardRedemption/routeDefinitions/routes/index.ts

@@ -0,0 +1,2 @@
+export * from './claim.ts'
+export * from './redeem.ts'

package/src/server/routes/rewardRedemption/routeDefinitions/routes/redeem.ts

@@ -0,0 +1,26 @@
+import { PayloadZodLoose } from '@xyo-network/payload-model'
+import { z } from 'zod'
+
+import { requestHandlerValidator } from '../../middleware/index.ts'
+import { AddressPathParam } from '../pathParams/index.ts'
+import type { RouteDefinition } from '../routeDefinition.ts'
+
+const params = z.object({ address: AddressPathParam })
+const body = PayloadZodLoose
+const response = PayloadZodLoose
+const validateRequest = requestHandlerValidator({
+  params,
+  body,
+  response,
+})
+
+export const postRedeem: RouteDefinition = {
+  method: 'post',
+  path: '/rewards/redeem/:address',
+  handlers: validateRequest(async (req, res) => {
+    const { body } = req
+    await Promise.resolve()
+    const bridgeObservation = { schema: 'network.xyo.test' }
+    res.json(bridgeObservation)
+  }),
+}