@xyo-network/chain-bridge 1.19.18 → 1.20.1

package/src/queue/workers/EthTransactionSubmissionStorage.ts

@@ -0,0 +1,76 @@
+import { assertEx, isDefined } from '@xylabs/sdk-js'
+import { PayloadBuilder } from '@xyo-network/sdk-js'
+import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
+import type { Job } from 'bullmq'
+import { Worker } from 'bullmq'
+import type { BullMQOtel } from 'bullmq-otel'
+import type { Redis } from 'ioredis'
+
+import type { EthTxState, IBridgeServiceCollection } from '../../services/index.ts'
+import { prefix } from '../prefix.ts'
+import type { EthTransactionSubmissionJobReturn } from './EthTransactionSubmission.ts'
+import { EthTransactionSubmission } from './EthTransactionSubmission.ts'
+import type { WorkerDescription } from './WorkerDescription.ts'
+
+export type EthTransactionSubmissionStorageJobData = { tx: SignedHydratedTransaction }
+export interface EthTransactionSubmissionStorageJobReturn {
+  submissionHash: Required<EthTxState>['submissionHash']
+}
+export type EthTransactionSubmissionStorageJob = Job<EthTransactionSubmissionStorageJobData, EthTransactionSubmissionStorageJobReturn>
+
+const name = 'Store ETH Transaction Submission'
+const queueName = 'eth-tx-store-submission'
+
+const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBridgeServiceCollection) => {
+  const stateMap = assertEx(services?.ethTxStateMap, () => 'ethTxStateMap service not provided')
+
+  const worker = new Worker(
+    queueName,
+    async (job: EthTransactionSubmissionStorageJob) => {
+      const { tx } = job.data
+      // Get the hash of the transaction
+      const hash = await PayloadBuilder.hash(tx[0])
+
+      // Get the state of the transaction
+      const state = assertEx(await stateMap.get(hash), () => `[${hash}] state not found`)
+
+      // Idempotency check against re-store
+      const { submissionHash: existingSubmissionHash } = state
+      if (isDefined(existingSubmissionHash)) {
+        await job.log(`[${hash}] submissionHash already stored as ${existingSubmissionHash}`)
+        return { submissionHash: existingSubmissionHash }
+      }
+
+      // In a Flow, this job should be the PARENT and the submit job should be a CHILD.
+      // That lets us read the child job’s return value(s) here.
+      const childrenValues = await job.getChildrenValues()
+      const jobKey = `${prefix}:${EthTransactionSubmission.queueName}:${hash}`
+      const childValues = childrenValues?.[jobKey] as EthTransactionSubmissionJobReturn | undefined
+      const submissionHash = childValues?.submissionHash
+
+      const resolvedSubmissionHash = assertEx(submissionHash, () => `[${hash}] child submissionHash not found in children values`)
+
+      // Store the submission hash in the state
+      await job.log(`[${hash}] Storing ETH submissionHash`)
+      state.submissionHash = resolvedSubmissionHash
+      await stateMap.set(hash, state)
+      await job.log(`[${hash}] Stored ETH submissionHash`)
+      return { submissionHash: resolvedSubmissionHash }
+    },
+    {
+      connection, telemetry, prefix,
+    },
+  )
+
+  worker.on('failed', (job, err) => {
+    console.error(`[${name}] Job ${job?.id} failed:`, err.message)
+  })
+
+  worker.on('error', (err) => {
+    console.error(`[${name}] Worker error:`, err)
+  })
+}
+
+export const EthTransactionSubmissionStorage: WorkerDescription = {
+  createWorker, name, queueName,
+}

package/src/queue/workers/Xl1ToEthBridgeParent.ts

@@ -1,25 +1,30 @@
+import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { Worker } from 'bullmq'
 import type { BullMQOtel } from 'bullmq-otel'
 import type { Redis } from 'ioredis'
 
+import { prefix } from '../prefix.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-export type Xl1ToEthBridgeParentJobData = {}
+export type Xl1ToEthBridgeParentJobData = { tx: SignedHydratedTransaction }
 export interface Xl1ToEthBridgeParentJobReturn { }
+export type Xl1ToEthBridgeParentJob = Job<Xl1ToEthBridgeParentJobData, Xl1ToEthBridgeParentJobReturn>
 
 const name = 'Bridge XL1 to Ethereum'
 const queueName = 'xl1-to-eth-bridge'
 const createWorker = (connection: Redis, telemetry?: BullMQOtel) => {
   const worker = new Worker(
     queueName,
-    async (job: Job<Xl1ToEthBridgeParentJobData, Xl1ToEthBridgeParentJobReturn>) => {
+    async (job: Xl1ToEthBridgeParentJob) => {
       await job.log(`[${job.name}] start`)
       // Parent job has no work other than waiting on children
       await job.log(`[${job.name}] done`)
       return {}
     },
-    { connection, telemetry },
+    {
+      connection, telemetry, prefix,
+    },
   )
 
   worker.on('failed', (job, err) => {

package/src/queue/workers/Xl1TransactionMonitor.ts

@@ -1,3 +1,4 @@
+import type { BrandedHash } from '@xylabs/sdk-js'
 import {
   assertEx, isDefined, isNull,
 } from '@xylabs/sdk-js'
@@ -9,42 +10,43 @@ import type { BullMQOtel } from 'bullmq-otel'
 import type { Redis } from 'ioredis'
 
 import type { IBridgeServiceCollection } from '../../services/index.ts'
+import { prefix } from '../prefix.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
 export type Xl1TransactionMonitorJobData = { tx: SignedHydratedTransaction }
-
 export interface Xl1TransactionMonitorJobReturn {
+  submissionHash: BrandedHash
 }
+export type Xl1TransactionMonitorJob = Job<Xl1TransactionMonitorJobData, Xl1TransactionMonitorJobReturn>
 
 const name = 'Monitor Submitted XL1 Transaction'
 const queueName = 'xl1-tx-monitor'
 const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBridgeServiceCollection) => {
   const gateway = assertEx(services?.gateway, () => 'gateway service not provided')
   const stateMap = assertEx(services?.xl1TxStateMap, () => 'xl1TxStateMap service not provided')
+  const viewer = assertEx(gateway.connection.viewer, () => 'viewer not defined on gateway')
 
   const worker = new Worker(
     queueName,
-    async (job: Job<Xl1TransactionMonitorJobData, Xl1TransactionMonitorJobReturn>) => {
+    async (job: Xl1TransactionMonitorJob) => {
       const { tx } = job.data
       // Get the hash of the transaction
       const hash = await PayloadBuilder.hash(tx[0])
       // Get the state of the transaction
-      const viewer = assertEx(gateway.connection.viewer, () => `[${hash}] viewer not defined on gateway`)
       const state = assertEx(await stateMap.get(hash), () => `[${hash}] state not found`)
-      const submissionHash = assertEx(state?.submissionHash, () => `[${hash}] submissionHash not found`)
+      const submissionHash = assertEx(state.submissionHash, () => `[${hash}] submissionHash not found`)
 
       // Check for transaction inclusion on chain
       await job.log(`[${hash}] Checking for XL1 transaction inclusion on chain`)
-      const foundTx = await viewer.transactionByHash(submissionHash)
+      const foundTx = await viewer.transaction.byHash(submissionHash)
       // const foundTx = await viewer.transaction.byHash(submissionHash)
 
       // Transaction found on chain
       if (isDefined(foundTx) && !isNull(foundTx)) {
         await job.log(`[${hash}] Found transaction on chain`)
         // Store the block hash
-        state.confirmationHash = await PayloadBuilder.hash(foundTx[0])
-        await stateMap.set(hash, state)
-        return {}
+        const submissionHash = await PayloadBuilder.hash(foundTx[0])
+        return { submissionHash }
       }
 
       // Check for transaction expiration
@@ -61,7 +63,9 @@ const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBri
       await job.log(`[${hash}] Transaction not yet included, retrying later`)
       throw new Error(`[${hash}] Transaction not yet included`)
     },
-    { connection, telemetry },
+    {
+      connection, telemetry, prefix,
+    },
   )
 
   worker.on('failed', (job, err) => {

package/src/queue/workers/Xl1TransactionPreparation.ts

@@ -7,10 +7,12 @@ import type { BullMQOtel } from 'bullmq-otel'
 import type { Redis } from 'ioredis'
 
 import type { IBridgeServiceCollection } from '../../services/index.ts'
+import { prefix } from '../prefix.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
 export type Xl1TransactionPreparationJobData = { tx: SignedHydratedTransaction }
 export interface Xl1TransactionPreparationJobReturn { preparedTx: SignedHydratedTransaction }
+export type Xl1TransactionPreparationJob = Job<Xl1TransactionPreparationJobData, Xl1TransactionPreparationJobReturn>
 
 const name = 'Prepare XL1 Transaction'
 const queueName = 'xl1-tx-prepare'
@@ -19,7 +21,7 @@ const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBri
 
   const worker = new Worker(
     queueName,
-    async (job: Job<Xl1TransactionPreparationJobData, Xl1TransactionPreparationJobReturn>) => {
+    async (job: Xl1TransactionPreparationJob) => {
       const { tx } = job.data
       const hash = await PayloadBuilder.hash(tx[0])
       await job.log(`[${hash}] preparing XL1 transaction`)
@@ -30,7 +32,9 @@ const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBri
       await job.log(`[${hash}] prepared XL1 transaction`)
       return { preparedTx }
     },
-    { connection, telemetry },
+    {
+      connection, telemetry, prefix,
+    },
   )
 
   worker.on('failed', (job, err) => {

package/src/queue/workers/Xl1TransactionSubmission.ts

@@ -7,24 +7,26 @@ import type { BullMQOtel } from 'bullmq-otel'
 import type { Redis } from 'ioredis'
 
 import type { IBridgeServiceCollection, Xl1TxState } from '../../services/index.ts'
+import { prefix } from '../prefix.ts'
 import { submitXl1Transaction } from './util/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
 export type Xl1TransactionSubmissionJobData = { tx: SignedHydratedTransaction }
-
 export interface Xl1TransactionSubmissionJobReturn {
   submissionHash: Required<Xl1TxState>['submissionHash']
 }
+export type Xl1TransactionSubmissionJob = Job<Xl1TransactionSubmissionJobData, Xl1TransactionSubmissionJobReturn>
 
 const name = 'Submit XL1 Transaction'
 const queueName = 'xl1-tx-submit'
+
 const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBridgeServiceCollection) => {
   const gateway = assertEx(services?.gateway, () => 'gateway service not provided')
   const stateMap = assertEx(services?.xl1TxStateMap, () => 'xl1TxStateMap service not provided')
 
   const worker = new Worker(
     queueName,
-    async (job: Job<Xl1TransactionSubmissionJobData, Xl1TransactionSubmissionJobReturn>) => {
+    async (job: Xl1TransactionSubmissionJob) => {
       const { tx } = job.data
       // Get the hash of the transaction
       const hash = await PayloadBuilder.hash(tx[0])
@@ -47,15 +49,12 @@ const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBri
       // assertEx(submissionHash === hash, () => `[${hash}] Submitted transaction hash ${submissionHash} does not match expected hash`)
       await job.log(`[${hash}] Submitted XL1 tx`)
 
-      // Store the submission hash in the state
-      await job.log(`[${hash}] Storing XL1 submissionHash`)
-      state.submissionHash = submissionHash
-      await stateMap.set(hash, state)
-      await job.log(`[${hash}] Stored XL1 submissionHash`)
-
+      // This worker intentionally does NOT store state as subsequent steps will do that.
       return { submissionHash }
     },
-    { connection, telemetry },
+    {
+      connection, telemetry, prefix,
+    },
   )
 
   worker.on('failed', (job, err) => {

package/src/queue/workers/Xl1TransactionSubmissionStorage.ts

@@ -0,0 +1,77 @@
+import { assertEx, isDefined } from '@xylabs/sdk-js'
+import { PayloadBuilder } from '@xyo-network/sdk-js'
+import { type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
+import type { Job } from 'bullmq'
+import { Worker } from 'bullmq'
+import type { BullMQOtel } from 'bullmq-otel'
+import type { Redis } from 'ioredis'
+
+import type { IBridgeServiceCollection, Xl1TxState } from '../../services/index.ts'
+import { prefix } from '../prefix.ts'
+import type { WorkerDescription } from './WorkerDescription.ts'
+import type { Xl1TransactionSubmissionJobReturn } from './Xl1TransactionSubmission.ts'
+import { Xl1TransactionSubmission } from './Xl1TransactionSubmission.ts'
+
+export type Xl1TransactionSubmissionStorageJobData = { tx: SignedHydratedTransaction }
+export interface Xl1TransactionSubmissionStorageJobReturn {
+  submissionHash: Required<Xl1TxState>['submissionHash']
+}
+export type Xl1TransactionSubmissionStorageJob = Job<Xl1TransactionSubmissionStorageJobData, Xl1TransactionSubmissionStorageJobReturn>
+
+const name = 'Store XL1 Transaction Submission'
+const queueName = 'xl1-tx-store-submission'
+
+const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBridgeServiceCollection) => {
+  const stateMap = assertEx(services?.xl1TxStateMap, () => 'xl1TxStateMap service not provided')
+
+  const worker = new Worker(
+    queueName,
+    async (job: Xl1TransactionSubmissionStorageJob) => {
+      const { tx } = job.data
+      // Get the hash of the transaction
+      const hash = await PayloadBuilder.hash(tx[0])
+
+      // Get the state of the transaction
+      const state = assertEx(await stateMap.get(hash), () => `[${hash}] state not found`)
+
+      // Idempotency check against re-store
+      const { submissionHash: existingSubmissionHash } = state
+      if (isDefined(existingSubmissionHash)) {
+        await job.log(`[${hash}] submissionHash already stored as ${existingSubmissionHash}`)
+        return { submissionHash: existingSubmissionHash }
+      }
+
+      // In a Flow, this job should be the PARENT and the submit job should be a CHILD.
+      // That lets us read the child job’s return value(s) here.
+      const childrenValues = await job.getChildrenValues()
+      const jobKey = `${prefix}:${Xl1TransactionSubmission.queueName}:${hash}`
+      const childValues = childrenValues?.[jobKey] as Xl1TransactionSubmissionJobReturn | undefined
+      const submissionHash = childValues?.submissionHash
+
+      const resolvedSubmissionHash = assertEx(submissionHash, () => `[${hash}] child submissionHash not found in children values`)
+
+      // Store the submission hash in the state
+      await job.log(`[${hash}] Storing XL1 submissionHash`)
+      state.submissionHash = resolvedSubmissionHash
+      await stateMap.set(hash, state)
+      await job.log(`[${hash}] Stored XL1 submissionHash`)
+
+      return { submissionHash: resolvedSubmissionHash }
+    },
+    {
+      connection, telemetry, prefix,
+    },
+  )
+
+  worker.on('failed', (job, err) => {
+    console.error(`[${name}] Job ${job?.id} failed:`, err.message)
+  })
+
+  worker.on('error', (err) => {
+    console.error(`[${name}] Worker error:`, err)
+  })
+}
+
+export const Xl1TransactionSubmissionStorage: WorkerDescription = {
+  createWorker, name, queueName,
+}

package/src/queue/workers/createWorkers.ts

@@ -6,18 +6,24 @@ import {
   EthTransactionMonitor,
   EthTransactionPreparation,
   EthTransactionSubmission,
+  EthTransactionSubmissionStorage,
   Xl1ToEthBridgeParent,
   Xl1TransactionMonitor,
   Xl1TransactionPreparation,
   Xl1TransactionSubmission,
+  Xl1TransactionSubmissionStorage,
 } from './index.ts'
 
 export const createWorkers = (connection: Redis, telemetry: BullMQOtel, services: IBridgeServiceCollection) => {
+  // TODO: Uncomment when EthToXl1 flow is ready
+  // EthToXl1BridgeParent.createWorker(connection, telemetry)
+  EthTransactionMonitor.createWorker(connection, telemetry, services)
+  EthTransactionPreparation.createWorker(connection, telemetry, services)
+  EthTransactionSubmission.createWorker(connection, telemetry, services)
+  EthTransactionSubmissionStorage.createWorker(connection, telemetry, services)
   Xl1ToEthBridgeParent.createWorker(connection, telemetry)
+  Xl1TransactionMonitor.createWorker(connection, telemetry, services)
   Xl1TransactionPreparation.createWorker(connection, telemetry, services)
   Xl1TransactionSubmission.createWorker(connection, telemetry, services)
-  Xl1TransactionMonitor.createWorker(connection, telemetry, services)
-  EthTransactionPreparation.createWorker(connection, telemetry, services)
-  EthTransactionSubmission.createWorker(connection, telemetry, services)
-  EthTransactionMonitor.createWorker(connection, telemetry, services)
+  Xl1TransactionSubmissionStorage.createWorker(connection, telemetry, services)
 }

package/src/queue/workers/index.ts

@@ -1,8 +1,11 @@
 export * from './createWorkers.ts'
+export * from './EthToXl1BridgeParent.ts'
 export * from './EthTransactionMonitor.ts'
 export * from './EthTransactionPreparation.ts'
 export * from './EthTransactionSubmission.ts'
+export * from './EthTransactionSubmissionStorage.ts'
 export * from './Xl1ToEthBridgeParent.ts'
 export * from './Xl1TransactionMonitor.ts'
 export * from './Xl1TransactionPreparation.ts'
 export * from './Xl1TransactionSubmission.ts'
+export * from './Xl1TransactionSubmissionStorage.ts'

package/src/queue/workers/util/index.ts

@@ -1,5 +1,2 @@
 export * from './submitEthTransaction.ts'
 export * from './submitXl1Transaction.ts'
-export * from './validateSufficientLiquiditySourceAllowance.ts'
-export * from './validateSufficientLiquiditySourceBalance.ts'
-export * from './validateSufficientRunnerEthBalanceForGas.ts'

package/src/server/index.ts

@@ -4,6 +4,8 @@ export * from './server.ts'
 // import type { NodeInstance } from '@xyo-network/sdk-js'
 import type { FlowProducer } from 'bullmq'
 
+import type { IBridgeServiceCollection } from '../services/index.ts'
+
 // import type { IBridgeServiceCollection } from '../services/index.ts'
 
 declare global {
@@ -11,8 +13,7 @@ declare global {
   namespace Express {
     interface Application {
       flowProducer: FlowProducer
-      // node: NodeInstance
-      // services: IBridgeServiceCollection
+      services: IBridgeServiceCollection
     }
   }
 }

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

@@ -13,7 +13,9 @@ import {
 import { z } from 'zod'
 
 import { createXl1ToEthBridgeJob } from '../../../../../queue/index.ts'
-import { validateBridgeEstimateExact, validateBridgeTransaction } from '../../../../../util/index.ts'
+import {
+  validateBridgeEstimateExact, validateBridgeTransaction, validateSufficientXL1SourceAddressBalance,
+} from '../../../../../validation/index.ts'
 import { getRemoteChainIdZod } from '../pathParams/index.ts'
 
 export const BridgeToRemoteBodyZod = z.tuple([
@@ -38,6 +40,7 @@ export const makeBridgeToRemoteRoute = (config: BridgeConfig): RouteDefinition =
     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)
@@ -53,6 +56,13 @@ export const makeBridgeToRemoteRoute = (config: BridgeConfig): RouteDefinition =
         return
       }
 
+      // Validate sufficient balance
+      const sufficientBalance = await validateSufficientXL1SourceAddressBalance(bridgeIntent, gateway, config)
+      if (!sufficientBalance) {
+        res.status(400).send()
+        return
+      }
+
       // Submit to job queue
       const singedHydratedTransaction: SignedHydratedTransaction = [signedTxBw, [transfer, bridgeIntent]]
       await createXl1ToEthBridgeJob(flowProducer, singedHydratedTransaction)

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

@@ -3,21 +3,14 @@ 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, SignedHydratedTransaction,
-} from '@xyo-network/xl1-sdk'
+import type { BridgeDestinationObservation, BridgeSourceObservation } from '@xyo-network/xl1-sdk'
 import {
   asBridgeIntent, BridgeDestinationObservationFieldsZod, BridgeDestinationObservationSchema, BridgeIntentFieldsZod, BridgeIntentSchema,
   BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema, isBridgeIntent,
 } from '@xyo-network/xl1-sdk'
-import type { Job } from 'bullmq'
-import { Queue } from 'bullmq'
 import { z } from 'zod'
 
-import {
-  EthTransactionMonitor, EthTransactionPreparation, EthTransactionSubmission, getConnection, Xl1ToEthBridgeParent, Xl1TransactionMonitor,
-  Xl1TransactionPreparation, Xl1TransactionSubmission,
-} from '../../../../../queue/index.ts'
+import { getStatusQueueJobs, getXl1ToEthQueues } from '../../../../../queue/index.ts'
 import { getRemoteChainIdZod } from '../pathParams/index.ts'
 
 const BridgeIntentResponseZod = PayloadZodStrictOfSchema(BridgeIntentSchema)
@@ -37,78 +30,6 @@ export const BridgeToRemoteStatusResponseZod = z.union([
 ])
 export type BridgeToRemoteStatusResponse = z.infer<typeof BridgeToRemoteStatusResponseZod>
 
-interface StatusQueues {
-  ethTransactionMonitor: Queue
-  ethTransactionPreparation: Queue
-  ethTransactionSubmission: Queue
-  xl1ToEthBridgeParent: Queue
-  xl1TransactionMonitor: Queue
-  xl1TransactionPreparation: Queue
-  xl1TransactionSubmission: Queue
-}
-
-let statusQueues: StatusQueues | undefined
-
-const getStatusQueues = (config: BridgeConfig): StatusQueues => {
-  if (statusQueues) return statusQueues
-  const connection = getConnection(config)
-  statusQueues = {
-    ethTransactionMonitor: new Queue(EthTransactionMonitor.queueName, { connection }),
-    ethTransactionPreparation: new Queue(EthTransactionPreparation.queueName, { connection }),
-    ethTransactionSubmission: new Queue(EthTransactionSubmission.queueName, { connection }),
-    xl1ToEthBridgeParent: new Queue(Xl1ToEthBridgeParent.queueName, { connection }),
-    xl1TransactionMonitor: new Queue(Xl1TransactionMonitor.queueName, { connection }),
-    xl1TransactionPreparation: new Queue(Xl1TransactionPreparation.queueName, { connection }),
-    xl1TransactionSubmission: new Queue(Xl1TransactionSubmission.queueName, { connection }),
-  }
-  return statusQueues
-}
-
-interface StatusQueueJobs {
-  ethTransactionMonitorJob?: Job
-  ethTransactionPreparationJob?: Job
-  ethTransactionSubmissionJob?: Job
-  xl1ToEthBridgeParentJob?: Job
-  xl1TransactionMonitorJob?: Job
-  xl1TransactionPreparationJob?: Job
-  xl1TransactionSubmissionJob?: Job
-}
-
-/**
- * Checks all the relevant status queues for a job with the given id and returns the jobs found in an object
- * @param queues The status queues to check for jobs
- * @param jobId The job id to look for in the queues, which is the same as the tx hash of the bridge transaction
- * @returns An object containing the jobs found in the status queues corresponding to the given job id
- */
-const getStatusQueueJobs = async (queues: StatusQueues, jobId: string): Promise<StatusQueueJobs> => {
-  const [
-    ethTransactionMonitorJob,
-    ethTransactionPreparationJob,
-    ethTransactionSubmissionJob,
-    xl1ToEthBridgeParentJob,
-    xl1TransactionMonitorJob,
-    xl1TransactionPreparationJob,
-    xl1TransactionSubmissionJob,
-  ] = await Promise.all([
-    queues.ethTransactionMonitor.getJob(jobId),
-    queues.ethTransactionPreparation.getJob(jobId),
-    queues.ethTransactionSubmission.getJob(jobId),
-    queues.xl1ToEthBridgeParent.getJob(jobId),
-    queues.xl1TransactionMonitor.getJob(jobId),
-    queues.xl1TransactionPreparation.getJob(jobId),
-    queues.xl1TransactionSubmission.getJob(jobId),
-  ])
-  return {
-    ethTransactionMonitorJob,
-    ethTransactionPreparationJob,
-    ethTransactionSubmissionJob,
-    xl1ToEthBridgeParentJob,
-    xl1TransactionMonitorJob,
-    xl1TransactionPreparationJob,
-    xl1TransactionSubmissionJob,
-  }
-}
-
 export const makeBridgeToRemoteStatusRoute = (config: BridgeConfig): RouteDefinition => {
   const params = z.object({
     chainId: getRemoteChainIdZod(config),
@@ -122,18 +43,18 @@ export const makeBridgeToRemoteStatusRoute = (config: BridgeConfig): RouteDefini
     path: '/bridge/chains/:chainId/bridgeToRemote/status/:nonce',
     handlers: validateRequest(async (req, res) => {
       const jobId = req.params.nonce
-      const result: z.infer<typeof BridgeToRemoteStatusResponseZod> = [] as unknown as z.infer<typeof BridgeToRemoteStatusResponseZod>
-      const queues = getStatusQueues(config)
+      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 any of the queues
-      const tx = Object.values(statusQueueJobs).map(job => job?.data?.tx as SignedHydratedTransaction | undefined).find(tx => isDefined(tx))
+      // Check for the transaction hash in the parent job
+      const tx = statusQueueJobs.xl1ToEthBridgeParentJob?.data?.tx
 
-      // If the transaction does not exist in any of them return Not Found
+      // If the job does not exist return Not Found
       if (!tx) return res.sendStatus(404)
 
-      // If the transaction is not the right shape return Not Found
+      // If the tx is not the right shape for bridging return Not Found
       const bridgeIntent = tx[1].find(isBridgeIntent)
       if (!bridgeIntent) return res.sendStatus(404)
 
@@ -143,26 +64,31 @@ export const makeBridgeToRemoteStatusRoute = (config: BridgeConfig): RouteDefini
       // 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
-      const srcConfirmation = asHex(jobId)
-      if (xl1MonitorState === 'completed' && isDefined(srcConfirmation)) {
-        const bridgeCommonFieldsZod = z.object({}).extend(BridgeSourceObservationFieldsZod.shape)
-        const bridgeCommonFields = bridgeCommonFieldsZod.parse(bridgeIntent)
-        const observation: BridgeSourceObservation = {
-          schema: BridgeSourceObservationSchema, ...bridgeCommonFields, srcConfirmation,
+      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
         }
-        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
-      const submissionHash = (ethTransactionMonitorJob?.returnvalue as { submissionHash?: string } | undefined)?.submissionHash
-      const destConfirmation = asHex(submissionHash)
-      if (ethMonitorState === 'completed' && isDefined(submissionHash)) {
-        const bridgeDestinationFieldsZod = z.object({}).extend(BridgeDestinationObservationFieldsZod.shape)
-        const bridgeDestinationFields = bridgeDestinationFieldsZod.parse({ ...bridgeIntent, destConfirmation })
-        const observation: BridgeDestinationObservation = { schema: BridgeDestinationObservationSchema, ...bridgeDestinationFields }
-        result[2] = observation
+      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/server.ts

@@ -13,6 +13,7 @@ export const getServer = async (context: BridgeConfigContext, gateway: XyoGatewa
   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)

package/src/services/IBridgeServiceCollection.ts

@@ -1,5 +1,5 @@
 import type { Hash } from '@xylabs/sdk-js'
-import type { AccountInstance } from '@xyo-network/account-model'
+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'

package/src/services/TxState.ts

@@ -1,5 +1,3 @@
-import { isDefined } from '@xylabs/sdk-js'
-
 export interface TxState<TTx, TTxHash extends string = string, TConfHash extends string = string> {
   /**
    * The confirmation hash of the transaction
@@ -14,19 +12,3 @@ export interface TxState<TTx, TTxHash extends string = string, TConfHash extends
    */
   submissionHash?: TTxHash
 }
-
-export type TxCompletionStates = 'pendingSubmission' | 'submitted' | 'confirmed' | 'failed'
-
-/**
- * Determines the transaction state based on the TxState object
- * @param state The transaction state
- * @returns The state of the transaction
- */
-export const getTransactionCompletionState = <T>(state: TxState<T>): TxCompletionStates => {
-  // Prepared, submitted, and confirmed
-  if (isDefined(state.preparedTx) && isDefined(state.submissionHash) && isDefined(state.confirmationHash)) return 'confirmed'
-  // Prepared and submitted
-  if (isDefined(state.preparedTx) && isDefined(state.submissionHash)) return 'submitted'
-  // Prepared
-  return 'pendingSubmission'
-}