@xyo-network/chain-bridge 1.17.2 → 1.17.3

package/src/modules/XL1TransactionCompletionMonitorSentinel/XL1TransactionCompletionMonitorSentinel.ts

@@ -0,0 +1,166 @@
+import type { Attributes, Counter } from '@opentelemetry/api'
+import type { Hash } from '@xylabs/sdk-js'
+import {
+  assertEx, delay, isDefined, isNull, isUndefined,
+} from '@xylabs/sdk-js'
+import type { AnyConfigSchema } from '@xyo-network/module-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload } from '@xyo-network/payload-model'
+import { AbstractSentinel } from '@xyo-network/sentinel-abstract'
+import type {
+  SentinelConfig, SentinelInstance, SentinelModuleEventData, SentinelParams,
+} from '@xyo-network/sentinel-model'
+import type { SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
+import type {
+  IterableMap, MapType, XyoViewer,
+} from '@xyo-network/xl1-protocol-sdk'
+import {
+  flattenHydratedTransaction, flattenHydratedTransactions, tryUnflattenHydratedTransaction,
+} from '@xyo-network/xl1-protocol-sdk'
+import { Mutex } from 'async-mutex'
+
+export const XL1TransactionCompletionMonitorSentinelConfigSchema = 'network.xyo.sentinel.chain.transaction.completion.monitor.config'
+export type XL1TransactionCompletionMonitorSentinelConfigSchema = typeof XL1TransactionCompletionMonitorSentinelConfigSchema
+
+/**
+ * The configuration for the sentinel
+ */
+export type XL1TransactionCompletionMonitorSentinelConfig = SentinelConfig<{
+  /**
+   * The interval in milliseconds between checking for jobs to fulfill
+   */
+  jobCheckInterval: number
+
+  /**
+   * The schema for the sentinel config
+   */
+  schema: XL1TransactionCompletionMonitorSentinelConfigSchema
+}>
+
+interface XL1TransactionCompletionMonitorSentinelParamFields {
+  /**
+   * The map of completed transactions to monitor for completion
+   */
+  completedTransactions: MapType<Hash, SignedHydratedTransaction>
+
+  /**
+   * The map of pending transactions to monitor for completion
+   */
+  pendingTransactions: IterableMap<Hash, SignedHydratedTransaction>
+
+  /**
+   * The viewer instance to use for viewing transactions
+   */
+  viewer: XyoViewer
+}
+
+export type XL1TransactionCompletionMonitorSentinelParams<
+  TConfig extends AnyConfigSchema<XL1TransactionCompletionMonitorSentinelConfig> = AnyConfigSchema<XL1TransactionCompletionMonitorSentinelConfig>,
+> = SentinelParams<TConfig> & XL1TransactionCompletionMonitorSentinelParamFields
+
+const defaultJobCheckIntervalMs = 15_000
+
+export class XL1TransactionCompletionMonitorSentinel<
+  TParams extends XL1TransactionCompletionMonitorSentinelParams = XL1TransactionCompletionMonitorSentinelParams,
+  TEventData extends SentinelModuleEventData<SentinelInstance<TParams>> = SentinelModuleEventData<SentinelInstance<TParams>>,
+> extends AbstractSentinel<TParams, TEventData> {
+  static override readonly configSchemas = [XL1TransactionCompletionMonitorSentinelConfigSchema]
+  static override readonly defaultConfigSchema = XL1TransactionCompletionMonitorSentinelConfigSchema
+  private _attemptsCounter: Counter<Attributes> | undefined
+  private _checkCounter: Counter<Attributes> | undefined
+  private _errorCounter: Counter<Attributes> | undefined
+  private _reportMutex = new Mutex()
+  private _successCounter: Counter<Attributes> | undefined
+
+  protected get completedTransactions(): MapType<Hash, SignedHydratedTransaction> {
+    return assertEx(this.params.completedTransactions, () => 'Completed transactions map is not defined')
+  }
+
+  protected get jobCheckInterval(): number {
+    return isDefined(this.config.jobCheckInterval) ? this.config.jobCheckInterval : defaultJobCheckIntervalMs
+  }
+
+  protected get pendingTransactions(): IterableMap<Hash, SignedHydratedTransaction> {
+    return assertEx(this.params.pendingTransactions, () => 'Pending transactions map is not defined')
+  }
+
+  protected get viewer(): XyoViewer {
+    return assertEx(this.params.viewer, () => 'Viewer is not defined in params')
+  }
+
+  override async createHandler(): Promise<void> {
+    await super.createHandler()
+    // Create meters for tracking bridge attempts, successes, and errors.
+    this._attemptsCounter = this.meter?.createCounter('xl1_transaction_completion_monitor_sentinel_attempts_total', { description: 'Number of attempts' })
+    this._checkCounter = this.meter?.createCounter('xl1_transaction_completion_monitor_sentinel_check_total', { description: 'Number of checks' })
+    this._successCounter = this.meter?.createCounter('xl1_transaction_completion_monitor_sentinel_success_total', { description: 'Number of successes' })
+    this._errorCounter = this.meter?.createCounter('xl1_transaction_completion_monitor_sentinel_errors_total', { description: 'Number of errors' })
+  }
+
+  override async reportHandler(payloads?: Payload[]): Promise<Payload[]> {
+    if (isDefined(payloads) && payloads.length > 0) {
+      const signedHydratedTransaction = tryUnflattenHydratedTransaction(payloads)
+      if (isDefined(signedHydratedTransaction)) {
+        // Insert into pending transactions for monitoring
+        const txHash = await PayloadBuilder.hash(signedHydratedTransaction[0])
+        this.logger?.info(`Adding transaction ${signedHydratedTransaction[0]} with hash ${txHash} to pending transactions for monitoring`)
+        await this.pendingTransactions.set(txHash, signedHydratedTransaction)
+        return flattenHydratedTransaction(signedHydratedTransaction)
+      }
+      return []
+    } else {
+      if (this._reportMutex.isLocked()) {
+        this.logger?.debug(`XL1TransactionCompletionMonitorSentinel [${this.id}] is already running, skipping report [${Date.now()}]`)
+        return []
+      }
+      return await this._reportMutex.runExclusive(async () => {
+        const response: Payload[] = []
+        if (isUndefined(payloads) || payloads.length === 0) {
+          await this.processAllTransactions()
+        }
+        return response
+      })
+    }
+  }
+
+  private async processAllTransactions(): Promise<Payload[]> {
+    const results: SignedHydratedTransaction[] = []
+    for await (const [hash, signedHydratedTransaction] of this.pendingTransactions) {
+      const result = await this.processTransaction([hash, signedHydratedTransaction])
+      if (isDefined(result)) results.push(result[1])
+      await delay(this.jobCheckInterval)
+    }
+    return flattenHydratedTransactions(results)
+  }
+
+  private async processTransaction(
+    [hash, signedHydratedTransaction]: [Hash, SignedHydratedTransaction],
+  ): Promise<[Hash, SignedHydratedTransaction] | undefined> {
+    this.logger?.info(`Checking for transaction ${signedHydratedTransaction[0]} with hash ${hash}`)
+    try {
+      let ret: [Hash, SignedHydratedTransaction] | undefined = undefined
+      this._checkCounter?.add(1)
+      this._attemptsCounter?.add(1)
+      // Check if the transaction is already included in the chain
+      const tx = await this.viewer.transactionByHash(hash)
+      if (isDefined(tx) && !isNull(tx)) {
+        await this.completedTransactions.set(hash, signedHydratedTransaction)
+        this.logger?.info(`Found transaction ${signedHydratedTransaction[0]} with hash ${hash}`)
+        this.logger?.info(`Removing completed transaction ${signedHydratedTransaction[0]} with hash ${hash}`)
+        await this.pendingTransactions.delete(hash)
+        ret = [hash, signedHydratedTransaction]
+      } else {
+        const currentBlockNumber = await this.viewer.currentBlockNumber()
+        if (signedHydratedTransaction[0].exp < currentBlockNumber) {
+          this.logger?.info(`Removing expired transaction ${signedHydratedTransaction[0]} with hash ${hash}`)
+          await this.pendingTransactions.delete(hash)
+        }
+      }
+      this._successCounter?.add(1)
+      return ret
+    } catch (error) {
+      this._errorCounter?.add(1)
+      this.logger?.error(`Error checking for transaction ${signedHydratedTransaction[0]} with hash ${hash}:`, error)
+    }
+  }
+}

package/src/modules/XL1TransactionCompletionMonitorSentinel/index.ts

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

package/src/modules/index.ts

@@ -1 +1,2 @@
-export * from './XL1toEvmBridgeSentinel/index.ts'
+export * from './EVMLiquidityBridgeTransactionCompletionMonitorSentinel/index.ts'
+export * from './XL1TransactionCompletionMonitorSentinel/index.ts'

package/src/server/app.ts

@@ -2,6 +2,8 @@ import {
   customPoweredByHeader, disableCaseSensitiveRouting, disableExpressDefaultPoweredByHeader, getJsonBodyParser, getJsonBodyParserOptions, responseProfiler,
   standardErrors, standardResponses,
 } from '@xylabs/express'
+import type { NodeInstance } from '@xyo-network/node-model'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
 import compression from 'compression'
 import cors from 'cors'
 import type { Express } from 'express'
@@ -10,8 +12,7 @@ import express from 'express'
 import { addInstrumentation } from './instrumentation.ts'
 import { addRoutes } from './routes/index.ts'
 
-// export const getApp = (node: NodeInstance): Express => {
-export const getApp = (): Express => {
+export const getApp = (node: NodeInstance, config: Config): Express => {
   addInstrumentation()
   const app = express()
   app.set('etag', false)
@@ -23,8 +24,8 @@ export const getApp = (): Express => {
   disableExpressDefaultPoweredByHeader(app)
   app.use(customPoweredByHeader)
   disableCaseSensitiveRouting(app)
-  // app.node = node
-  addRoutes(app)
+  app.node = node
+  addRoutes(app, config)
   app.use(standardErrors)
   return app
 }

package/src/server/routes/addRoutes.ts

@@ -1,7 +1,8 @@
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
 import type { Express } from 'express'
 
 import { addBridgeRoutes } from './bridge/index.ts'
 
-export const addRoutes = (app: Express) => {
-  addBridgeRoutes(app)
+export const addRoutes = (app: Express, config: Config) => {
+  addBridgeRoutes(app, config)
 }

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

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

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

@@ -1,14 +1,16 @@
 import type { RouteDefinition } from '@xylabs/express'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
 
 import {
-  bridgeFromRemoteStatus, bridgeToRemote, bridgeToRemoteEstimate, bridgeToRemoteStatus,
+  makeBridgeConfigRoute, makeBridgeFromRemoteStatusRoute, makeBridgeToRemoteEstimateRoute, makeBridgeToRemoteRoute, makeBridgeToRemoteStatusRoute,
 } from './routes/index.ts'
 
-export const getRouteDefinitions = (): RouteDefinition[] => {
+export const getRouteDefinitions = (config: Config): RouteDefinition[] => {
   return [
-    bridgeFromRemoteStatus,
-    bridgeToRemote,
-    bridgeToRemoteEstimate,
-    bridgeToRemoteStatus,
+    makeBridgeConfigRoute(config),
+    makeBridgeToRemoteEstimateRoute(config),
+    makeBridgeToRemoteRoute(config),
+    makeBridgeToRemoteStatusRoute(config),
+    makeBridgeFromRemoteStatusRoute(config),
   ]
 }

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

@@ -1,18 +1,21 @@
 import {
-  hexFromHexString, HexZod, isAddress, isUndefined,
-  toAddress,
+  asHex, HexZod, isUndefined,
 } from '@xylabs/sdk-js'
 import type { ChainId } from '@xyo-network/xl1-protocol'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
 
-const remoteChainId: ChainId = toAddress('0x01')
+import { getRemoteChainId } from '../../../../../config/index.ts'
 
-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` },
-)
+export const getRemoteChainIdZod = (config: Config) => {
+  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/routes/bridgeConfig.ts

@@ -0,0 +1,43 @@
+import type { RouteDefinition } from '@xylabs/express'
+import { requestHandlerValidator } from '@xylabs/express'
+import { BridgeSettingsZod, type Config } from '@xyo-network/xl1-protocol-sdk'
+
+import { getBridgeSettings } from '../../../../../config/index.ts'
+
+const response = BridgeSettingsZod
+
+const validateRequest = requestHandlerValidator({ response })
+
+export const makeBridgeConfigRoute = (config: Config): 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

@@ -7,49 +7,52 @@ import {
   BridgeDestinationObservationFieldsZod,
   BridgeDestinationObservationSchema,
 } from '@xyo-network/xl1-protocol'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
 import { z } from 'zod'
 
-import { ChainIdPathParam } from '../pathParams/index.ts'
+import { getBridgeSettings } from '../../../../../config/index.ts'
+import { getRemoteChainIdZod } from '../pathParams/index.ts'
 
-const params = z.object({
-  chainId: ChainIdPathParam,
-  nonce: z.string(),
-})
-const response = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(
-  BridgeDestinationObservationFieldsZod.shape,
-)
+export const makeBridgeFromRemoteStatusRoute = (config: Config): RouteDefinition => {
+  const params = z.object({
+    chainId: getRemoteChainIdZod(config),
+    nonce: z.string().nonempty(),
+  })
+  const response = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(
+    BridgeDestinationObservationFieldsZod.shape,
+  )
+  const validateRequest = requestHandlerValidator({ params, response })
 
-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)
 
-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())
+      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)
+      // 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 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)
-  }),
+      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,53 +1,82 @@
 import type { RouteDefinition } from '@xylabs/express'
 import { requestHandlerValidator } from '@xylabs/express'
-import { asHash } from '@xylabs/sdk-js'
+import { asAddress, assertEx } from '@xylabs/sdk-js'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
-import { PayloadZodLooseOfSchema, PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
-import type { BridgeSourceObservation, BridgeSourceObservationFields } from '@xyo-network/xl1-protocol'
+import { PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
+import { asSentinelInstance } from '@xyo-network/sentinel-model'
+import type {
+  BridgeSourceObservation, BridgeSourceObservationFields, SignedHydratedTransaction,
+} from '@xyo-network/xl1-protocol'
 import {
-  BridgeIntentFieldsZod,
-  BridgeIntentSchema,
-  BridgeSourceObservationFieldsZod,
-  BridgeSourceObservationSchema,
-  TransferSchema,
+  BridgeIntentFieldsZod, BridgeIntentSchema, BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema, SignedTransactionBoundWitnessZod,
+  TransferZod,
 } from '@xyo-network/xl1-protocol'
+import { type Config, flattenHydratedTransaction } from '@xyo-network/xl1-protocol-sdk'
 import { z } from 'zod'
 
-import { ChainIdPathParam } from '../pathParams/index.ts'
-
-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] = 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)
-  }),
+import { validateBridgeEstimateExact } from '../../../../../util/index.ts'
+import { getRemoteChainIdZod } from '../pathParams/index.ts'
+
+export const makeBridgeToRemoteRoute = (config: Config): RouteDefinition => {
+  const params = z.object({ chainId: getRemoteChainIdZod(config) })
+  const body = z.tuple([
+    SignedTransactionBoundWitnessZod,
+    PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
+    TransferZod,
+  ])
+  const response = PayloadZodStrictOfSchema(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape)
+
+  const validateRequest = requestHandlerValidator({
+    params, body, response,
+  })
+  return {
+    method: 'post',
+    path: '/bridge/chains/:chainId/bridgeToRemote',
+    handlers: validateRequest(async (req, res) => {
+      const [signedTxBw, bridgeIntent, transfer] = req.body
+      const { srcAddress } = bridgeIntent
+      const { node } = req.app
+
+      // TODO: Validate TX is valid BW
+      // BoundWitnessBuilder.validate(signedTxBw)
+
+      // Validate TX has address from srcAddress
+      // const sender = asAddress(srcAddress, true)
+      // const srcAddressValid = signedTxBw.addresses.includes(sender)
+      // if (!srcAddressValid) {
+      //   res.status(400).send()
+      //   return
+      // }
+
+      // Validate estimate
+      const estimateValid = await validateBridgeEstimateExact(bridgeIntent, transfer, config)
+      if (!estimateValid) {
+        res.status(400).send()
+        return
+      }
+
+      // Submit to sentinel
+      const mod = await node.resolve('XL1BridgeIntentTransactionCompletionMonitorSentinel')
+      const sentinel = assertEx(asSentinelInstance(mod), () => 'Error resolving XL1BridgeIntentTransactionCompletionMonitorSentinel')
+      const singedHydratedTransaction: SignedHydratedTransaction = [signedTxBw, [transfer, bridgeIntent]]
+      const observation = await sentinel.report(flattenHydratedTransaction(singedHydratedTransaction))
+      if (observation.length === 0) {
+        console.error('Error submitting bridge intent transaction to sentinel')
+        res.status(500).send()
+        return
+      }
+      const srcConfirmation = await PayloadBuilder.hash(signedTxBw)
+
+      // Create BridgeObservation
+      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.json(bridgeObservation)
+    }),
+  }
 }