@xyo-network/chain-bridge 1.19.17 → 1.20.0

package/src/queue/workers/EthTransactionPreparation.ts

@@ -3,38 +3,43 @@ import { PayloadBuilder } from '@xyo-network/sdk-js'
 import { isBridgeIntent, type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { Worker } from 'bullmq'
+import type { BullMQOtel } from 'bullmq-otel'
 import { getAddress } from 'ethers'
 import type { Redis } from 'ioredis'
 
 import type { IBridgeServiceCollection } from '../../services/index.ts'
-import { validateSufficientAllowance, validateSufficientBalance } from './util/index.ts'
+import {
+  validateSufficientLiquiditySourceAllowance, validateSufficientLiquiditySourceBalance, validateSufficientRunnerEthBalanceForGas,
+} from '../../validation/index.ts'
+import { prefix } from '../prefix.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = { tx: SignedHydratedTransaction }
-
-interface ReturnType {}
+export type EthTransactionPreparationJobData = { tx: SignedHydratedTransaction }
+export type EthTransactionPreparationJobReturn = Record<string, never>
+export type EthTransactionPreparationJob = Job<EthTransactionPreparationJobData, EthTransactionPreparationJobReturn>
 
 const name = 'Prepare ETH Transaction'
 const queueName = 'eth-tx-prepare'
 
-export const createWorker = (connection: Redis, services?: IBridgeServiceCollection) => {
+export const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBridgeServiceCollection) => {
   const bridge = assertEx(services?.bridge, () => 'bridge service not provided')
   const bridgeableToken = assertEx(services?.bridgeableToken, () => 'bridgeableToken service not provided')
   const stateMap = assertEx(services?.ethTxStateMap, () => 'ethTxStateMap service not provided')
+  const wallet = assertEx(services?.wallet, () => 'wallet service not provided')
 
   const worker = new Worker(
     queueName,
-    async (job: Job<JobData, ReturnType>) => {
+    async (job: EthTransactionPreparationJob) => {
       const { tx } = job.data
       const hash = await PayloadBuilder.hash(tx[0])
       await job.log(`[${hash}] preparing ETH transaction`)
       await job.log(`[${hash}] validating liquiditySource has sufficient allowance`)
-      if (!await validateSufficientAllowance(tx, bridgeableToken, bridge, job)) {
+      if (!await validateSufficientLiquiditySourceAllowance(tx, bridgeableToken, bridge, job)) {
         throw new Error('Liquidity source does not have sufficient allowance for the bridge to execute the transaction')
       }
       await job.log(`[${hash}] validated liquiditySource has sufficient allowance`)
       await job.log(`[${hash}] validating liquiditySource has sufficient balance`)
-      if (!await validateSufficientBalance(tx, bridgeableToken, bridge, job)) {
+      if (!await validateSufficientLiquiditySourceBalance(tx, bridgeableToken, bridge, job)) {
         throw new Error('Liquidity source does not have sufficient balance for the bridge to execute the transaction')
       }
       await job.log(`[${hash}] validated liquiditySource has sufficient balance`)
@@ -46,13 +51,20 @@ export const createWorker = (connection: Redis, services?: IBridgeServiceCollect
       const nonce = hexToBigInt(await PayloadBuilder.hash(tx[0]))
       const preparedTx = await bridge.getFunction('bridgeFromRemote').populateTransaction(srcAddress, destAddress, amount, nonce)
       await job.log(`[${hash}] built ETH transaction`)
+      await job.log(`[${hash}] validating tx runner has sufficient ETH for gas`)
+      if (!await validateSufficientRunnerEthBalanceForGas(preparedTx, wallet, job)) {
+        throw new Error('Transaction runner does not have sufficient ETH to cover estimated gas (with buffer)')
+      }
+      await job.log(`[${hash}] validated tx runner has sufficient ETH for gas`)
       await job.log(`[${hash}] storing ETH preparedTx`)
       await stateMap.set(hash, { preparedTx })
       await job.log(`[${hash}] stored ETH preparedTx`)
       await job.log(`[${hash}] prepared ETH transaction`)
       return {}
     },
-    { connection },
+    {
+      connection, telemetry, prefix,
+    },
   )
 
   worker.on('failed', (job, err) => {

package/src/queue/workers/EthTransactionSubmission.ts

@@ -3,21 +3,23 @@ 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 { submitEthTransaction } from './util/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = { tx: SignedHydratedTransaction }
-
-interface ReturnType {
+export type EthTransactionSubmissionJobData = { tx: SignedHydratedTransaction }
+export interface EthTransactionSubmissionJobReturn {
   submissionHash: Required<EthTxState>['submissionHash']
 }
+export type EthTransactionSubmissionJob = Job<EthTransactionSubmissionJobData, EthTransactionSubmissionJobReturn>
 
 const name = 'Submit ETH Transaction'
 const queueName = 'eth-tx-submit'
-const createWorker = (connection: Redis, services?: IBridgeServiceCollection) => {
+const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBridgeServiceCollection) => {
   const bridge = assertEx(services?.bridge, () => 'bridge service not provided')
   const bridgeableToken = assertEx(services?.bridgeableToken, () => 'bridgeableToken service not provided')
   const wallet = assertEx(services?.wallet, () => 'wallet service not provided')
@@ -25,11 +27,10 @@ const createWorker = (connection: Redis, services?: IBridgeServiceCollection) =>
 
   const worker = new Worker(
     queueName,
-    async (job: Job<JobData, ReturnType>) => {
+    async (job: EthTransactionSubmissionJob) => {
       const { tx } = job.data
       const hash = await PayloadBuilder.hash(tx[0])
       const state = assertEx(await stateMap.get(hash), () => `[${hash}] state not found`)
-      const preparedTx = assertEx(state?.preparedTx, () => `[${hash}] preparedTx not found`)
 
       // Idempotency check against resubmission
       const { submissionHash: existingSubmissionHash } = state
@@ -40,42 +41,13 @@ const createWorker = (connection: Redis, services?: IBridgeServiceCollection) =>
 
       // Submit the transaction to the Ethereum network
       await job.log(`[${hash}] Submitting ETH tx`)
-      // const submissionResponse = await wallet.sendTransaction(preparedTx)
-      // const submissionHash = submissionResponse.hash
-
       const submissionHash = assertEx(await submitEthTransaction(tx, bridgeableToken, bridge, wallet), () => `[${hash}] submissionHash not found in receipt`)
-
       await job.log(`[${hash}] Submitted ETH tx and received submission response hash ${submissionHash}`)
-
-      // Store the submission hash in the state
-      await job.log(`[${hash}] Storing ETH submissionHash`)
-      state.submissionHash = submissionHash
-      await stateMap.set(hash, state)
-      await job.log(`[${hash}] Stored ETH submissionHash`)
-
       return { submissionHash }
-      // const hash = await PayloadBuilder.hash(tx[0])
-      // await job.log(`[${hash}] Obtaining bridge intent from tx`)
-      // const bridgeIntent = assertEx(tx[1].find(isBridgeIntent), () => 'No bridge intent found in transaction payload')
-      // await job.log(`[${hash}] submitting ETH transaction`)
-      // const amount = hexToBigInt(bridgeIntent.destAmount)
-      // const srcAddress = getAddress(bridgeIntent.srcAddress)
-      // const destAddress = getAddress(bridgeIntent.destAddress)
-      // const tx = await bridge.bridgeFromRemote(srcAddress, destAddress, amount)
-      // // const nonce = await wallet.getNonce()
-      // // const tx = await bridge.bridgeFromRemote(srcAddress, destAddress, amount, { nonce })
-      // await job.log(`[${hash}] submitted ETH transaction`)
-      // const confirmation = await tx.wait()
-      // const transactionResponse = await confirmation?.getTransaction()
-      // const destConfirmation = asHex(transactionResponse?.hash ?? '', true)
-      // const block = await transactionResponse?.getBlock()
-      // await job.log(`[${hash}] confirmed ETH transaction with hash ${destConfirmation} in block ${block?.number}`)
-      // const { schema, ...rest } = bridgeIntent
-      // const result: BridgeDestinationObservation = new PayloadBuilder<BridgeDestinationObservation>({ schema: BridgeDestinationObservationSchema })
-      //   .fields({ ...rest, destConfirmation }).build()
-      // return result
     },
-    { connection, concurrency: 1 },
+    {
+      connection, telemetry, concurrency: 1, prefix,
+    },
   )
 
   worker.on('failed', (job, err) => {

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/WorkerDescription.ts

@@ -1,9 +1,10 @@
+import type { BullMQOtel } from 'bullmq-otel'
 import type { Redis } from 'ioredis'
 
 import type { IBridgeServiceCollection } from '../../services/index.ts'
 
 export interface WorkerDescription {
-  createWorker: (connection: Redis, services?: IBridgeServiceCollection) => void
+  createWorker: (connection: Redis, telemetry?: BullMQOtel, services?: IBridgeServiceCollection) => void
   name: string
   queueName: string
 }

package/src/queue/workers/Xl1ToEthBridgeParent.ts

@@ -1,22 +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 = { 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) => {
+const createWorker = (connection: Redis, telemetry?: BullMQOtel) => {
   const worker = new Worker(
     queueName,
-    async (job: Job) => {
+    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`)
-      // const values = await job.getChildrenValues()
-      return { ok: true }
+      return {}
+    },
+    {
+      connection, telemetry, prefix,
     },
-    { connection },
   )
 
   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'
@@ -5,44 +6,47 @@ import { PayloadBuilder } from '@xyo-network/sdk-js'
 import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { UnrecoverableError, Worker } from 'bullmq'
+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'
 
-type JobData = { tx: SignedHydratedTransaction }
-
-interface ReturnType {
+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, services?: IBridgeServiceCollection) => {
+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<JobData, ReturnType>) => {
+    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
@@ -59,7 +63,9 @@ const createWorker = (connection: Redis, services?: IBridgeServiceCollection) =>
       await job.log(`[${hash}] Transaction not yet included, retrying later`)
       throw new Error(`[${hash}] Transaction not yet included`)
     },
-    { connection },
+    {
+      connection, telemetry, prefix,
+    },
   )
 
   worker.on('failed', (job, err) => {

package/src/queue/workers/Xl1TransactionPreparation.ts

@@ -3,23 +3,25 @@ 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 } from '../../services/index.ts'
+import { prefix } from '../prefix.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = { tx: SignedHydratedTransaction }
-
-interface ReturnType {}
+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'
-const createWorker = (connection: Redis, services?: IBridgeServiceCollection) => {
+const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBridgeServiceCollection) => {
   const stateMap = assertEx(services?.xl1TxStateMap, () => 'xl1TxStateMap service not provided')
 
   const worker = new Worker(
     queueName,
-    async (job: Job<JobData, ReturnType>) => {
+    async (job: Xl1TransactionPreparationJob) => {
       const { tx } = job.data
       const hash = await PayloadBuilder.hash(tx[0])
       await job.log(`[${hash}] preparing XL1 transaction`)
@@ -28,9 +30,11 @@ const createWorker = (connection: Redis, services?: IBridgeServiceCollection) =>
       await stateMap.set(hash, { preparedTx })
       await job.log(`[${hash}] stored XL1 preparedTx`)
       await job.log(`[${hash}] prepared XL1 transaction`)
-      return {}
+      return { preparedTx }
+    },
+    {
+      connection, telemetry, prefix,
     },
-    { connection },
   )
 
   worker.on('failed', (job, err) => {

package/src/queue/workers/Xl1TransactionSubmission.ts

@@ -3,27 +3,30 @@ 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 { submitXl1Transaction } from './util/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = { tx: SignedHydratedTransaction }
-
-interface ReturnType {
+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, services?: IBridgeServiceCollection) => {
+
+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<JobData, ReturnType>) => {
+    async (job: Xl1TransactionSubmissionJob) => {
       const { tx } = job.data
       // Get the hash of the transaction
       const hash = await PayloadBuilder.hash(tx[0])
@@ -46,15 +49,12 @@ const createWorker = (connection: Redis, services?: IBridgeServiceCollection) =>
       // 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 },
+    {
+      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

@@ -1,3 +1,4 @@
+import type { BullMQOtel } from 'bullmq-otel'
 import type { Redis } from 'ioredis'
 
 import type { IBridgeServiceCollection } from '../../services/index.ts'
@@ -5,18 +6,24 @@ import {
   EthTransactionMonitor,
   EthTransactionPreparation,
   EthTransactionSubmission,
+  EthTransactionSubmissionStorage,
   Xl1ToEthBridgeParent,
   Xl1TransactionMonitor,
   Xl1TransactionPreparation,
   Xl1TransactionSubmission,
+  Xl1TransactionSubmissionStorage,
 } from './index.ts'
 
-export const createWorkers = (connection: Redis, services: IBridgeServiceCollection) => {
-  Xl1ToEthBridgeParent.createWorker(connection)
-  Xl1TransactionPreparation.createWorker(connection, services)
-  Xl1TransactionSubmission.createWorker(connection, services)
-  Xl1TransactionMonitor.createWorker(connection, services)
-  EthTransactionPreparation.createWorker(connection, services)
-  EthTransactionSubmission.createWorker(connection, services)
-  EthTransactionMonitor.createWorker(connection, services)
+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)
+  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,4 +1,2 @@
 export * from './submitEthTransaction.ts'
 export * from './submitXl1Transaction.ts'
-export * from './validateSufficientAllowance.ts'
-export * from './validateSufficientBalance.ts'

package/src/server/addFlowProducer.ts

@@ -1,11 +1,14 @@
 import type { BridgeConfig } from '@xyo-network/chain-orchestration'
 import type { Express } from 'express'
 
-import { getConnection, getFlowProducer } from '../queue/index.ts'
+import {
+  getConnection, getFlowProducer, getTelemetry,
+} from '../queue/index.ts'
 
 export const addFlowProducer = (app: Express, config: BridgeConfig): Express => {
   const connection = getConnection(config)
-  const flowProducer = getFlowProducer(connection)
+  const telemetry = getTelemetry()
+  const flowProducer = getFlowProducer(connection, telemetry)
   app.flowProducer = flowProducer
   return app
 }

package/src/server/addWorkers.ts

@@ -1,9 +1,13 @@
 import type { BridgeConfig } from '@xyo-network/chain-orchestration'
 
-import { createWorkers, getConnection } from '../queue/index.ts'
+import {
+  createWorkers, getConnection,
+  getTelemetry,
+} from '../queue/index.ts'
 import type { IBridgeServiceCollection } from '../services/index.ts'
 
 export const addWorkers = (config: BridgeConfig, services: IBridgeServiceCollection) => {
   const connection = getConnection(config)
-  createWorkers(connection, services)
+  const telemetry = getTelemetry()
+  createWorkers(connection, telemetry, services)
 }

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
     }
   }
 }