@xyo-network/chain-bridge 1.17.7 → 1.18.0

package/src/manifest/getServices.ts

@@ -0,0 +1,102 @@
+import { BaseMongoSdk, type BaseMongoSdkPrivateConfig } from '@xylabs/mongo'
+import type { Hash, Logger } from '@xylabs/sdk-js'
+import { assertEx, isDefined } from '@xylabs/sdk-js'
+import { MongoMap } from '@xyo-network/chain-protocol'
+import { initEvmProvider } from '@xyo-network/chain-services'
+import { LiquidityPoolBridge__factory } from '@xyo-network/typechain'
+import { HDWallet } from '@xyo-network/wallet'
+import type {
+  Config, IterableMap, XyoGatewayRunner,
+} from '@xyo-network/xl1-protocol-sdk'
+import {
+  hasMongoConfig, mapToMapType, SimpleXyoGatewayRunner, SimpleXyoSigner,
+  XyoConnectionMoniker,
+} from '@xyo-network/xl1-protocol-sdk'
+import type { SimpleXyoConnection } from '@xyo-network/xl1-providers'
+import { buildJsonRpcProviderLocator } from '@xyo-network/xl1-providers'
+import type { RpcSchemaMap, TransportFactory } from '@xyo-network/xl1-rpc'
+import { HttpRpcTransport } from '@xyo-network/xl1-rpc'
+import { getAddress, Wallet } from 'ethers'
+import type { Document } from 'mongodb'
+
+import type {
+  EthTxState, IBridgeServiceCollection, Xl1TxState,
+} from '../services/index.ts'
+
+export interface GetServicesContext {
+  config: Config
+  logger?: Logger
+}
+
+/**
+ * Used for retrieving a service collection
+ * @returns A service collection
+ */
+export const getServices = async (context: GetServicesContext): Promise<IBridgeServiceCollection> => {
+  const { config } = context
+
+  const gateway = await getGateway(config)
+  const ethTxStateMap = await getIterableMap<Hash, EthTxState>(config, 'liquidity_bridge_xl1_to_eth_eth_tx_state')
+  const xl1TxStateMap = await getIterableMap<Hash, Xl1TxState>(config, 'liquidity_bridge_xl1_to_eth_xl1_tx_state')
+  const provider = await initEvmProvider({ config })
+  // TODO: Get from config
+  const {
+    remoteBridgeContractAddress, remoteChainWalletPrivateKey, mnemonic,
+  } = config.bridge
+  const account = isDefined(mnemonic) ? await HDWallet.fromPhrase(mnemonic) : await HDWallet.random()
+  const wallet = new Wallet(remoteChainWalletPrivateKey, provider)
+  const bridge = LiquidityPoolBridge__factory.connect(getAddress(remoteBridgeContractAddress), wallet)
+  // Assert we are contract owner so we can call ownable methods
+  const bridgeOwner = await bridge.owner()
+  assertEx(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => 'Wallet is not the owner of the bridge contract')
+  return {
+    account,
+    bridge,
+    ethTxStateMap,
+    gateway,
+    provider,
+    wallet,
+    xl1TxStateMap,
+  }
+}
+
+const getGateway = async (
+  config: Config,
+): Promise<XyoGatewayRunner> => {
+  const { mnemonic, chainRpcApiUrl: endpoint } = config.bridge
+  const walletPromise = isDefined(mnemonic) ? HDWallet.fromPhrase(mnemonic) : HDWallet.random()
+  const account = await walletPromise
+  const signer = new SimpleXyoSigner(account)
+  const transportFactory: TransportFactory = (schemas: RpcSchemaMap) => new HttpRpcTransport(endpoint, schemas)
+  const locator = await buildJsonRpcProviderLocator({ transportFactory })
+  const connection = await locator.getInstance<SimpleXyoConnection>(XyoConnectionMoniker)
+  const gateway = new SimpleXyoGatewayRunner(connection, signer)
+  return gateway
+}
+
+/**
+ * Gets an iterable map based on the storage instructions in the config
+ * @param config The config containing storage instructions
+ * @param collection The collection to use if using MongoDB for persistence
+ * @returns The iterable map
+ */
+const getIterableMap = async <K extends {} = string, V extends Document = Document>
+(config: Config, collection: string): Promise<IterableMap<K, V>> => {
+  const mongoConfig = config.storage?.mongo
+  if (hasMongoConfig(mongoConfig)) {
+    const {
+      connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName,
+    } = mongoConfig
+    const payloadSdkConfig: BaseMongoSdkPrivateConfig = {
+      dbConnectionString, dbDomain, dbName, dbPassword, dbUserName,
+    }
+    const sdkBalanceSummaryMap = new BaseMongoSdk<V>({ ...payloadSdkConfig, collection })
+    const result = await MongoMap.create<MongoMap<K, V>>({
+      sdk: sdkBalanceSummaryMap,
+      getCache: { enabled: true, maxEntries: 5000 },
+    })
+    return result
+  } else {
+    return mapToMapType(new Map<K, V>())
+  }
+}

package/src/manifest/index.ts

@@ -1,5 +1,6 @@
 export * from './getLocator.ts'
 export * from './getNode.ts'
+export * from './getServices.ts'
 export * from './nodeManifest.ts'
 export * from './private/index.ts'
 export * from './public/index.ts'

package/src/modules/EVMLiquidityBridgeTransactionCompletionMonitorSentinel/EVMLiquidityBridgeTransactionCompletionMonitorSentinel.ts

@@ -109,7 +109,7 @@ export class EVMLiquidityBridgeTransactionCompletionMonitorSentinel<
     return assertEx(this._wallet, () => 'wallet is required')
   }
 
-  override async createHandler(): Promise<void> {
+  override async createHandler() {
     await super.createHandler()
     // Create meters for tracking bridge attempts, successes, and errors.
     this._attemptsCounter = this.meter?.createCounter(

package/src/modules/XL1TransactionCompletionMonitorSentinel/XL1TransactionCompletionMonitorSentinel.ts

@@ -88,7 +88,7 @@ export class XL1TransactionCompletionMonitorSentinel<
     return assertEx(this.params.viewer, () => 'Viewer is not defined in params')
   }
 
-  override async createHandler(): Promise<void> {
+  override async createHandler() {
     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' })

package/src/queue/connection.ts

@@ -0,0 +1,16 @@
+import { isDefined } from '@xylabs/sdk-js'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+import { Redis } from 'ioredis'
+
+let connection: Redis | undefined
+
+const maxRetriesPerRequest = null
+
+export const getConnection = (config: Config) => {
+  if (isDefined(connection)) return connection
+  const { redisHost: host, redisPort: port } = config.bridge
+  connection = new Redis({
+    host, port, maxRetriesPerRequest,
+  })
+  return connection
+}

package/src/queue/flowProducer.ts

@@ -0,0 +1,11 @@
+import { isDefined } from '@xylabs/sdk-js'
+import { FlowProducer } from 'bullmq'
+import type { Redis } from 'ioredis'
+
+let flowProducer: FlowProducer | undefined
+
+export const getFlowProducer = (connection: Redis) => {
+  if (isDefined(flowProducer)) return flowProducer
+  flowProducer = new FlowProducer({ connection })
+  return flowProducer
+}

package/src/queue/flows/createXl1ToEthBridgeJob.ts

@@ -0,0 +1,60 @@
+import type { SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
+import type { FlowProducer } from 'bullmq'
+
+import {
+  ethTransactionMonitor, ethTransactionPreparation, ethTransactionSubmission, xl1ToEthBridgeParent, xl1TransactionMonitor, xl1TransactionPreparation,
+  xl1TransactionSubmission,
+} from '../workers/index.ts'
+
+export const createXl1ToEthBridgeJob = async (flowProducer: FlowProducer, tx: SignedHydratedTransaction) => {
+  const flow = await flowProducer.add({
+    name: xl1ToEthBridgeParent.name,
+    queueName: xl1ToEthBridgeParent.queueName,
+    data: { tx },
+    children: [
+      {
+        name: xl1TransactionPreparation.name,
+        queueName: xl1TransactionPreparation.queueName,
+        data: { tx },
+        children: [
+          {
+            name: xl1TransactionSubmission.name,
+            queueName: xl1TransactionSubmission.queueName,
+            data: { tx },
+            children: [
+              {
+                name: xl1TransactionMonitor.name,
+                queueName: xl1TransactionMonitor.queueName,
+                data: { tx },
+                opts: { attempts: 60, backoff: { type: 'fixed', delay: 5000 } },
+                children: [
+                  {
+                    name: ethTransactionPreparation.name,
+                    queueName: ethTransactionPreparation.queueName,
+                    data: { tx },
+                    children: [
+                      {
+                        name: ethTransactionSubmission.name,
+                        queueName: ethTransactionSubmission.queueName,
+                        data: { tx },
+                        children: [
+                          {
+                            name: ethTransactionMonitor.name,
+                            queueName: ethTransactionMonitor.queueName,
+                            data: { tx },
+                            opts: { attempts: 60, backoff: { type: 'fixed', delay: 5000 } },
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  })
+  return flow
+}

package/src/queue/flows/index.ts

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

package/src/queue/index.ts

@@ -0,0 +1,4 @@
+export * from './connection.ts'
+export * from './flowProducer.ts'
+export * from './flows/index.ts'
+export * from './workers/index.ts'

package/src/queue/workers/WorkerDescription.ts

@@ -0,0 +1,7 @@
+import type { Redis } from 'ioredis'
+
+export interface WorkerDescription {
+  createWorker: (connection: Redis) => void
+  name: string
+  queueName: string
+}

package/src/queue/workers/createWorkers.ts

@@ -0,0 +1,15 @@
+import type { Redis } from 'ioredis'
+
+import {
+  ethTransactionMonitor, ethTransactionSubmission, xl1ToEthBridgeParent, xl1TransactionMonitor, xl1TransactionSubmission,
+} from './index.ts'
+
+export const createWorkers = (connection: Redis) => {
+  return [
+    xl1ToEthBridgeParent.createWorker(connection),
+    xl1TransactionSubmission.createWorker(connection),
+    xl1TransactionMonitor.createWorker(connection),
+    ethTransactionSubmission.createWorker(connection),
+    ethTransactionMonitor.createWorker(connection),
+  ]
+}

package/src/queue/workers/ethTransactionMonitor.ts

@@ -0,0 +1,42 @@
+import { assertEx } from '@xylabs/sdk-js'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
+import type { Job } from 'bullmq'
+import { Worker } from 'bullmq'
+import type { Redis } from 'ioredis'
+
+import type { IBridgeServiceCollection } from '../../services/index.ts'
+import type { WorkerDescription } from './WorkerDescription.ts'
+
+type JobData = Pick<IBridgeServiceCollection, 'bridge' | 'ethTxStateMap' | 'provider' | 'wallet'> & { tx: SignedHydratedTransaction }
+interface ReturnType {
+  blockHash: string
+  blockNumber: number
+}
+
+const name = 'Monitor Submitted ETH Transaction'
+const queueName = 'eth-tx-monitor'
+const createWorker = (connection: Redis) => {
+  new Worker(
+    queueName,
+    async (job: Job<JobData, ReturnType>) => {
+      const {
+        provider, ethTxStateMap: stateMap, tx,
+      } = job.data
+      const hash = await PayloadBuilder.hash(tx[0])
+      const state = assertEx(await stateMap.get(hash), () => 'State not found')
+      const submissionHash = assertEx(state?.submissionHash, () => 'submissionHash not found')
+      const receipt = assertEx(await provider.getTransactionReceipt(submissionHash), () => 'Transaction receipt not found')
+      await job.log(`[${hash}] confirmed ETH tx ${submissionHash} in block ${receipt.blockNumber}`)
+      const { blockHash, blockNumber } = receipt
+      state.confirmationHash = blockHash
+      await stateMap.set(hash, state)
+      return { blockHash, blockNumber }
+    },
+    { connection },
+  )
+}
+
+export const ethTransactionMonitor: WorkerDescription = {
+  createWorker, name, queueName,
+}

package/src/queue/workers/ethTransactionPreparation.ts

@@ -0,0 +1,47 @@
+import { assertEx, hexToBigInt } from '@xylabs/sdk-js'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { isBridgeIntent, type SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
+import type { Job } from 'bullmq'
+import { Worker } from 'bullmq'
+import { getAddress } from 'ethers'
+import type { Redis } from 'ioredis'
+
+import type { IBridgeServiceCollection } from '../../services/index.ts'
+import type { WorkerDescription } from './WorkerDescription.ts'
+
+type JobData = Pick<IBridgeServiceCollection, 'bridge' | 'ethTxStateMap'> & { tx: SignedHydratedTransaction }
+
+interface ReturnType {}
+
+const name = 'Prepare ETH Transaction'
+const queueName = 'eth-tx-prepare'
+
+export const createWorker = (connection: Redis) => {
+  new Worker(
+    queueName,
+    async (job: Job<JobData, ReturnType>) => {
+      const {
+        bridge, ethTxStateMap: stateMap, tx,
+      } = job.data
+      const hash = await PayloadBuilder.hash(tx[0])
+      await job.log(`[${hash}] preparing ETH transaction`)
+      await job.log(`[${hash}] building ETH transaction`)
+      const bridgeIntent = assertEx(tx[1].find(isBridgeIntent), () => 'No bridge intent found')
+      const amount = hexToBigInt(bridgeIntent.destAmount)
+      const srcAddress = getAddress(bridgeIntent.srcAddress)
+      const destAddress = getAddress(bridgeIntent.destAddress)
+      const preparedTx = await bridge.getFunction('bridgeFromRemote').populateTransaction(srcAddress, destAddress, amount)
+      await job.log(`[${hash}] built ETH transaction`)
+      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 },
+  )
+}
+
+export const ethTransactionPreparation: WorkerDescription = {
+  createWorker, name, queueName,
+}

package/src/queue/workers/ethTransactionSubmission.ts

@@ -0,0 +1,77 @@
+import { assertEx, isDefined } from '@xylabs/sdk-js'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { type SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
+import type { Job } from 'bullmq'
+import { Worker } from 'bullmq'
+import type { Redis } from 'ioredis'
+
+import type { EthTxState, IBridgeServiceCollection } from '../../services/index.ts'
+import type { WorkerDescription } from './WorkerDescription.ts'
+
+type JobData = Pick<IBridgeServiceCollection, 'bridge' | 'ethTxStateMap' | 'wallet'> & { tx: SignedHydratedTransaction }
+
+interface ReturnType {
+  submissionHash: Required<EthTxState>['submissionHash']
+}
+
+const name = 'Submit ETH Transaction'
+const queueName = 'eth-tx-submit'
+const createWorker = (connection: Redis) => {
+  new Worker(
+    queueName,
+    async (job: Job<JobData, ReturnType>) => {
+      const {
+        ethTxStateMap: stateMap, tx, wallet,
+      } = 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
+      if (isDefined(existingSubmissionHash)) {
+        await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`)
+        return { submissionHash: existingSubmissionHash }
+      }
+
+      // Submit the transaction to the Ethereum network
+      await job.log(`[${hash}] Submitting ETH tx`)
+      const submissionResponse = await wallet.sendTransaction(preparedTx)
+      const submissionHash = submissionResponse.hash
+      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 },
+  )
+}
+
+export const ethTransactionSubmission: WorkerDescription = {
+  createWorker, name, queueName,
+}

package/src/queue/workers/index.ts

@@ -0,0 +1,8 @@
+export * from './createWorkers.ts'
+export * from './ethTransactionMonitor.ts'
+export * from './ethTransactionPreparation.ts'
+export * from './ethTransactionSubmission.ts'
+export * from './xl1ToEthBridgeParent.ts'
+export * from './xl1TransactionMonitor.ts'
+export * from './xl1TransactionPreparation.ts'
+export * from './xl1TransactionSubmission.ts'

package/src/queue/workers/xl1ToEthBridgeParent.ts

@@ -0,0 +1,25 @@
+import type { Job } from 'bullmq'
+import { Worker } from 'bullmq'
+import type { Redis } from 'ioredis'
+
+import type { WorkerDescription } from './WorkerDescription.ts'
+
+const name = 'Bridge XL1 to Ethereum'
+const queueName = 'xl1-to-eth-bridge'
+const createWorker = (connection: Redis) => {
+  new Worker(
+    queueName,
+    async (job: Job) => {
+      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 }
+    },
+    { connection },
+  )
+}
+
+export const xl1ToEthBridgeParent: WorkerDescription = {
+  createWorker, name, queueName,
+}

package/src/queue/workers/xl1TransactionMonitor.ts

@@ -0,0 +1,66 @@
+import {
+  assertEx, isDefined, isNull,
+} from '@xylabs/sdk-js'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
+import type { Job } from 'bullmq'
+import { UnrecoverableError, Worker } from 'bullmq'
+import type { Redis } from 'ioredis'
+
+import type { IBridgeServiceCollection } from '../../services/index.ts'
+import type { WorkerDescription } from './WorkerDescription.ts'
+
+type JobData = Pick<IBridgeServiceCollection, 'gateway' | 'xl1TxStateMap'> & { tx: SignedHydratedTransaction }
+
+interface ReturnType {
+}
+
+const name = 'Monitor Submitted XL1 Transaction'
+const queueName = 'xl1-tx-monitor'
+const createWorker = (connection: Redis) => {
+  new Worker(
+    queueName,
+    async (job: Job<JobData, ReturnType>) => {
+      const {
+        gateway, tx, xl1TxStateMap: stateMap,
+      } = 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.connectionInstance.viewer, () => `[${hash}] viewer not defined on gateway`)
+      const state = assertEx(await stateMap.get(hash), () => `[${hash}] state not found`)
+
+      // Check for transaction inclusion on chain
+      await job.log(`[${hash}] Checking for XL1 transaction inclusion on chain`)
+      const foundTx = await viewer.transactionByHash(hash)
+
+      // Transaction found on chain
+      if (isDefined(foundTx) && !isNull(foundTx)) {
+        await job.log(`[${hash}] Found transaction on chain`)
+        // TODO: For now we just store the same hash as TX hash until we have block hash confirmation capability
+        state.confirmationHash = hash
+        await stateMap.set(hash, state)
+        return {}
+      }
+
+      // Check for transaction expiration
+      const currentBlockNumber = await viewer.currentBlockNumber()
+      if (tx[0].exp < currentBlockNumber) {
+        await job.log(
+          `[${hash}] Transaction expired at block ${tx[0].exp}, current block ${currentBlockNumber}`,
+        )
+        // Throw unrecoverable error to stop retries
+        throw new UnrecoverableError(`[${hash}] Transaction expired and will never be included`)
+      }
+
+      // Transaction not yet found, but still valid — retry later
+      await job.log(`[${hash}] Transaction not yet included, retrying later`)
+      throw new Error(`[${hash}] Transaction not yet included`)
+    },
+    { connection },
+  )
+}
+
+export const xl1TransactionMonitor: WorkerDescription = {
+  createWorker, name, queueName,
+}

package/src/queue/workers/xl1TransactionPreparation.ts

@@ -0,0 +1,36 @@
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
+import type { Job } from 'bullmq'
+import { Worker } from 'bullmq'
+import type { Redis } from 'ioredis'
+
+import type { IBridgeServiceCollection } from '../../services/index.ts'
+import type { WorkerDescription } from './WorkerDescription.ts'
+
+type JobData = Pick<IBridgeServiceCollection, 'xl1TxStateMap'> & { tx: SignedHydratedTransaction }
+
+interface ReturnType {}
+
+const name = 'Prepare XL1 Transaction'
+const queueName = 'xl1-tx-prepare'
+const createWorker = (connection: Redis) => {
+  new Worker(
+    queueName,
+    async (job: Job<JobData, ReturnType>) => {
+      const { tx, xl1TxStateMap: stateMap } = job.data
+      const hash = await PayloadBuilder.hash(tx[0])
+      await job.log(`[${hash}] preparing XL1 transaction`)
+      const preparedTx = tx
+      await job.log(`[${hash}] storing XL1 preparedTx`)
+      await stateMap.set(hash, { preparedTx })
+      await job.log(`[${hash}] stored XL1 preparedTx`)
+      await job.log(`[${hash}] prepared XL1 transaction`)
+      return {}
+    },
+    { connection },
+  )
+}
+
+export const xl1TransactionPreparation: WorkerDescription = {
+  createWorker, name, queueName,
+}

package/src/queue/workers/xl1TransactionSubmission.ts

@@ -0,0 +1,60 @@
+import { assertEx, isDefined } from '@xylabs/sdk-js'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
+import type { Job } from 'bullmq'
+import { Worker } from 'bullmq'
+import type { Redis } from 'ioredis'
+
+import type { IBridgeServiceCollection, Xl1TxState } from '../../services/index.ts'
+import type { WorkerDescription } from './WorkerDescription.ts'
+
+type JobData = Pick<IBridgeServiceCollection, 'gateway' | 'xl1TxStateMap'> & { tx: SignedHydratedTransaction }
+
+interface ReturnType {
+  submissionHash: Required<Xl1TxState>['submissionHash']
+}
+
+const name = 'Submit XL1 Transaction'
+const queueName = 'xl1-tx-submit'
+const createWorker = (connection: Redis) => {
+  new Worker(
+    queueName,
+    async (job: Job<JobData, ReturnType>) => {
+      const {
+        gateway, tx, xl1TxStateMap: stateMap,
+      } = 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`)
+      const preparedTx = assertEx(state?.preparedTx, () => `[${hash}] preparedTx not found`)
+
+      // Idempotency check against resubmission
+      const { submissionHash: existingSubmissionHash } = state
+      if (isDefined(existingSubmissionHash)) {
+        await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`)
+        return { submissionHash: existingSubmissionHash }
+      }
+
+      // Submit the transaction to the XL1 network
+      await job.log(`[${hash}] Submitting XL1 tx`)
+      const [submissionHash] = await gateway.addTransactionToChain(preparedTx)
+      // Ensure the submission hash matches the expected hash
+      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`)
+
+      return { submissionHash }
+    },
+    { connection },
+  )
+}
+
+export const xl1TransactionSubmission: WorkerDescription = {
+  createWorker, name, queueName,
+}

package/src/server/app.ts

@@ -9,6 +9,7 @@ import cors from 'cors'
 import type { Express } from 'express'
 import express from 'express'
 
+import { addFlowProducer } from './flowProducer.ts'
 import { addInstrumentation } from './instrumentation.ts'
 import { addRoutes } from './routes/index.ts'
 
@@ -25,6 +26,7 @@ export const getApp = (node: NodeInstance, config: Config): Express => {
   app.use(customPoweredByHeader)
   disableCaseSensitiveRouting(app)
   app.node = node
+  addFlowProducer(app, config)
   addRoutes(app, config)
   app.use(standardErrors)
   return app

package/src/server/flowProducer.ts

@@ -0,0 +1,11 @@
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+import type { Express } from 'express'
+
+import { getConnection, getFlowProducer } from '../queue/index.ts'
+
+export const addFlowProducer = (app: Express, config: Config): Express => {
+  const connection = getConnection(config)
+  const flowProducer = getFlowProducer(connection)
+  app.flowProducer = flowProducer
+  return app
+}