@xyo-network/chain-bridge 1.19.16 → 1.19.18

package/src/queue/workers/EthTransactionPreparation.ts

@@ -3,38 +3,41 @@ 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 './util/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = { tx: SignedHydratedTransaction }
-
-interface ReturnType {}
+export type EthTransactionPrepareJobData = { tx: SignedHydratedTransaction }
+export type EthTransactionPrepareJobReturn = Record<string, never>
 
 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: Job<EthTransactionPrepareJobData, EthTransactionPrepareJobReturn>) => {
       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 +49,18 @@ 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 },
   )
 
   worker.on('failed', (job, err) => {

package/src/queue/workers/EthTransactionSubmission.ts

@@ -3,21 +3,22 @@ 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 { submitEthTransaction } from './util/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = { tx: SignedHydratedTransaction }
+export type EthTransactionSubmissionJobData = { tx: SignedHydratedTransaction }
 
-interface ReturnType {
+export interface EthTransactionSubmissionJobReturn {
   submissionHash: Required<EthTxState>['submissionHash']
 }
 
 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 +26,10 @@ const createWorker = (connection: Redis, services?: IBridgeServiceCollection) =>
 
   const worker = new Worker(
     queueName,
-    async (job: Job<JobData, ReturnType>) => {
+    async (job: Job<EthTransactionSubmissionJobData, EthTransactionSubmissionJobReturn>) => {
       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,8 +40,6 @@ 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`)
 
@@ -54,28 +52,10 @@ const createWorker = (connection: Redis, services?: IBridgeServiceCollection) =>
       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,
+    },
   )
 
   worker.on('failed', (job, err) => {

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,25 @@
 import type { Job } from 'bullmq'
 import { Worker } from 'bullmq'
+import type { BullMQOtel } from 'bullmq-otel'
 import type { Redis } from 'ioredis'
 
 import type { WorkerDescription } from './WorkerDescription.ts'
 
+export type Xl1ToEthBridgeParentJobData = {}
+export interface 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: Job<Xl1ToEthBridgeParentJobData, Xl1ToEthBridgeParentJobReturn>) => {
       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 },
+    { connection, telemetry },
   )
 
   worker.on('failed', (job, err) => {

package/src/queue/workers/Xl1TransactionMonitor.ts

@@ -5,25 +5,26 @@ 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 type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = { tx: SignedHydratedTransaction }
+export type Xl1TransactionMonitorJobData = { tx: SignedHydratedTransaction }
 
-interface ReturnType {
+export interface 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 worker = new Worker(
     queueName,
-    async (job: Job<JobData, ReturnType>) => {
+    async (job: Job<Xl1TransactionMonitorJobData, Xl1TransactionMonitorJobReturn>) => {
       const { tx } = job.data
       // Get the hash of the transaction
       const hash = await PayloadBuilder.hash(tx[0])
@@ -35,6 +36,7 @@ const createWorker = (connection: Redis, services?: IBridgeServiceCollection) =>
       // 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)
 
       // Transaction found on chain
       if (isDefined(foundTx) && !isNull(foundTx)) {
@@ -59,7 +61,7 @@ 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 },
   )
 
   worker.on('failed', (job, err) => {

package/src/queue/workers/Xl1TransactionPreparation.ts

@@ -3,23 +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 { IBridgeServiceCollection } from '../../services/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = { tx: SignedHydratedTransaction }
-
-interface ReturnType {}
+export type Xl1TransactionPreparationJobData = { tx: SignedHydratedTransaction }
+export interface Xl1TransactionPreparationJobReturn { preparedTx: SignedHydratedTransaction }
 
 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: Job<Xl1TransactionPreparationJobData, Xl1TransactionPreparationJobReturn>) => {
       const { tx } = job.data
       const hash = await PayloadBuilder.hash(tx[0])
       await job.log(`[${hash}] preparing XL1 transaction`)
@@ -28,9 +28,9 @@ 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 },
+    { connection, telemetry },
   )
 
   worker.on('failed', (job, err) => {

package/src/queue/workers/Xl1TransactionSubmission.ts

@@ -3,27 +3,28 @@ 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 { submitXl1Transaction } from './util/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = { tx: SignedHydratedTransaction }
+export type Xl1TransactionSubmissionJobData = { tx: SignedHydratedTransaction }
 
-interface ReturnType {
+export interface Xl1TransactionSubmissionJobReturn {
   submissionHash: Required<Xl1TxState>['submissionHash']
 }
 
 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: Job<Xl1TransactionSubmissionJobData, Xl1TransactionSubmissionJobReturn>) => {
       const { tx } = job.data
       // Get the hash of the transaction
       const hash = await PayloadBuilder.hash(tx[0])
@@ -54,7 +55,7 @@ const createWorker = (connection: Redis, services?: IBridgeServiceCollection) =>
 
       return { submissionHash }
     },
-    { connection },
+    { connection, telemetry },
   )
 
   worker.on('failed', (job, err) => {

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'
@@ -11,12 +12,12 @@ import {
   Xl1TransactionSubmission,
 } 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) => {
+  Xl1ToEthBridgeParent.createWorker(connection, telemetry)
+  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)
 }

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

@@ -0,0 +1,5 @@
+import type { Promisable } from '@xylabs/sdk-js'
+
+export interface AsyncLogger {
+  log: (message: string) => Promisable<unknown>
+}

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

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

package/src/queue/workers/util/{validateSufficientAllowance.ts → validateSufficientLiquiditySourceAllowance.ts}

@@ -1,11 +1,8 @@
-import type { Promisable } from '@xylabs/sdk-js'
 import { assertEx, hexToBigInt } from '@xylabs/sdk-js'
 import type { BridgeableToken, LiquidityPoolBridge } from '@xyo-network/typechain'
 import { isBridgeIntent, type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 
-interface IAsyncLogger {
-  log: (message: string) => Promisable<unknown>
-}
+import type { AsyncLogger } from './AsyncLogger.ts'
 
 /**
  * Checks if the liquidity source has sufficient allowance for the bridge to execute the transaction. This doesn't
@@ -17,11 +14,11 @@ interface IAsyncLogger {
  * @param logger Optional logger for asynchronous logging
  * @returns True if the liquidity source allowance is sufficient to execute the bridge
  */
-export const validateSufficientAllowance = async (
+export const validateSufficientLiquiditySourceAllowance = async (
   tx: SignedHydratedTransaction,
   bridgeableToken: BridgeableToken,
   bridge: LiquidityPoolBridge,
-  logger?: IAsyncLogger,
+  logger?: AsyncLogger,
 ) => {
   // Get the amount being bridged from the bridge intent
   const bridgeIntent = assertEx(tx[1].find(isBridgeIntent), () => 'No bridge intent found')

package/src/queue/workers/util/{validateSufficientBalance.ts → validateSufficientLiquiditySourceBalance.ts}

@@ -1,11 +1,8 @@
-import type { Promisable } from '@xylabs/sdk-js'
 import { assertEx, hexToBigInt } from '@xylabs/sdk-js'
 import type { BridgeableToken, LiquidityPoolBridge } from '@xyo-network/typechain'
 import { isBridgeIntent, type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 
-interface IAsyncLogger {
-  log: (message: string) => Promisable<unknown>
-}
+import type { AsyncLogger } from './AsyncLogger.ts'
 
 /**
  * Checks if the liquidity source has sufficient balance for the bridge to execute the transaction. This doesn't
@@ -17,11 +14,11 @@ interface IAsyncLogger {
  * @param logger Optional logger for asynchronous logging
  * @returns True if the liquidity source balance is sufficient to execute the bridge
  */
-export const validateSufficientBalance = async (
+export const validateSufficientLiquiditySourceBalance = async (
   tx: SignedHydratedTransaction,
   bridgeableToken: BridgeableToken,
   bridge: LiquidityPoolBridge,
-  logger?: IAsyncLogger,
+  logger?: AsyncLogger,
 ) => {
   // Get the amount being bridged from the bridge intent
   const bridgeIntent = assertEx(tx[1].find(isBridgeIntent), () => 'No bridge intent found')

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

@@ -0,0 +1,57 @@
+import { assertEx } from '@xylabs/sdk-js'
+import type { ContractTransaction, Wallet } from 'ethers'
+
+import type { AsyncLogger } from './AsyncLogger.ts'
+
+const DEFAULT_GAS_BUFFER_BPS = 2000n // 20%
+
+/**
+ * Validates that the wallet (the account that will submit the tx) has enough ETH
+ * to cover the estimated gas cost (plus a buffer) for the transaction.
+ * @param preparedTx The transaction that is being prepared for submission.
+ * This should be a fully populated transaction (to/from/data/value) except for gas fields.
+ * @param wallet The wallet that will be used to submit the transaction.
+ * @param logger Optional logger for asynchronous logging.
+ * @param bufferBps The buffer to apply to the estimated gas cost, in basis points (1/100th of a percent).
+ * @returns A boolean indicating whether the wallet has sufficient ETH to cover the estimated gas cost with the buffer applied.
+ */
+export const validateSufficientRunnerEthBalanceForGas = async (
+  preparedTx: ContractTransaction,
+  wallet: Wallet,
+  logger?: AsyncLogger,
+  bufferBps: bigint = DEFAULT_GAS_BUFFER_BPS,
+) => {
+  const provider = assertEx(wallet.provider, () => 'Wallet provider is not defined')
+
+  // Fee data (EIP-1559 preferred, gasPrice fallback)
+  const feeData = await provider.getFeeData()
+  const perGas = feeData.maxFeePerGas ?? feeData.gasPrice
+  if (perGas == null) {
+    await logger?.log('[gas] unable to resolve gas price / maxFeePerGas from provider')
+    return true // don’t hard-fail; provider may not support fee data
+  }
+
+  // Estimate gas
+  const transactionRequest = {
+    ...preparedTx,
+    from: await wallet.getAddress(),
+  }
+  const estGas = await provider.estimateGas(transactionRequest)
+
+  // Include any value sent with the tx
+  const txValue = preparedTx?.value ?? 0n
+
+  // Required = (gas * perGas + value) * (1 + buffer)
+  const baseRequired = estGas * perGas + txValue
+  const required = (baseRequired * (10_000n + bufferBps)) / 10_000n
+
+  const balance = await provider.getBalance(await wallet.getAddress())
+
+  await logger?.log(
+    `[gas] runner=${await wallet.getAddress()} balance=${balance.toString()} `
+    + `estGas=${estGas.toString()} perGas=${perGas.toString()} value=${txValue.toString()} `
+    + `requiredWithBuffer=${required.toString()} bufferBps=${bufferBps.toString()}`,
+  )
+
+  return balance >= required
+}

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