@xyo-network/chain-bridge 1.20.15 → 1.20.16

package/src/queue/flows/createEthToXl1BridgeJob.ts

@@ -1,71 +0,0 @@
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
-import type { FlowProducer } from 'bullmq'
-
-import {
-  EthToXl1BridgeParent, Xl1TransactionMonitor, Xl1TransactionPreparation, Xl1TransactionSubmission,
-  Xl1TransactionSubmissionStorage,
-} from '../workers/index.ts'
-
-/**
- * Creates a job flow for bridging a transaction from Ethereum to XL1.
- * @param flowProducer The flow producer to run the job
- * @param tx The bridge transaction
- * @returns The JobNode representing the ETH to XL1 bridge job
- */
-export const createEthToXl1BridgeJob = async (
-  flowProducer: FlowProducer,
-  tx: SignedHydratedTransaction,
-) => {
-  const jobId = await PayloadBuilder.hash(tx[0])
-  const flow = await flowProducer.add({
-    // Step 0 (runs first as parent job)
-    name: EthToXl1BridgeParent.name,
-    queueName: EthToXl1BridgeParent.queueName,
-    data: { tx },
-    opts: { jobId },
-    children: [
-      {
-        // Step 4
-        name: Xl1TransactionMonitor.name,
-        queueName: Xl1TransactionMonitor.queueName,
-        data: { tx },
-        opts: {
-          jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
-        },
-        children: [
-          {
-            // Step 3
-            name: Xl1TransactionSubmissionStorage.name,
-            queueName: Xl1TransactionSubmissionStorage.queueName,
-            data: { tx },
-            opts: {
-              jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
-            },
-            children: [
-              {
-                // Step 2
-                name: Xl1TransactionSubmission.name,
-                queueName: Xl1TransactionSubmission.queueName,
-                data: { tx },
-                opts: { jobId },
-                children: [
-                  {
-                    // Step 1 (runs first as deepest child)
-                    name: Xl1TransactionPreparation.name,
-                    queueName: Xl1TransactionPreparation.queueName,
-                    data: { tx },
-                    opts: {
-                      jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
-                    },
-                  },
-                ],
-              },
-            ],
-          },
-        ],
-      },
-    ],
-  })
-  return flow
-}

package/src/queue/flows/createXl1ToEthBridgeJob/createXl1ToEthBridgeJob.ts

@@ -1,127 +0,0 @@
-import type { Payload } from '@xyo-network/sdk-js'
-import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
-import type { FlowProducer } from 'bullmq'
-
-import type {
-  EthTransactionMonitorJobData,
-  EthTransactionPreparationJobData,
-  EthTransactionSubmissionJobData,
-  EthTransactionSubmissionStorageJobData,
-  Xl1ToEthBridgeParentJobData,
-  Xl1TransactionMonitorJobData,
-  Xl1TransactionPreparationJobData,
-  Xl1TransactionSubmissionJobData,
-  Xl1TransactionSubmissionStorageJobData,
-} from '../../workers/index.ts'
-import {
-  EthTransactionMonitor, EthTransactionPreparation, EthTransactionSubmission, EthTransactionSubmissionStorage, Xl1ToEthBridgeParent, Xl1TransactionMonitor,
-  Xl1TransactionPreparation, Xl1TransactionSubmission, Xl1TransactionSubmissionStorage,
-} from '../../workers/index.ts'
-import { getJobIdForXl1ToEthBridgeJob } from './getJobIdForXl1ToEthBridgeJob.ts'
-
-/**
- * Creates a job flow for bridging a transaction from XL1 to Ethereum.
- * @param flowProducer The flow producer to run the job
- * @param tx The bridge transaction
- * @param offChainPayloads The payloads to put off chain
- * @returns The JobNode representing the XL1 to ETH bridge job
- */
-export const createXl1ToEthBridgeJob = async (
-  flowProducer: FlowProducer,
-  tx: SignedHydratedTransaction,
-  offChainPayloads: Payload[] = [],
-) => {
-  const jobId = await getJobIdForXl1ToEthBridgeJob(tx)
-  const flow = await flowProducer.add({
-    // Step 0 (runs first as parent job)
-    name: Xl1ToEthBridgeParent.name,
-    queueName: Xl1ToEthBridgeParent.queueName,
-    data: { tx, offChainPayloads } as Xl1ToEthBridgeParentJobData,
-    opts: { jobId },
-    children: [
-      {
-        // Step 8
-        name: EthTransactionMonitor.name,
-        queueName: EthTransactionMonitor.queueName,
-        data: { tx } as EthTransactionMonitorJobData,
-        opts: {
-          jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
-        },
-        children: [
-          {
-            // Step 7
-            name: EthTransactionSubmissionStorage.name,
-            queueName: EthTransactionSubmissionStorage.queueName,
-            data: { tx } as EthTransactionSubmissionStorageJobData,
-            opts: {
-              jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
-            },
-            children: [
-              {
-                // Step 6
-                name: EthTransactionSubmission.name,
-                queueName: EthTransactionSubmission.queueName,
-                data: { tx, offChainPayloads } as EthTransactionSubmissionJobData,
-                opts: { jobId },
-                children: [
-                  {
-                    // Step 5
-                    name: EthTransactionPreparation.name,
-                    queueName: EthTransactionPreparation.queueName,
-                    data: { tx, offChainPayloads } as EthTransactionPreparationJobData,
-                    opts: {
-                      jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
-                    },
-                    children: [
-                      {
-                        // Step 4
-                        name: Xl1TransactionMonitor.name,
-                        queueName: Xl1TransactionMonitor.queueName,
-                        data: { tx } as Xl1TransactionMonitorJobData,
-                        opts: {
-                          jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
-                        },
-                        children: [
-                          {
-                            // Step 3
-                            name: Xl1TransactionSubmissionStorage.name,
-                            queueName: Xl1TransactionSubmissionStorage.queueName,
-                            data: { tx } as Xl1TransactionSubmissionStorageJobData,
-                            opts: {
-                              jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
-                            },
-                            children: [
-                              {
-                                // Step 2
-                                name: Xl1TransactionSubmission.name,
-                                queueName: Xl1TransactionSubmission.queueName,
-                                data: { tx } as Xl1TransactionSubmissionJobData,
-                                opts: { jobId },
-                                children: [
-                                  {
-                                    // Step 1 (runs first as deepest child)
-                                    name: Xl1TransactionPreparation.name,
-                                    queueName: Xl1TransactionPreparation.queueName,
-                                    data: { tx, offChainPayloads } as Xl1TransactionPreparationJobData,
-                                    opts: {
-                                      jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
-                                    },
-                                  },
-                                ],
-                              },
-                            ],
-                          },
-                        ],
-                      },
-                    ],
-                  },
-                ],
-              },
-            ],
-          },
-        ],
-      },
-    ],
-  })
-  return flow
-}

package/src/queue/flows/createXl1ToEthBridgeJob/getJobIdForXl1ToEthBridgeJob.ts

@@ -1,18 +0,0 @@
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
-
-/**
- * Returns a deterministic & repeatable job ID based off the Transaction hash. This is to ensure
- * that if the same transaction is attempted to be bridged multiple times, it will have the same
- * job ID and not create duplicate jobs.
- * https://docs.bullmq.io/guide/jobs/job-ids
- * "The main reason to be able to specify a custom id is in cases when you want to avoid duplicated
- * jobs. Since ids must be unique, if you add a job with an existing id then that job will just be
- * ignored and not added to the queue at all."
- * @param tx The transaction to bridge from XL1 to ETH
- * @returns A deterministic job ID for the bridge job
- */
-export const getJobIdForXl1ToEthBridgeJob = async (tx: SignedHydratedTransaction) => {
-  const jobId = await PayloadBuilder.hash(tx[0])
-  return jobId
-}

package/src/queue/flows/createXl1ToEthBridgeJob/getXl1ToEthBridgeJob.ts

@@ -1,11 +0,0 @@
-import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
-import type { FlowProducer } from 'bullmq'
-
-import { Xl1ToEthBridgeParent } from '../../workers/index.ts'
-import { getJobIdForXl1ToEthBridgeJob } from './getJobIdForXl1ToEthBridgeJob.ts'
-
-export const getXl1ToEthBridgeJob = async (flowProducer: FlowProducer, tx: SignedHydratedTransaction) => {
-  const id = await getJobIdForXl1ToEthBridgeJob(tx)
-  const flow = await flowProducer.getFlow({ queueName: Xl1ToEthBridgeParent.queueName, id })
-  return flow
-}

package/src/queue/flows/createXl1ToEthBridgeJob/index.ts

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

package/src/queue/flows/index.ts

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

package/src/queue/getXl1ToEthQueueJobs.ts

@@ -1,57 +0,0 @@
-import type { Xl1ToEthQueues } from './getXl1ToEthQueues.ts'
-import type {
-  EthTransactionMonitorJob, EthTransactionPreparationJob,
-  EthTransactionSubmissionJob,
-  Xl1ToEthBridgeParentJob,
-  Xl1TransactionMonitorJob, Xl1TransactionPreparationJob, Xl1TransactionSubmissionJob,
-  Xl1TransactionSubmissionStorageJob,
-} from './workers/index.ts'
-
-export interface StatusQueueJobs {
-  ethTransactionMonitorJob?: EthTransactionMonitorJob
-  ethTransactionPreparationJob?: EthTransactionPreparationJob
-  ethTransactionSubmissionJob?: EthTransactionSubmissionJob
-  xl1ToEthBridgeParentJob?: Xl1ToEthBridgeParentJob
-  xl1TransactionMonitorJob?: Xl1TransactionMonitorJob
-  xl1TransactionPreparationJob?: Xl1TransactionPreparationJob
-  xl1TransactionSubmissionJob?: Xl1TransactionSubmissionJob
-  xl1TransactionSubmissionStorageJob?: Xl1TransactionSubmissionStorageJob
-}
-
-/**
- * Checks all the relevant status queues for a job with the given id and returns the jobs found in an object
- * @param queues The status queues to check for jobs
- * @param jobId The job id to look for in the queues, which is the same as the tx hash of the bridge transaction
- * @returns An object containing the jobs found in the status queues corresponding to the given job id
- */
-export const getStatusQueueJobs = async (queues: Xl1ToEthQueues, jobId: string): Promise<StatusQueueJobs> => {
-  const [
-    ethTransactionMonitorJob,
-    ethTransactionPreparationJob,
-    ethTransactionSubmissionJob,
-    xl1ToEthBridgeParentJob,
-    xl1TransactionMonitorJob,
-    xl1TransactionPreparationJob,
-    xl1TransactionSubmissionJob,
-    xl1TransactionSubmissionStorageJob,
-  ] = await Promise.all([
-    queues.ethTransactionMonitor.getJob(jobId),
-    queues.ethTransactionPreparation.getJob(jobId),
-    queues.ethTransactionSubmission.getJob(jobId),
-    queues.xl1ToEthBridgeParent.getJob(jobId),
-    queues.xl1TransactionMonitor.getJob(jobId),
-    queues.xl1TransactionPreparation.getJob(jobId),
-    queues.xl1TransactionSubmission.getJob(jobId),
-    queues.xl1TransactionSubmissionStorage.getJob(jobId),
-  ])
-  return {
-    ethTransactionMonitorJob,
-    ethTransactionPreparationJob,
-    ethTransactionSubmissionJob,
-    xl1ToEthBridgeParentJob,
-    xl1TransactionMonitorJob,
-    xl1TransactionPreparationJob,
-    xl1TransactionSubmissionStorageJob,
-    xl1TransactionSubmissionJob,
-  }
-}

package/src/queue/getXl1ToEthQueues.ts

@@ -1,39 +0,0 @@
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import { Queue } from 'bullmq'
-
-import { getConnection } from './connection.ts'
-import { prefix } from './prefix.ts'
-import {
-  EthTransactionMonitor, EthTransactionPreparation, EthTransactionSubmission, Xl1ToEthBridgeParent, Xl1TransactionMonitor, Xl1TransactionPreparation,
-  Xl1TransactionSubmission,
-  Xl1TransactionSubmissionStorage,
-} from './workers/index.ts'
-
-export interface Xl1ToEthQueues {
-  ethTransactionMonitor: Queue
-  ethTransactionPreparation: Queue
-  ethTransactionSubmission: Queue
-  xl1ToEthBridgeParent: Queue
-  xl1TransactionMonitor: Queue
-  xl1TransactionPreparation: Queue
-  xl1TransactionSubmission: Queue
-  xl1TransactionSubmissionStorage: Queue
-}
-
-let xl1ToEthQueues: Xl1ToEthQueues | undefined
-
-export const getXl1ToEthQueues = (config: BridgeConfig): Xl1ToEthQueues => {
-  if (xl1ToEthQueues) return xl1ToEthQueues
-  const connection = getConnection(config)
-  xl1ToEthQueues = {
-    ethTransactionMonitor: new Queue(EthTransactionMonitor.queueName, { connection, prefix }),
-    ethTransactionPreparation: new Queue(EthTransactionPreparation.queueName, { connection, prefix }),
-    ethTransactionSubmission: new Queue(EthTransactionSubmission.queueName, { connection, prefix }),
-    xl1ToEthBridgeParent: new Queue(Xl1ToEthBridgeParent.queueName, { connection, prefix }),
-    xl1TransactionMonitor: new Queue(Xl1TransactionMonitor.queueName, { connection, prefix }),
-    xl1TransactionPreparation: new Queue(Xl1TransactionPreparation.queueName, { connection, prefix }),
-    xl1TransactionSubmission: new Queue(Xl1TransactionSubmission.queueName, { connection, prefix }),
-    xl1TransactionSubmissionStorage: new Queue(Xl1TransactionSubmissionStorage.queueName, { connection, prefix }),
-  }
-  return xl1ToEthQueues
-}

package/src/queue/index.ts

@@ -1,8 +0,0 @@
-export * from './connection.ts'
-export * from './flowProducer.ts'
-export * from './flows/index.ts'
-export * from './getXl1ToEthQueueJobs.ts'
-export * from './getXl1ToEthQueues.ts'
-export * from './prefix.ts'
-export * from './telemetry.ts'
-export * from './workers/index.ts'

package/src/queue/prefix.ts

@@ -1 +0,0 @@
-export const prefix = 'xl1-bridge'

package/src/queue/telemetry.ts

@@ -1,12 +0,0 @@
-import { isDefined } from '@xylabs/sdk-js'
-import type { BullMQOtelOptions } from 'bullmq-otel'
-import { BullMQOtel } from 'bullmq-otel'
-
-let telemetry: BullMQOtel | undefined
-const options: BullMQOtelOptions = { enableMetrics: true }
-
-export const getTelemetry = () => {
-  if (isDefined(telemetry)) return telemetry
-  telemetry = new BullMQOtel(options)
-  return telemetry
-}

package/src/queue/workers/EthToXl1BridgeParent.ts

@@ -1,40 +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'
-
-export type EthToXl1BridgeParentJobData = {}
-export interface EthToXl1BridgeParentJobReturn { }
-export type EthToXl1BridgeParentJob = Job<EthToXl1BridgeParentJobData, EthToXl1BridgeParentJobReturn>
-
-const name = 'Bridge Ethereum to XL1'
-const queueName = 'eth-to-xl1-bridge'
-const createWorker = (connection: Redis, telemetry?: BullMQOtel) => {
-  const worker = new Worker(
-    queueName,
-    async (job: EthToXl1BridgeParentJob) => {
-      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 EthToXl1BridgeParent: WorkerDescription = {
-  createWorker, name, queueName,
-}

package/src/queue/workers/EthTransactionMonitor.ts

@@ -1,59 +0,0 @@
-import { assertEx } 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 } from '../../services/index.ts'
-import { prefix } from '../prefix.ts'
-import type { WorkerDescription } from './WorkerDescription.ts'
-import type { Xl1TransactionJobData } from './Xl1TransactionJobData.ts'
-
-export type EthTransactionMonitorJobData = Xl1TransactionJobData
-export interface EthTransactionMonitorJobReturn {
-  blockHash: string
-  blockNumber: number
-  submissionHash: string
-}
-export type EthTransactionMonitorJob = Job<EthTransactionMonitorJobData, EthTransactionMonitorJobReturn>
-
-const name = 'Monitor Submitted ETH Transaction'
-const queueName = 'eth-tx-monitor'
-const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBridgeServiceCollection) => {
-  const provider = assertEx(services?.provider, () => 'provider service not provided')
-  const stateMap = assertEx(services?.ethTxStateMap, () => 'ethTxStateMap service not provided')
-
-  const worker = new Worker(
-    queueName,
-    async (job: EthTransactionMonitorJob) => {
-      const { 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, 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 EthTransactionMonitor: WorkerDescription = {
-  createWorker, name, queueName,
-}

package/src/queue/workers/EthTransactionPreparation.ts

@@ -1,83 +0,0 @@
-import { assertEx, hexToBigInt } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import { isBridgeIntent } 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 {
-  validateSufficientLiquiditySourceAllowance, validateSufficientLiquiditySourceBalance, validateSufficientRunnerEthBalanceForGas,
-} from '../../validation/index.ts'
-import { prefix } from '../prefix.ts'
-import type { WorkerDescription } from './WorkerDescription.ts'
-import type { Xl1DataLakeTransactionJobData } from './Xl1TransactionJobData.ts'
-
-export type EthTransactionPreparationJobData = Xl1DataLakeTransactionJobData
-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, 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: EthTransactionPreparationJob) => {
-      const { tx, offChainPayloads } = 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 validateSufficientLiquiditySourceAllowance(tx, offChainPayloads, 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 validateSufficientLiquiditySourceBalance(tx, offChainPayloads, 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`)
-      await job.log(`[${hash}] building ETH transaction`)
-      const allPayloads = [...tx[1], ...offChainPayloads]
-      const bridgeIntent = assertEx(allPayloads.find(isBridgeIntent), () => 'No bridge intent found')
-      const amount = hexToBigInt(bridgeIntent.destAmount)
-      const srcAddress = getAddress(bridgeIntent.srcAddress)
-      const destAddress = getAddress(bridgeIntent.destAddress)
-      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, 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 EthTransactionPreparation: WorkerDescription = {
-  createWorker, name, queueName,
-}

package/src/queue/workers/EthTransactionSubmission.ts

@@ -1,63 +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 { submitEthTransaction } from './util/index.ts'
-import type { WorkerDescription } from './WorkerDescription.ts'
-import type { Xl1DataLakeTransactionJobData } from './Xl1TransactionJobData.ts'
-
-export type EthTransactionSubmissionJobData = Xl1DataLakeTransactionJobData
-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, telemetry?: BullMQOtel, services?: IBridgeServiceCollection) => {
-  const bridge = assertEx(services?.bridge, () => 'bridge service not provided')
-  const wallet = assertEx(services?.wallet, () => 'wallet service not provided')
-  const stateMap = assertEx(services?.ethTxStateMap, () => 'ethTxStateMap service not provided')
-
-  const worker = new Worker(
-    queueName,
-    async (job: EthTransactionSubmissionJob) => {
-      const { tx, offChainPayloads } = job.data
-      const hash = await PayloadBuilder.hash(tx[0])
-      const state = assertEx(await stateMap.get(hash), () => `[${hash}] state 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 submissionHash = assertEx(await submitEthTransaction(tx, offChainPayloads, bridge, wallet), () => `[${hash}] submissionHash not found in receipt`)
-      await job.log(`[${hash}] Submitted ETH tx and received submission response hash ${submissionHash}`)
-      return { submissionHash }
-    },
-    {
-      connection, telemetry, concurrency: 1, 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 EthTransactionSubmission: WorkerDescription = {
-  createWorker, name, queueName,
-}