@xyo-network/chain-bridge 1.20.14 → 1.20.16

package/src/queue/workers/EthTransactionSubmissionStorage.ts

@@ -1,76 +0,0 @@
-import { assertEx, isDefined } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-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'
-import type { Xl1TransactionJobData } from './Xl1TransactionJobData.ts'
-
-export type EthTransactionSubmissionStorageJobData = Xl1TransactionJobData
-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,10 +0,0 @@
-import type { BullMQOtel } from 'bullmq-otel'
-import type { Redis } from 'ioredis'
-
-import type { IBridgeServiceCollection } from '../../services/index.ts'
-
-export interface WorkerDescription {
-  createWorker: (connection: Redis, telemetry?: BullMQOtel, services?: IBridgeServiceCollection) => void
-  name: string
-  queueName: string
-}

package/src/queue/workers/Xl1ToEthBridgeParent.ts

@@ -1,41 +0,0 @@
-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'
-import type { Xl1DataLakeTransactionJobData } from './Xl1TransactionJobData.ts'
-
-export type Xl1ToEthBridgeParentJobData = Xl1DataLakeTransactionJobData
-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: 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, 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 Xl1ToEthBridgeParent: WorkerDescription = {
-  createWorker, name, queueName,
-}

package/src/queue/workers/Xl1TransactionJobData.ts

@@ -1,12 +0,0 @@
-import type { Payload } from '@xyo-network/sdk-js'
-import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
-
-/**
- * Represents the data required for a job that requires an XL1 transaction.
- */
-export type Xl1TransactionJobData = { tx: SignedHydratedTransaction }
-
-/**
- * Represents the data required for a job that requires an XL1 transaction and its associated off-chain payloads.
- */
-export type Xl1DataLakeTransactionJobData = Xl1TransactionJobData & { offChainPayloads: Payload[] }

package/src/queue/workers/Xl1TransactionMonitor.ts

@@ -1,82 +0,0 @@
-import type { BrandedHash } from '@xylabs/sdk-js'
-import {
-  assertEx, isDefined, isNull,
-} from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-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'
-import type { Xl1TransactionJobData } from './Xl1TransactionJobData.ts'
-
-export type Xl1TransactionMonitorJobData = Xl1TransactionJobData
-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: 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 state = assertEx(await stateMap.get(hash), () => `[${hash}] state 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.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
-        const submissionHash = await PayloadBuilder.hash(foundTx[0])
-        return { submissionHash }
-      }
-
-      // 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, 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 Xl1TransactionMonitor: WorkerDescription = {
-  createWorker, name, queueName,
-}

package/src/queue/workers/Xl1TransactionPreparation.ts

@@ -1,52 +0,0 @@
-import { assertEx } 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 } from '../../services/index.ts'
-import { prefix } from '../prefix.ts'
-import type { WorkerDescription } from './WorkerDescription.ts'
-import type { Xl1DataLakeTransactionJobData } from './Xl1TransactionJobData.ts'
-
-export type Xl1TransactionPreparationJobData = Xl1DataLakeTransactionJobData
-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, telemetry?: BullMQOtel, services?: IBridgeServiceCollection) => {
-  const stateMap = assertEx(services?.xl1TxStateMap, () => 'xl1TxStateMap service not provided')
-
-  const worker = new Worker(
-    queueName,
-    async (job: Xl1TransactionPreparationJob) => {
-      const { tx, offChainPayloads = [] } = 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, { offChainPayloads, preparedTx })
-      await job.log(`[${hash}] stored XL1 preparedTx`)
-      await job.log(`[${hash}] prepared XL1 transaction`)
-      return { preparedTx }
-    },
-    {
-      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 Xl1TransactionPreparation: WorkerDescription = {
-  createWorker, name, queueName,
-}

package/src/queue/workers/Xl1TransactionSubmission.ts

@@ -1,70 +0,0 @@
-import { assertEx, isDefined } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-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'
-import type { Xl1TransactionJobData } from './Xl1TransactionJobData.ts'
-
-export type Xl1TransactionSubmissionJobData = Xl1TransactionJobData
-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: Xl1TransactionSubmissionJob) => {
-      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`)
-      const {
-        preparedTx, offChainPayloads = [], submissionHash: existingSubmissionHash,
-      } = state
-
-      // Idempotency check against resubmission
-      if (isDefined(existingSubmissionHash)) {
-        await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`)
-        return { submissionHash: existingSubmissionHash }
-      }
-      const txToSubmit = assertEx(preparedTx, () => `[${hash}] preparedTx not found`)
-
-      // Submit the transaction to the XL1 network
-      await job.log(`[${hash}] Submitting XL1 tx`)
-      const [submissionHash] = await submitXl1Transaction(txToSubmit, offChainPayloads, gateway)
-      await job.log(`[${hash}] Submitted XL1 tx`)
-
-      // This worker intentionally does NOT store state as subsequent steps will do that.
-      return { submissionHash }
-    },
-    {
-      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 Xl1TransactionSubmission: WorkerDescription = {
-  createWorker, name, queueName,
-}

package/src/queue/workers/Xl1TransactionSubmissionStorage.ts

@@ -1,77 +0,0 @@
-import { assertEx, isDefined } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-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 { Xl1TransactionJobData } from './Xl1TransactionJobData.ts'
-import type { Xl1TransactionSubmissionJobReturn } from './Xl1TransactionSubmission.ts'
-import { Xl1TransactionSubmission } from './Xl1TransactionSubmission.ts'
-
-export type Xl1TransactionSubmissionStorageJobData = Xl1TransactionJobData
-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,29 +0,0 @@
-import type { BullMQOtel } from 'bullmq-otel'
-import type { Redis } from 'ioredis'
-
-import type { IBridgeServiceCollection } from '../../services/index.ts'
-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)
-  Xl1TransactionSubmissionStorage.createWorker(connection, telemetry, services)
-}

package/src/queue/workers/index.ts

@@ -1,11 +0,0 @@
-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,2 +0,0 @@
-export * from './submitEthTransaction.ts'
-export * from './submitXl1Transaction.ts'

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

@@ -1,32 +0,0 @@
-import {
-  assertEx, hexToBigInt, toEthAddress,
-} from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { LiquidityPoolBridge } from '@xyo-network/typechain'
-import { isBridgeIntent, type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
-import type { Wallet } from 'ethers'
-
-export const submitEthTransaction = async (
-  tx: SignedHydratedTransaction,
-  offChainPayloads: Payload[],
-  bridge: LiquidityPoolBridge,
-  wallet: Wallet,
-) => {
-  // Approve the bridge to spend tokens
-  const xl1Transaction = assertEx(tx[0], () => 'No corresponding XL1 transaction found')
-  const allPayloads = [...tx[1], ...offChainPayloads]
-  const bridgeIntent = assertEx(allPayloads.find(isBridgeIntent), () => 'No bridge intent found')
-  const srcAddress = toEthAddress(bridgeIntent.srcAddress)
-  const destAddress = toEthAddress(bridgeIntent.destAddress)
-  const amount = hexToBigInt(bridgeIntent.destAmount)
-  const nonce = hexToBigInt(await PayloadBuilder.hash(xl1Transaction))
-  // Assume approval has already been done out of band for simplicity
-  // const contractApprovalTx = await bridgeableToken.connect(wallet).approve(bridge.getAddress(), amount)
-  // await contractApprovalTx.wait(1)
-
-  // Send tokens to bridge
-  const bridgeTx = await bridge.connect(wallet).bridgeFromRemote(srcAddress, destAddress, amount, nonce)
-  const receipt = await bridgeTx.wait(1)
-  return receipt?.hash
-}

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

@@ -1,26 +0,0 @@
-import { type BrandedHash } from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/sdk-js'
-import { type SignedHydratedTransaction, type XyoGatewayRunner } from '@xyo-network/xl1-sdk'
-
-export const submitXl1Transaction = async (
-  preparedTx: SignedHydratedTransaction,
-  offChain: Payload[] = [],
-  gateway: XyoGatewayRunner,
-): Promise<[BrandedHash, SignedHydratedTransaction]> => {
-  // Option 1: Add payloads to chain with addPayloadsToChain
-  // Not optimal as it requires reconstructing the transaction from the on-chain payloads, which changes the tx hash
-  // const offChainPayloads = preparedTx[1].filter(p => !isAllowedBlockPayload(p))
-  // const onChainPayloads = preparedTx[1].filter(isAllowedBlockPayload)
-  // const result = await gateway.addPayloadsToChain(onChainPayloads, offChainPayloads)
-  // return result
-
-  // Option 2: Add transaction to chain with addTransactionToChain
-  // Fails due to resigning of transaction in addTransactionToChain, which causes `from` to be invalid
-  const result = await gateway.addTransactionToChain(preparedTx, offChain)
-  return result
-
-  // Option 3: Add transaction to chain with addTransactionToChain, but bypass resigning by passing the preparedTx as an unsigned transaction
-  // const runner = assertEx(gateway.connection.runner, () => 'No runner available on gateway connection')
-  // const result = await runner.broadcastTransaction(preparedTx)
-  // return [result, preparedTx]
-}

package/src/server/addFlowProducer.ts

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

package/src/server/addWorkers.ts

@@ -1,13 +0,0 @@
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-
-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)
-  const telemetry = getTelemetry()
-  createWorkers(connection, telemetry, services)
-}

package/src/server/app.ts

@@ -1,20 +0,0 @@
-import { standardErrors } from '@xylabs/express'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import { sharedMiddleware } from '@xyo-network/chain-orchestration'
-import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
-import type { Express } from 'express'
-import express from 'express'
-
-import { addFlowProducer } from './addFlowProducer.ts'
-import { addInstrumentation } from './instrumentation.ts'
-import { addRoutes } from './routes/index.ts'
-
-export const getApp = (config: BridgeConfig, gateway: XyoGatewayRunner): Express => {
-  addInstrumentation()
-  const app = express()
-  sharedMiddleware(app)
-  addFlowProducer(app, config)
-  addRoutes(app, config, gateway)
-  app.use(standardErrors)
-  return app
-}

package/src/server/index.ts

@@ -1,19 +0,0 @@
-export * from './app.ts'
-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 {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace Express {
-    interface Application {
-      flowProducer: FlowProducer
-      services: IBridgeServiceCollection
-    }
-  }
-}

package/src/server/instrumentation.ts

@@ -1,15 +0,0 @@
-import { registerInstrumentations } from '@opentelemetry/instrumentation'
-import { ExpressInstrumentation } from '@opentelemetry/instrumentation-express'
-import { HttpInstrumentation } from '@opentelemetry/instrumentation-http'
-
-/**
- * Registers OpenTelemetry instrumentations for HTTP and Express.
- * This function is used to set up the necessary instrumentations for monitoring
- * HTTP requests and Express applications. Since it monkey patches the Express
- * router & middleware system, it should be called before any Express applications
- * are defined.
- */
-export const addInstrumentation = () => {
-  const instrumentations = [new HttpInstrumentation(), new ExpressInstrumentation()]
-  registerInstrumentations({ instrumentations })
-}

package/src/server/routes/addRoutes.ts

@@ -1,9 +0,0 @@
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
-import type { Express } from 'express'
-
-import { addBridgeRoutes } from './bridge/index.ts'
-
-export const addRoutes = (app: Express, config: BridgeConfig, gateway: XyoGatewayRunner) => {
-  addBridgeRoutes(app, config, gateway)
-}

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

@@ -1,12 +0,0 @@
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
-import type { Express } from 'express'
-
-import { getRouteDefinitions } from './routeDefinitions/index.ts'
-
-export const addBridgeRoutes = (app: Express, config: BridgeConfig, gateway: XyoGatewayRunner) => {
-  const routeDefinitions = getRouteDefinitions(config, gateway)
-  for (const definition of routeDefinitions) {
-    app[definition.method](definition.path, definition.handlers)
-  }
-}

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

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