@xyo-network/chain-bridge 1.15.2 → 1.15.3

package/src/server/routes/addRoutes.ts

@@ -1,11 +1,7 @@
 import type { Express } from 'express'
 
-import { addNodeRoutes } from './address/index.ts'
-import { addDataLakeRoutes } from './dataLake/index.ts'
-import { addRpcRoutes } from './rpc/index.ts'
+import { addBridgeRoutes } from './bridge/index.ts'
 
 export const addRoutes = (app: Express) => {
-  addRpcRoutes(app)
-  addDataLakeRoutes(app)
-  addNodeRoutes(app)
+  addBridgeRoutes(app)
 }

package/src/server/routes/bridge/addBridgeRoutes.ts

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

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

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

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

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

package/src/server/routes/bridge/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/bridge/routeDefinitions/getRouteDefinitions.ts

@@ -0,0 +1,13 @@
+import type { RouteDefinition } from './routeDefinition.ts'
+import {
+  bridgeFromRemoteStatus, bridgeToRemote, bridgeToRemoteEstimate, bridgeToRemoteStatus,
+} from './routes/index.ts'
+
+export const getRouteDefinitions = (): RouteDefinition[] => {
+  return [
+    bridgeFromRemoteStatus,
+    bridgeToRemote,
+    bridgeToRemoteEstimate,
+    bridgeToRemoteStatus,
+  ]
+}

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

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

package/src/server/routes/bridge/routeDefinitions/pathParams/ChainIdPathParam.ts

@@ -0,0 +1,18 @@
+import {
+  hexFromHexString, HexZod, isAddress, toAddress,
+} from '@xylabs/hex'
+import { isUndefined } from '@xylabs/typeof'
+import type { ChainId } from '@xyo-network/xl1-protocol'
+
+const remoteChainId: ChainId = toAddress('0x01')
+
+export const ChainIdPathParam = HexZod.refine(
+  (val) => {
+    const chainIdHex = hexFromHexString(val, { prefix: true })
+    if (isAddress(chainIdHex)) return false
+    const suppliedChainId = toAddress(chainIdHex)
+    if (isUndefined(suppliedChainId)) return false
+    return suppliedChainId === remoteChainId
+  },
+  { message: `Only ${remoteChainId} is supported` },
+)

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

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

package/src/server/routes/bridge/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/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts

@@ -0,0 +1,55 @@
+import { toAddress, toHex } from '@xylabs/hex'
+import { PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
+import type { BridgeDestinationObservation } from '@xyo-network/xl1-protocol'
+import {
+  BridgeDestinationObservationFieldsZod,
+  BridgeDestinationObservationSchema,
+} from '@xyo-network/xl1-protocol'
+import { z } from 'zod'
+
+import { requestHandlerValidator } from '../../middleware/index.ts'
+import { ChainIdPathParam } from '../pathParams/index.ts'
+import type { RouteDefinition } from '../routeDefinition.ts'
+
+const params = z.object({
+  chainId: ChainIdPathParam,
+  nonce: z.string(),
+})
+const response = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(
+  BridgeDestinationObservationFieldsZod.shape,
+)
+
+const validateRequest = requestHandlerValidator({
+  params,
+  response,
+})
+
+export const bridgeFromRemoteStatus: RouteDefinition = {
+  method: 'get',
+  path: '/bridge/chains/:chainId/bridgeFromRemote/status/:nonce',
+  handlers: validateRequest(async (req, res) => {
+    const { chainId } = req.params
+    const rand = await Promise.resolve(Math.random())
+
+    // TODO: Replace with actual lookup logic (e.g. database or chain query)
+    const found = rand > 0.5 // simulate lookup
+    if (!found) return res.sendStatus(404)
+
+    const confirmed = rand > 0.8 // simulate pending/confirmed
+    if (!confirmed) return res.sendStatus(204)
+
+    const observation: BridgeDestinationObservation = {
+      schema: BridgeDestinationObservationSchema,
+      dest: chainId,
+      destAddress: toAddress('0xabc'),
+      destAmount: toHex('0x100'),
+      destToken: toAddress('0xdef'),
+      src: toAddress('0x02'),
+      srcAddress: toAddress('0x123'),
+      srcAmount: toHex('0x200'),
+      srcToken: toHex('0x456'),
+      destConfirmation: toHex('0x9999'),
+    }
+    res.json(observation)
+  }),
+}

package/src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts

@@ -0,0 +1,58 @@
+import { asHash, toAddress } from '@xylabs/hex'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { PayloadZodLooseOfSchema, PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
+import type {
+  BridgeSourceObservation, BridgeSourceObservationFields, ChainId,
+} from '@xyo-network/xl1-protocol'
+import {
+  BridgeIntentFieldsZod,
+  BridgeIntentSchema,
+  BridgeSourceObservationFieldsZod,
+  BridgeSourceObservationSchema,
+  TransferSchema,
+} from '@xyo-network/xl1-protocol'
+import { z } from 'zod'
+
+import { requestHandlerValidator } from '../../middleware/index.ts'
+import { ChainIdPathParam } from '../pathParams/index.ts'
+import type { RouteDefinition } from '../routeDefinition.ts'
+
+// TODO: Replace with actual chain logic / contract integration
+const remoteChainId: ChainId = toAddress('0x01')
+
+const params = z.object({ chainId: ChainIdPathParam })
+const body = z.tuple([
+  // TODO: TransactionBoundWitness
+  PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
+  PayloadZodLooseOfSchema(TransferSchema),
+])
+const response = PayloadZodStrictOfSchema(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape)
+
+const validateRequest = requestHandlerValidator({
+  params,
+  body,
+  response,
+})
+
+export const bridgeToRemote: RouteDefinition = {
+  method: 'post',
+  path: '/bridge/chains/:chainId/bridgeToRemote',
+  handlers: validateRequest(async (req, res) => {
+    const { body } = req
+    const [bridgeIntent, transfer] = body
+    // TODO: Execute bridge transaction on-chain
+    const srcConfirmation = await Promise.resolve(asHash('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'))
+
+    // Extract common fields for BridgeSourceObservation from BridgeIntent
+    const bridgeCommonFieldsZod = z.object({}).extend(BridgeSourceObservationFieldsZod.shape)
+    const bridgeCommonFields = bridgeCommonFieldsZod.parse(bridgeIntent)
+    const bridgeObservationFields: BridgeSourceObservationFields = {
+      ...bridgeCommonFields,
+      srcConfirmation,
+    }
+    const bridgeObservation: BridgeSourceObservation = new PayloadBuilder<BridgeSourceObservation>(
+      { schema: BridgeSourceObservationSchema },
+    ).fields(bridgeObservationFields).build()
+    res.json(bridgeObservation)
+  }),
+}

package/src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts

@@ -0,0 +1,83 @@
+import {
+  hexToBigInt, toAddress, toHex,
+} from '@xylabs/hex'
+import { createTransferPayload } from '@xyo-network/chain-protocol'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { PayloadZodLooseOfSchema, PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
+import type {
+  BridgeIntent, BridgeIntentFields, ChainId, Transfer,
+} from '@xyo-network/xl1-protocol'
+import {
+  BridgeIntentFieldsZod, BridgeIntentSchema, TransferSchema,
+} from '@xyo-network/xl1-protocol'
+import { v4 } from 'uuid'
+import { z } from 'zod'
+
+import { requestHandlerValidator } from '../../middleware/index.ts'
+import { ChainIdPathParam } from '../pathParams/index.ts'
+import type { RouteDefinition } from '../routeDefinition.ts'
+
+// TODO: Get from config
+const TOKEN_ADDRESS = '0x5FbDB2315678afecb367f032d93F642f64180aa3'
+const bridgeableTokenContract = toHex(TOKEN_ADDRESS)
+const xl1ChainId: ChainId = toAddress('0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9')
+const fixedFee: bigint = 1_000_000_000_000_000n
+const percentFee: bigint = 5n // 0.5%
+const bridgeEscrowAddress = toAddress('0x0a')
+const bridgeFeesAddress = toAddress('0x0b')
+const remoteChainId: ChainId = toHex('0x01')
+
+const params = z.object({ chainId: ChainIdPathParam })
+const body = BridgeIntentFieldsZod.pick({
+  destAddress: true,
+  srcAddress: true,
+  srcAmount: true,
+})
+const response = z.tuple([
+  PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
+  PayloadZodLooseOfSchema(TransferSchema),
+])
+const validateRequest = requestHandlerValidator({
+  params, body, response,
+})
+
+export const bridgeToRemoteEstimate: RouteDefinition = {
+  method: 'post',
+  path: '/bridge/chains/:chainId/bridgeToRemote/estimate',
+  handlers: validateRequest((req, res) => {
+    const {
+      srcAddress, srcAmount, destAddress,
+    } = req.body
+
+    const srcAmountBigInt = hexToBigInt(srcAmount)
+    const feeAmount = fixedFee + ((srcAmountBigInt * percentFee) / 100n)
+    const destAmountBigInt = srcAmountBigInt > feeAmount ? srcAmountBigInt - feeAmount : 0n
+    const destAmount = toHex(destAmountBigInt)
+    const nonce = v4()
+
+    const sender = toAddress(srcAddress)
+
+    const bridgeIntentFields: BridgeIntentFields = {
+      // Source
+      src: xl1ChainId,
+      srcAddress,
+      srcAmount,
+      srcToken: xl1ChainId,
+
+      // Destination
+      dest: remoteChainId,
+      destAddress,
+      destAmount,
+      destToken: bridgeableTokenContract,
+      nonce,
+    }
+    const bridgeIntent: BridgeIntent = new PayloadBuilder<BridgeIntent>({ schema: BridgeIntentSchema }).fields(bridgeIntentFields).build()
+
+    const transfer: Transfer = createTransferPayload(sender, {
+      [bridgeEscrowAddress]: destAmountBigInt,
+      [bridgeFeesAddress]: feeAmount,
+    })
+
+    res.json([bridgeIntent, transfer])
+  }),
+}

package/src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteStatus.ts

@@ -0,0 +1,55 @@
+import { toAddress, toHex } from '@xylabs/hex'
+import { PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
+import type { BridgeDestinationObservation } from '@xyo-network/xl1-protocol'
+import {
+  BridgeDestinationObservationFieldsZod,
+  BridgeDestinationObservationSchema,
+} from '@xyo-network/xl1-protocol'
+import { z } from 'zod'
+
+import { requestHandlerValidator } from '../../middleware/index.ts'
+import { ChainIdPathParam } from '../pathParams/index.ts'
+import type { RouteDefinition } from '../routeDefinition.ts'
+
+const params = z.object({
+  chainId: ChainIdPathParam,
+  nonce: z.string(),
+})
+const response = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(
+  BridgeDestinationObservationFieldsZod.shape,
+)
+
+const validateRequest = requestHandlerValidator({
+  params,
+  response,
+})
+
+export const bridgeToRemoteStatus: RouteDefinition = {
+  method: 'get',
+  path: '/bridge/chains/:chainId/bridgeToRemote/status/:nonce',
+  handlers: validateRequest(async (req, res) => {
+    const { chainId } = req.params
+    const rand = await Promise.resolve(Math.random())
+
+    // TODO: Replace with actual lookup logic (e.g. database or chain query)
+    const found = rand > 0.5 // simulate lookup
+    if (!found) return res.sendStatus(404)
+
+    const confirmed = rand > 0.8 // simulate pending/confirmed
+    if (!confirmed) return res.sendStatus(204)
+
+    const observation: BridgeDestinationObservation = {
+      schema: BridgeDestinationObservationSchema,
+      dest: chainId,
+      destAddress: toAddress('0xabc'),
+      destAmount: toHex('0x100'),
+      destToken: toAddress('0xdef'),
+      src: toAddress('0x02'),
+      srcAddress: toAddress('0x123'),
+      srcAmount: toHex('0x200'),
+      srcToken: toHex('0x456'),
+      destConfirmation: toHex('0x9999'),
+    }
+    res.json(observation)
+  }),
+}

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

@@ -0,0 +1,4 @@
+export * from './bridgeFromRemoteStatus.ts'
+export * from './bridgeToRemote.ts'
+export * from './bridgeToRemoteEstimate.ts'
+export * from './bridgeToRemoteStatus.ts'

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

@@ -17,4 +17,4 @@ const handler: RequestHandler<NoReqParams> = (_req, res) => {
   res.status(200).send(data)
 }
 
-export const getHealthz = handler
+export const getHealthz: RequestHandler<NoReqParams> = handler

package/src/server/routes/index.ts

@@ -1,5 +1,3 @@
 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/server.ts

@@ -1,13 +1,11 @@
 import { assertEx } from '@xylabs/assert'
 import type { Logger } from '@xylabs/logger'
-import { isDefined, isString } from '@xylabs/typeof'
-import { boot } from '@xyo-network/bios'
+import { isString } from '@xylabs/typeof'
 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 = '::'
@@ -42,17 +40,16 @@ interface GetServerContext {
 }
 
 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 { logger } = context
+  const { port } = context.config.bridge
+  await Promise.resolve() // bios booting is currently disabled
+  // 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()
   const server = app.listen(port, hostname, () => logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`))
   server.setTimeout(20_000)
   return server

package/dist/node/interface/service/ChainBridgeRelay/ChainBridgeRelayInterface.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ChainBridgeRelayInterface.d.ts","sourceRoot":"","sources":["../../../../../src/interface/service/ChainBridgeRelay/ChainBridgeRelayInterface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAE3F,OAAO,KAAK,EAAE,0BAA0B,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAA;AAErG,MAAM,WAAW,wBAAyB,SAAQ,yBAAyB,CAAC,YAAY,EAAE,4BAA4B,CAAC;CAAG;AAE1H,MAAM,WAAW,gBAAiB,SAAQ,0BAA0B,CAAC,YAAY,EAAE,4BAA4B,CAAC;CAAG;AAEnH,MAAM,WAAW,yBAA0B,SACzC,0BAA0B,CAAC,YAAY,EAAE,4BAA4B,CAAC,EACtE,yBAAyB,CAAC,YAAY,EAAE,4BAA4B,CAAC;CAAG"}

package/dist/node/interface/service/ChainBridgeRelay/ChainBridgeRelayService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ChainBridgeRelayService.d.ts","sourceRoot":"","sources":["../../../../../src/interface/service/ChainBridgeRelay/ChainBridgeRelayService.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,KAAK,EAAE,4BAA4B,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAE3F,OAAO,KAAK,EACV,4CAA4C,EAAE,4BAA4B,EAC1E,mBAAmB,EACnB,uCAAuC,EAAE,yBAAyB,EAAE,qCAAqC,EACzG,uCAAuC,EACxC,MAAM,0BAA0B,CAAA;AAEjC,qBAAa,uBAAuB,CAAC,OAAO,SAAS,mBAAmB,GAAG,mBAAmB,CAC5F,SAAQ,sBAAsB,CAAC,OAAO,CAAE,YAAW,yBAAyB;IAC5E,SAAS,KAAK,OAAO,yDAEpB;IAED,SAAS,KAAK,uBAAuB,IAAI,4CAA4C,CAEpF;IAED,SAAS,KAAK,gBAAgB,IAAI,yBAAyB,CAE1D;IAED,SAAS,KAAK,eAAe,IAAI,qCAAqC,CAErE;IAED,SAAS,KAAK,gBAAgB,IAAI,uCAAuC,CAExE;IAED,SAAS,KAAK,oBAAoB,IAAI,4BAA4B,CAEjE;IAED,SAAS,KAAK,kBAAkB,IAAI,uCAAuC,CAE1E;IAED;;;;OAIG;IACG,UAAU,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAiB9D;;;;OAIG;IACG,wBAAwB,CAAC,4BAA4B,EAAE,4BAA4B,GAAG,OAAO,CAAC,OAAO,CAAC;IAoB5G;;;;OAIG;IACG,SAAS,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC;CAqB1F"}

package/dist/node/interface/service/ChainBridgeRelay/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/interface/service/ChainBridgeRelay/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA"}

package/dist/node/interface/service/ChainBridgeRelay/spec/ChainBridgeRelayService.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ChainBridgeRelayService.spec.d.ts","sourceRoot":"","sources":["../../../../../../src/interface/service/ChainBridgeRelay/spec/ChainBridgeRelayService.spec.ts"],"names":[],"mappings":""}

package/dist/node/server/routes/rpc/index.d.ts

@@ -1,2 +0,0 @@
-export * from './routes/index.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/node/server/routes/rpc/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/server/routes/rpc/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA"}

package/dist/node/server/routes/rpc/routes/addRpcRoutes.d.ts

@@ -1,3 +0,0 @@
-import type { Express } from 'express';
-export declare const addRpcRoutes: (app: Express) => void;
-//# sourceMappingURL=addRpcRoutes.d.ts.map

package/dist/node/server/routes/rpc/routes/addRpcRoutes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"addRpcRoutes.d.ts","sourceRoot":"","sources":["../../../../../../src/server/routes/rpc/routes/addRpcRoutes.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAEtC,eAAO,MAAM,YAAY,GAAI,KAAK,OAAO,SAaxC,CAAA"}

package/dist/node/server/routes/rpc/routes/index.d.ts

@@ -1,2 +0,0 @@
-export * from './addRpcRoutes.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/node/server/routes/rpc/routes/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/server/routes/rpc/routes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA"}

package/src/manifest/public/Pending.json

@@ -1,35 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
-  "nodes": [
-    {
-      "config": {
-        "accountPath": "2",
-        "name": "Pending",
-        "schema": "network.xyo.node.config"
-      },
-      "modules": {
-        "private": [],
-        "public": [
-          {
-            "config": {
-              "accountPath": "2/1/2",
-              "name": "PendingTransactions",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "labels": {
-                "network.xyo.storage.class": "mongodb"
-              },
-              "payloadSdkConfig": {
-                "collection": "pending_bundles"
-              },
-              "schema": "network.xyo.archivist.config"
-            }
-          }
-        ]
-      }
-    }
-  ],
-  "schema": "network.xyo.manifest"
-}

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

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

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

@@ -1,22 +0,0 @@
-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

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