@xyo-network/chain-bridge 1.20.14 → 1.20.16

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

@@ -1,18 +0,0 @@
-import type { RouteDefinition } from '@xylabs/express'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
-
-import {
-  makeBridgeConfigRoute, makeBridgeFromRemoteStatusRoute, makeBridgeToRemoteEstimateRoute, makeBridgeToRemoteMaxEstimateRoute, makeBridgeToRemoteRoute, makeBridgeToRemoteStatusRoute,
-} from './routes/index.ts'
-
-export const getRouteDefinitions = (config: BridgeConfig, gateway: XyoGatewayRunner): RouteDefinition[] => {
-  return [
-    makeBridgeConfigRoute(config),
-    makeBridgeToRemoteEstimateRoute(config, gateway),
-    makeBridgeToRemoteMaxEstimateRoute(config, gateway),
-    makeBridgeToRemoteRoute(config),
-    makeBridgeToRemoteStatusRoute(config),
-    makeBridgeFromRemoteStatusRoute(config),
-  ]
-}

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

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

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

@@ -1,21 +0,0 @@
-import {
-  asHex, HexZod, isUndefined,
-} from '@xylabs/sdk-js'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import type { ChainId } from '@xyo-network/xl1-sdk'
-
-import { getRemoteChainId } from '../../../../../config/index.ts'
-
-export const getRemoteChainIdZod = (config: BridgeConfig) => {
-  const remoteChainId: ChainId = getRemoteChainId(config)
-  return HexZod.superRefine((val, ctx) => {
-    const chainId = asHex(val)
-    if (isUndefined(chainId)) {
-      ctx.addIssue('Not a valid chain id')
-      return
-    }
-    if (chainId !== remoteChainId) {
-      ctx.addIssue(`Only ${remoteChainId} is supported`)
-    }
-  })
-}

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

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

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

@@ -1,46 +0,0 @@
-import type { RouteDefinition } from '@xylabs/express'
-import { requestHandlerValidator } from '@xylabs/express'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import { BridgeSettingsZod } from '@xyo-network/chain-orchestration'
-import type { z } from 'zod'
-
-import { getBridgeSettings } from '../../../../../config/index.ts'
-
-export const BridgeConfigResponseZod = BridgeSettingsZod
-export type BridgeConfigResponse = z.infer<typeof BridgeConfigResponseZod>
-
-const validateRequest = requestHandlerValidator({ response: BridgeConfigResponseZod })
-
-export const makeBridgeConfigRoute = (config: BridgeConfig): RouteDefinition => {
-  return {
-    method: 'get',
-    path: '/bridge/chains/:chainId/config',
-    handlers: validateRequest(async (_, res) => {
-      const {
-        escrowAddress,
-        feeFixed,
-        feeRateBasisPoints,
-        feesAddress,
-        maxBridgeAmount,
-        minBridgeAmount,
-        remoteChainId,
-        remoteTokenAddress,
-        xl1ChainId,
-        xl1TokenAddress,
-      } = await getBridgeSettings(config)
-      const sanitizedConfig = {
-        escrowAddress,
-        feeFixed,
-        feeRateBasisPoints,
-        feesAddress,
-        maxBridgeAmount,
-        minBridgeAmount,
-        remoteChainId,
-        remoteTokenAddress,
-        xl1ChainId,
-        xl1TokenAddress,
-      }
-      res.json(sanitizedConfig)
-    }),
-  }
-}

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

@@ -1,58 +0,0 @@
-import type { RouteDefinition } from '@xylabs/express'
-import { requestHandlerValidator } from '@xylabs/express'
-import { toAddress, toHex } from '@xylabs/sdk-js'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import { PayloadZodStrictOfSchema } from '@xyo-network/sdk-js'
-import type { BridgeDestinationObservation } from '@xyo-network/xl1-sdk'
-import {
-  BridgeDestinationObservationFieldsZod,
-  BridgeDestinationObservationSchema,
-} from '@xyo-network/xl1-sdk'
-import { z } from 'zod'
-
-import { getBridgeSettings } from '../../../../../config/index.ts'
-import { getRemoteChainIdZod } from '../pathParams/index.ts'
-
-export const makeBridgeFromRemoteStatusRoute = (config: BridgeConfig): RouteDefinition => {
-  const params = z.object({
-    chainId: getRemoteChainIdZod(config),
-    nonce: z.string().nonempty(),
-  })
-  const response = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(
-    BridgeDestinationObservationFieldsZod.shape,
-  )
-  const validateRequest = requestHandlerValidator({ params, response })
-
-  return {
-    method: 'get',
-    path: '/bridge/chains/:chainId/bridgeFromRemote/status/:nonce',
-    handlers: validateRequest(async (req, res) => {
-      const {
-        remoteChainId, remoteTokenAddress, xl1ChainId, xl1TokenAddress,
-      } = await getBridgeSettings(config)
-
-      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: xl1ChainId,
-        destAddress: toAddress('0xabc'),
-        destAmount: toHex('0x100'),
-        destToken: xl1TokenAddress,
-        src: remoteChainId,
-        srcAddress: toAddress('0x123'),
-        srcAmount: toHex('0x200'),
-        srcToken: remoteTokenAddress,
-        destConfirmation: toHex('0x9999'),
-      }
-      res.json(observation)
-    }),
-  }
-}

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

@@ -1,93 +0,0 @@
-import type { RouteDefinition } from '@xylabs/express'
-import { requestHandlerValidator } from '@xylabs/express'
-import { isDefined } from '@xylabs/sdk-js'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import {
-  PayloadBuilder, PayloadZodLooseOfSchema, PayloadZodStrictOfSchema,
-} from '@xyo-network/sdk-js'
-import type {
-  BridgeSourceObservation, BridgeSourceObservationFields, SignedHydratedTransaction,
-} from '@xyo-network/xl1-sdk'
-import {
-  BridgeIntentFieldsZod, BridgeIntentSchema, BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema, SignedTransactionBoundWitnessZod, TransferZod,
-} from '@xyo-network/xl1-sdk'
-import { z } from 'zod'
-
-import { createXl1ToEthBridgeJob, getXl1ToEthBridgeJob } from '../../../../../queue/index.ts'
-import {
-  validateBridgeEstimateExact, validateBridgeTransaction, validateSufficientXL1SourceAddressBalance,
-} from '../../../../../validation/index.ts'
-import { getRemoteChainIdZod } from '../pathParams/index.ts'
-
-export const BridgeToRemoteBodyZod = z.tuple([
-  SignedTransactionBoundWitnessZod,
-  PayloadZodLooseOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
-  TransferZod,
-])
-export type BridgeToRemoteBody = z.infer<typeof BridgeToRemoteBodyZod>
-
-export const BridgeToRemoteResponseZod = PayloadZodStrictOfSchema(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape)
-export type BridgeToRemoteResponse = z.infer<typeof BridgeToRemoteResponseZod>
-
-export const makeBridgeToRemoteRoute = (config: BridgeConfig): RouteDefinition => {
-  const params = z.object({ chainId: getRemoteChainIdZod(config) })
-
-  const validateRequest = requestHandlerValidator({
-    params, body: BridgeToRemoteBodyZod, response: BridgeToRemoteResponseZod,
-  })
-  return {
-    method: 'post',
-    path: '/bridge/chains/:chainId/bridgeToRemote',
-    handlers: validateRequest(async (req, res) => {
-      const [signedTxBw, bridgeIntent, transfer] = req.body
-      const { flowProducer } = req.app
-      const { gateway } = req.app.services
-
-      // Validate request
-      const transactionValid = await validateBridgeTransaction(signedTxBw, bridgeIntent, transfer, config)
-      if (!transactionValid) {
-        res.status(400).send()
-        return
-      }
-
-      // Validate estimate
-      const estimateValid = await validateBridgeEstimateExact(bridgeIntent, transfer, config)
-      if (!estimateValid) {
-        res.status(400).send()
-        return
-      }
-
-      // Validate sufficient balance
-      const sufficientBalance = await validateSufficientXL1SourceAddressBalance(bridgeIntent, gateway, config)
-      if (!sufficientBalance) {
-        res.status(400).send()
-        return
-      }
-
-      // Create the signed hydrated transaction for the job
-      const singedHydratedTransaction: SignedHydratedTransaction = [signedTxBw, [transfer]]
-
-      // Check if a job already exists for this transaction
-      const existingFlow = await getXl1ToEthBridgeJob(flowProducer, singedHydratedTransaction)
-      if (isDefined(existingFlow)) {
-        res.status(200).send()
-        return
-      }
-
-      // Submit to job queue
-      await createXl1ToEthBridgeJob(flowProducer, singedHydratedTransaction, [bridgeIntent])
-
-      // Create BridgeObservation
-      const srcConfirmation = await PayloadBuilder.hash(signedTxBw)
-      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()
-
-      // Return bridge observation to caller
-      res.status(202).json(bridgeObservation)
-    }),
-  }
-}

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

@@ -1,69 +0,0 @@
-import type { RouteDefinition } from '@xylabs/express'
-import { requestHandlerValidator } from '@xylabs/express'
-import {
-  assertEx, hexToBigInt, toAddress,
-} from '@xylabs/sdk-js'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import { PayloadZodStrictOfSchema } from '@xyo-network/sdk-js'
-import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
-import {
-  BridgeIntentFieldsZod, BridgeIntentSchema, buildUnsignedTransaction, toXL1BlockNumber, TransactionBoundWitnessZod, TransferZod,
-} from '@xyo-network/xl1-sdk'
-import { z } from 'zod'
-
-import { getBridgeSettings, getXl1ChainId } from '../../../../../config/index.ts'
-import { generateBridgeEstimate } from '../../../../../util/index.ts'
-import { getRemoteChainIdZod } from '../pathParams/index.ts'
-
-export const BridgeToRemoteEstimateBodyZod = BridgeIntentFieldsZod.pick({
-  destAddress: true,
-  srcAddress: true,
-  srcAmount: true,
-})
-export type BridgeToRemoteEstimateBody = z.infer<typeof BridgeToRemoteEstimateBodyZod>
-
-export const BridgeToRemoteEstimateResponseZod = z.tuple([
-  TransactionBoundWitnessZod,
-  PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
-  TransferZod,
-])
-
-export type BridgeToRemoteEstimateResponse = z.infer<typeof BridgeToRemoteEstimateResponseZod>
-
-export const makeBridgeToRemoteEstimateRoute = (config: BridgeConfig, gateway: XyoGatewayRunner): RouteDefinition => {
-  const params = z.object({ chainId: getRemoteChainIdZod(config) })
-  const validateRequest = requestHandlerValidator({
-    params, body: BridgeToRemoteEstimateBodyZod, response: BridgeToRemoteEstimateResponseZod,
-  })
-  return {
-    method: 'post',
-    path: '/bridge/chains/:chainId/bridgeToRemote/estimate',
-    handlers: validateRequest(async (req, res) => {
-      const xl1ChainId = getXl1ChainId(config)
-      const {
-        srcAddress, srcAmount, destAddress,
-      } = req.body
-
-      const { maxBridgeAmount } = await getBridgeSettings(config)
-      if (hexToBigInt(srcAmount) > hexToBigInt(maxBridgeAmount)) {
-        res.status(400).send()
-        return
-      }
-
-      const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config)
-      const sender = toAddress(srcAddress)
-
-      // Use viewer to get current block
-      const viewer = assertEx(gateway.connection.viewer, () => new Error('Viewer not available on gateway connection'))
-      const currentBlockNumber = await viewer.currentBlockNumber()
-      // Calculate nbf/exp
-      const nbf = toXL1BlockNumber(currentBlockNumber, true)
-      const exp = toXL1BlockNumber(currentBlockNumber + 1000, true)
-      // Build unsigned transaction representing the transfer that will be signed by srcAddress
-      const [txBw] = await buildUnsignedTransaction(xl1ChainId, [transfer], [bridgeIntent], nbf, exp, sender)
-
-      // Return the TX to the caller for signing
-      res.json([txBw, bridgeIntent, transfer])
-    }),
-  }
-}

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

@@ -1,64 +0,0 @@
-import type { RouteDefinition } from '@xylabs/express'
-import { requestHandlerValidator } from '@xylabs/express'
-import {
-  assertEx, hexToBigInt, toAddress, toHex,
-} from '@xylabs/sdk-js'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import { PayloadZodStrictOfSchema } from '@xyo-network/sdk-js'
-import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
-import {
-  BridgeIntentFieldsZod, BridgeIntentSchema, buildUnsignedTransaction, toXL1BlockNumber, TransactionBoundWitnessZod, TransferZod,
-} from '@xyo-network/xl1-sdk'
-import { z } from 'zod'
-
-import { getBridgeSettings } from '../../../../../config/index.ts'
-import { calculateMaxBridgeAmount, generateBridgeEstimate } from '../../../../../util/index.ts'
-import { getRemoteChainIdZod } from '../pathParams/index.ts'
-
-export const BridgeToRemoteMaxEstimateBodyZod = BridgeIntentFieldsZod.pick({
-  destAddress: true,
-  srcAddress: true,
-  srcAmount: true,
-})
-export type BridgeToRemoteMaxEstimateBody = z.infer<typeof BridgeToRemoteMaxEstimateBodyZod>
-
-export const BridgeToRemoteMaxEstimateResponseZod = z.tuple([
-  TransactionBoundWitnessZod,
-  PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
-  TransferZod,
-])
-
-export type BridgeToRemoteMaxEstimateResponse = z.infer<typeof BridgeToRemoteMaxEstimateResponseZod>
-
-export const makeBridgeToRemoteMaxEstimateRoute = (config: BridgeConfig, gateway: XyoGatewayRunner): RouteDefinition => {
-  const params = z.object({ chainId: getRemoteChainIdZod(config) })
-  const validateRequest = requestHandlerValidator({
-    params, body: BridgeToRemoteMaxEstimateBodyZod, response: BridgeToRemoteMaxEstimateResponseZod,
-  })
-  return {
-    method: 'post',
-    path: '/bridge/chains/:chainId/bridgeToRemote/maxEstimate',
-    handlers: validateRequest(async (req, res) => {
-      const {
-        feeFixed, feeRateBasisPoints, maxBridgeAmount: configMax, xl1ChainId,
-      } = await getBridgeSettings(config)
-      const {
-        srcAddress, srcAmount: balance, destAddress,
-      } = req.body
-
-      const balanceMax = calculateMaxBridgeAmount(balance, { feeFixed, feeRateBasisPoints })
-      const maxBridgeAmount = toHex(hexToBigInt(balanceMax) < hexToBigInt(configMax) ? balanceMax : configMax)
-
-      const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, maxBridgeAmount, destAddress, config)
-      const sender = toAddress(srcAddress)
-
-      const viewer = assertEx(gateway.connection.viewer, () => new Error('Viewer not available on gateway connection'))
-      const currentBlockNumber = await viewer.currentBlockNumber()
-      const nbf = toXL1BlockNumber(currentBlockNumber, true)
-      const exp = toXL1BlockNumber(currentBlockNumber + 1000, true)
-      const [txBw] = await buildUnsignedTransaction(xl1ChainId, [transfer], [bridgeIntent], nbf, exp, sender)
-
-      res.json([txBw, bridgeIntent, transfer])
-    }),
-  }
-}

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

@@ -1,98 +0,0 @@
-import type { RouteDefinition } from '@xylabs/express'
-import { requestHandlerValidator } from '@xylabs/express'
-import { asHex, isDefined } from '@xylabs/sdk-js'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import { PayloadBuilder, PayloadZodStrictOfSchema } from '@xyo-network/sdk-js'
-import type { BridgeDestinationObservation, BridgeSourceObservation } from '@xyo-network/xl1-sdk'
-import {
-  asBridgeIntent, BridgeDestinationObservationFieldsZod, BridgeDestinationObservationSchema, BridgeIntentFieldsZod, BridgeIntentSchema,
-  BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema, isBridgeIntent,
-} from '@xyo-network/xl1-sdk'
-import { z } from 'zod'
-
-import { getStatusQueueJobs, getXl1ToEthQueues } from '../../../../../queue/index.ts'
-import { getRemoteChainIdZod } from '../pathParams/index.ts'
-
-const BridgeIntentResponseZod = PayloadZodStrictOfSchema(BridgeIntentSchema)
-  .extend(BridgeIntentFieldsZod.shape)
-
-const BridgeSourceResponseZod = PayloadZodStrictOfSchema(BridgeSourceObservationSchema)
-  .extend(BridgeSourceObservationFieldsZod.shape)
-
-const BridgeDestinationResponseZod = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema)
-  .extend(BridgeDestinationObservationFieldsZod.shape)
-
-export const BridgeToRemoteStatusResponseZod = z.union([
-  z.tuple([]),
-  z.tuple([BridgeIntentResponseZod]),
-  z.tuple([BridgeIntentResponseZod, BridgeSourceResponseZod]),
-  z.tuple([BridgeIntentResponseZod, BridgeSourceResponseZod, BridgeDestinationResponseZod]),
-])
-export type BridgeToRemoteStatusResponse = z.infer<typeof BridgeToRemoteStatusResponseZod>
-
-export const makeBridgeToRemoteStatusRoute = (config: BridgeConfig): RouteDefinition => {
-  const params = z.object({
-    chainId: getRemoteChainIdZod(config),
-    nonce: z.string().nonempty(),
-  })
-
-  const validateRequest = requestHandlerValidator({ params, response: BridgeToRemoteStatusResponseZod })
-
-  return {
-    method: 'get',
-    path: '/bridge/chains/:chainId/bridgeToRemote/status/:nonce',
-    handlers: validateRequest(async (req, res) => {
-      const jobId = req.params.nonce
-      const result: z.infer<typeof BridgeToRemoteStatusResponseZod> = [] as z.infer<typeof BridgeToRemoteStatusResponseZod>
-      const queues = getXl1ToEthQueues(config)
-
-      const statusQueueJobs = await getStatusQueueJobs(queues, jobId)
-
-      // Check for the transaction hash in the parent job
-      const { tx, offChainPayloads = [] } = statusQueueJobs.xl1ToEthBridgeParentJob?.data ?? {}
-
-      // If the job does not exist return Not Found
-      if (!tx) return res.sendStatus(404)
-
-      // If the tx is not the right shape for bridging return Not Found
-      const allPayloads = [...tx[1], ...offChainPayloads]
-      const bridgeIntent = allPayloads.find(isBridgeIntent)
-      if (!bridgeIntent) return res.sendStatus(404)
-
-      // At this point we know we have a valid bridge intent, so we can start building the response
-      result[0] = asBridgeIntent(PayloadBuilder.omitMeta(bridgeIntent))
-
-      // Check the state of the XL1 monitor job to determine if we can include the source observation
-      const { xl1TransactionMonitorJob } = statusQueueJobs
-      const xl1MonitorState = xl1TransactionMonitorJob ? await xl1TransactionMonitorJob.getState() : undefined
-      if (xl1MonitorState === 'completed') {
-        const srcConfirmation = xl1TransactionMonitorJob?.returnvalue?.submissionHash
-        if (isDefined(srcConfirmation)) {
-          const schema = BridgeSourceObservationSchema
-          const bridgeSourceObservationFields = BridgeSourceObservationFieldsZod.parse(bridgeIntent)
-          const observation: BridgeSourceObservation = {
-            schema, ...bridgeSourceObservationFields, srcConfirmation,
-          }
-          result[1] = observation
-        }
-      }
-
-      // Check the state of the ETH monitor job to determine if we can include the destination observation
-      const { ethTransactionMonitorJob } = statusQueueJobs
-      const ethMonitorState = ethTransactionMonitorJob ? await ethTransactionMonitorJob.getState() : undefined
-      if (ethMonitorState === 'completed') {
-        const destConfirmation = asHex(ethTransactionMonitorJob?.returnvalue?.submissionHash)
-        if (isDefined(destConfirmation)) {
-          const schema = BridgeDestinationObservationSchema
-          const bridgeDestinationObservationFields = BridgeDestinationObservationFieldsZod.parse(bridgeIntent)
-          const observation: BridgeDestinationObservation = {
-            schema, ...bridgeDestinationObservationFields, destConfirmation,
-          }
-          result[2] = observation
-        }
-      }
-
-      res.json(result)
-    }),
-  }
-}

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

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

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

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

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

package/src/server/routes/index.ts

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

package/src/server/server.ts

@@ -1,21 +0,0 @@
-import type { BridgeConfigContext } from '@xyo-network/chain-orchestration'
-import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
-
-import { getServices } from '../services/index.ts'
-import { addWorkers } from './addWorkers.ts'
-import { getApp } from './app.ts'
-
-const hostname = '::'
-// const hostname = '0.0.0.0'
-
-export const getServer = async (context: BridgeConfigContext, gateway: XyoGatewayRunner) => {
-  const { logger, config } = context
-  const { port } = config
-  const app = getApp(config, gateway)
-  const services = await getServices(context, gateway)
-  app.services = services
-  addWorkers(config, services)
-  const server = app.listen(port, hostname, () => logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`))
-  server.setTimeout(20_000)
-  return server
-}

package/src/services/EthTxState.ts

@@ -1,5 +0,0 @@
-import type { TransactionRequest } from 'ethers'
-
-import type { TxState } from './TxState.ts'
-
-export interface EthTxState extends TxState<TransactionRequest> {}

package/src/services/IBridgeServiceCollection.ts

@@ -1,19 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type { AccountInstance } from '@xyo-network/sdk-js'
-import type { BridgeableToken, LiquidityPoolBridge } from '@xyo-network/typechain'
-import type { IterableMap, XyoGatewayRunner } from '@xyo-network/xl1-sdk'
-import type { Provider, Wallet } from 'ethers'
-
-import type { EthTxState } from './EthTxState.ts'
-import type { Xl1TxState } from './Xl1TxState.ts'
-
-export interface IBridgeServiceCollection {
-  account: AccountInstance
-  bridge: LiquidityPoolBridge
-  bridgeableToken: BridgeableToken
-  ethTxStateMap: IterableMap<Hash, EthTxState>
-  gateway: XyoGatewayRunner
-  provider: Provider
-  wallet: Wallet
-  xl1TxStateMap: IterableMap<Hash, Xl1TxState>
-}

package/src/services/TxState.ts

@@ -1,14 +0,0 @@
-export interface TxState<TTx, TTxHash extends string = string, TConfHash extends string = string> {
-  /**
-   * The confirmation hash of the transaction
-   */
-  confirmationHash?: TConfHash
-  /**
-   * The transaction that has been prepared for submission
-   */
-  preparedTx?: TTx
-  /**
-   * The hash of the submitted transaction
-   */
-  submissionHash?: TTxHash
-}

package/src/services/Xl1TxState.ts

@@ -1,9 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/sdk-js'
-import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
-
-import type { TxState } from './TxState.ts'
-
-export interface Xl1TxState extends TxState<SignedHydratedTransaction, Hash, Hash> {
-  offChainPayloads?: Payload[]
-}

package/src/services/getIterableMap.ts

@@ -1,34 +0,0 @@
-import { BaseMongoSdk, type BaseMongoSdkPrivateConfig } from '@xylabs/mongo'
-import { MongoMap } from '@xyo-network/chain-protocol'
-import type { BaseConfig, IterableMap } from '@xyo-network/xl1-sdk'
-import { hasMongoConfig, mapToMapType } from '@xyo-network/xl1-sdk'
-import type { Document } from 'mongodb'
-
-/**
- * Gets an iterable map based on the storage instructions in the config
- * @param config The config containing storage instructions
- * @param collection The collection to use if using MongoDB for persistence
- * @returns The iterable map
- */
-export const getIterableMap = async <K extends {} = string, V extends Document = Document>(
-  config: BaseConfig,
-  collection: string,
-): Promise<IterableMap<K, V>> => {
-  const mongoConfig = config.storage?.mongo
-  if (hasMongoConfig(mongoConfig)) {
-    const {
-      connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName,
-    } = mongoConfig
-    const payloadSdkConfig: BaseMongoSdkPrivateConfig = {
-      dbConnectionString, dbDomain, dbName, dbPassword, dbUserName,
-    }
-    const sdkBalanceSummaryMap = new BaseMongoSdk<V>({ ...payloadSdkConfig, collection })
-    const result = await MongoMap.create<MongoMap<K, V>>({
-      sdk: sdkBalanceSummaryMap,
-      getCache: { enabled: true, maxEntries: 5000 },
-    })
-    return result
-  } else {
-    return mapToMapType(new Map<K, V>())
-  }
-}