@xyo-network/chain-bridge 1.20.15 → 1.20.16

package/src/interface/service/Relay/ChainBridgeRelay/ChainBridgeRelayService.ts

@@ -1,116 +0,0 @@
-import { assertEx, isNull } from '@xylabs/sdk-js'
-import type { BridgeDestinationObservation, BridgeIntent } from '@xyo-network/xl1-sdk'
-import { AbstractCreatableProvider } from '@xyo-network/xl1-sdk'
-
-import type {
-  BridgeDestinationObservationIndexerInterface, BridgeIntentIndexerInterface,
-  BridgeServiceParams,
-  BridgeSourceObservationIndexerInterface, ChainBridgeRelayInterface, LockingBridgeIntentProcessorInterface,
-  UnlockingBridgeIntentProcessorInterface,
-} from '../../../interface/index.ts'
-
-export class ChainBridgeRelayService<TParams extends BridgeServiceParams = BridgeServiceParams>
-  extends AbstractCreatableProvider<TParams> implements ChainBridgeRelayInterface {
-  moniker = 'ChainBridgeRelayService'
-  protected get account() {
-    return assertEx(this.params.account, () => 'account is required')
-  }
-
-  protected get destinationObservations(): BridgeDestinationObservationIndexerInterface {
-    return assertEx(this.params.destinationObservations, () => 'destinationObservations is required')
-  }
-
-  protected get destinationRelay(): ChainBridgeRelayInterface {
-    return assertEx(this.params.destinationRelay, () => 'destinationRelay is required')
-  }
-
-  protected get intentProcessed(): LockingBridgeIntentProcessorInterface {
-    return assertEx(this.params.intentProcessed, () => 'intentProcessed is required')
-  }
-
-  protected get intentProcessing(): UnlockingBridgeIntentProcessorInterface {
-    return assertEx(this.params.intentProcessing, () => 'intentProcessing is required')
-  }
-
-  protected get intentResourceAccess(): BridgeIntentIndexerInterface {
-    return assertEx(this.params.intents, () => 'intents is required')
-  }
-
-  protected get sourceObservations(): BridgeSourceObservationIndexerInterface {
-    return assertEx(this.params.sourceObservations, () => 'sourceObservations is required')
-  }
-
-  /**
-   * Begins the relay process for a given BridgeIntent.
-   * @param bridgeIntent The bridgeIntent to begin relaying
-   * @returns True if the relay was started, false otherwise
-   */
-  async beginRelay(bridgeIntent: BridgeIntent): Promise<boolean> {
-    try {
-      // Ensure source observation exists
-      const bridgeSourceObservation = await this.sourceObservations.getObservationForIntent(bridgeIntent)
-      if (!isNull(bridgeSourceObservation)) {
-        const canProcess = await this.intentProcessing.lock(this.account.address, bridgeIntent)
-        if (canProcess) {
-          await this.destinationRelay.beginRelay(bridgeIntent)
-          return true
-        }
-      }
-    } catch {
-      await this.intentProcessing.unlock(this.account.address, bridgeIntent)
-    }
-    return false
-  }
-
-  /**
-   * Handles a BridgeDestinationObservation.
-   * @param bridgeDestinationObservation The BridgeDestinationObservation to process
-   * @returns True if the observation was processed as a completion for an outstanding relay, false otherwise
-   */
-  async onDestinationObservation(bridgeDestinationObservation: BridgeDestinationObservation): Promise<boolean> {
-    // Ensure intent exists
-    const bridgeIntent = await this.destinationObservations.getIntentForObservation(bridgeDestinationObservation)
-    if (!isNull(bridgeIntent)) {
-      // Ensure not already processed
-      const processed = await this.intentProcessed.isLocked(bridgeIntent)
-      if (isNull(processed)) {
-        // Ensure we are the processor
-        const processor = await this.intentProcessing.isLocked(bridgeIntent)
-        if (!isNull(processor) && processor === this.account.address) {
-          // Mark as completed
-          await this.intentProcessed.lock(this.account.address, bridgeIntent)
-          await this.intentProcessing.unlock(this.account.address, bridgeIntent)
-          return true
-        }
-      }
-    }
-    return false
-  }
-
-  /**
-   * Relays a given BridgeIntent.
-   * @param bridgeIntent The BridgeIntent to relay
-   * @returns Relays the intent in a blocking manner, returning the resulting BridgeDestinationObservation if successful
-   */
-  async relaySync(bridgeIntent: BridgeIntent): Promise<BridgeDestinationObservation | null> {
-    let canProcess = isNull(await this.intentProcessing.isLocked(bridgeIntent))
-    try {
-      canProcess = await this.intentProcessing.lock(this.account.address, bridgeIntent)
-      if (canProcess) {
-        const result = await this.destinationRelay.relaySync(bridgeIntent)
-        if (!isNull(result)) {
-          // TODO: How to handle partial success here where relay succeeded but we didn't record result successfully?
-          // Prefer async observer pattern instead?
-          await this.destinationObservations.addObservation(result, bridgeIntent)
-          await this.intentProcessed.lock(this.account.address, bridgeIntent)
-          return result
-        }
-      }
-    } finally {
-      if (!isNull(bridgeIntent)) {
-        await this.intentProcessing.unlock(this.account.address, bridgeIntent)
-      }
-    }
-    return null
-  }
-}

package/src/interface/service/Relay/ChainBridgeRelay/index.ts

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

package/src/interface/service/Relay/LiquidityPoolBridgeRelay/LiquidityPoolBridgeRelay.ts

@@ -1,227 +0,0 @@
-import type { Address, Hex } from '@xylabs/sdk-js'
-import {
-  asHex, assertEx, hexFromBigInt, hexToBigInt, isNull,
-  toAddress,
-} from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { LiquidityPoolBridge } from '@xyo-network/typechain'
-import { LiquidityPoolBridge__factory } from '@xyo-network/typechain'
-import { AbstractCreatableProvider } from '@xyo-network/xl1-sdk'
-import {
-  type BridgeDestinationObservation, BridgeDestinationObservationSchema, type BridgeIntent,
-} from '@xyo-network/xl1-sdk'
-import type { WebSocketProvider } from 'ethers'
-import { getAddress, Wallet } from 'ethers'
-
-import type {
-  BridgeDestinationObservationIndexerInterface, BridgeIntentIndexerInterface, BridgeServiceParams, BridgeSourceObservationIndexerInterface,
-  ChainBridgeRelayInterface, LockingBridgeIntentProcessorInterface, UnlockingBridgeIntentProcessorInterface,
-} from '../../../interface/index.ts'
-
-export type LiquidityPoolBridgeRelayParams = BridgeServiceParams & {
-  /**
-   * The address to watch for incoming or outgoing ERC-20 token transfers.
-   */
-  bridgeAddress: string
-  /**
-   * An ethers.js WebSocketProvider connected to the Ethereum network to monitor for ERC-20 transfers.
-   */
-  provider: WebSocketProvider
-}
-
-export class LiquidityPoolBridgeRelay<TParams extends LiquidityPoolBridgeRelayParams = LiquidityPoolBridgeRelayParams>
-  extends AbstractCreatableProvider<TParams> implements ChainBridgeRelayInterface {
-  moniker = 'LiquidityPoolBridgeRelay'
-  protected _bridge: LiquidityPoolBridge | undefined
-  protected _bridgeChainId: Hex | undefined
-  protected _bridgeRemoteChainId: Hex | undefined
-  protected _bridgeTokenAddress: Address | undefined
-  protected _wallet: Wallet | undefined
-
-  protected get account() {
-    return assertEx(this.params.account, () => 'account is required')
-  }
-
-  protected get bridge(): LiquidityPoolBridge {
-    return assertEx(this._bridge, () => new Error('Bridge contract not initialized'))
-  }
-
-  protected get bridgeChainId(): Hex {
-    return assertEx(this._bridgeChainId, () => new Error('Bridge chain ID not initialized'))
-  }
-
-  protected get bridgeRemoteChainId(): Hex {
-    return assertEx(this._bridgeRemoteChainId, () => new Error('Bridge remote chain ID not initialized'))
-  }
-
-  protected get bridgeTokenAddress(): Address {
-    return assertEx(this._bridgeTokenAddress, () => new Error('Bridge token address not initialized'))
-  }
-
-  protected get destinationObservations(): BridgeDestinationObservationIndexerInterface {
-    return assertEx(this.params.destinationObservations, () => 'destinationObservations is required')
-  }
-
-  protected get destinationRelay(): ChainBridgeRelayInterface {
-    return assertEx(this.params.destinationRelay, () => 'destinationRelay is required')
-  }
-
-  protected get intentProcessed(): LockingBridgeIntentProcessorInterface {
-    return assertEx(this.params.intentProcessed, () => 'intentProcessed is required')
-  }
-
-  protected get intentProcessing(): UnlockingBridgeIntentProcessorInterface {
-    return assertEx(this.params.intentProcessing, () => 'intentProcessing is required')
-  }
-
-  protected get intentResourceAccess(): BridgeIntentIndexerInterface {
-    return assertEx(this.params.intents, () => 'intents is required')
-  }
-
-  protected get provider(): WebSocketProvider {
-    return assertEx(this.params.provider, () => new Error('Provider not initialized'))
-  }
-
-  protected get sourceObservations(): BridgeSourceObservationIndexerInterface {
-    return assertEx(this.params.sourceObservations, () => 'sourceObservations is required')
-  }
-
-  protected get wallet(): Wallet {
-    return assertEx(this._wallet, () => 'wallet is required')
-  }
-
-  /**
-   * Begins the relay process for a given BridgeIntent.
-   * @param bridgeIntent The bridgeIntent to begin relaying
-   * @returns True if the relay was started, false otherwise
-   */
-  async beginRelay(bridgeIntent: BridgeIntent): Promise<boolean> {
-    try {
-      // Ensure source observation exists
-      const bridgeSourceObservation = await this.sourceObservations.getObservationForIntent(bridgeIntent)
-      if (!isNull(bridgeSourceObservation)) {
-        const canProcess = await this.intentProcessing.lock(this.account.address, bridgeIntent)
-        if (canProcess) {
-          const amount = hexToBigInt(bridgeIntent.destAmount)
-          const nonce = await this.wallet.getNonce()
-          await this.bridge.bridgeFromRemote(
-            getAddress(bridgeIntent.srcAddress),
-            getAddress(bridgeIntent.destAddress),
-            amount,
-            nonce,
-          )
-          return true
-        }
-      }
-    } catch (error) {
-      console.error('Error occurred while beginning relay:', error)
-      await this.intentProcessing.unlock(this.account.address, bridgeIntent)
-    }
-    return false
-  }
-
-  override async createHandler() {
-    const { provider, bridgeAddress } = this.params
-
-    // Connect to the bridge contract
-    // Create a wallet bound to the provider (signer + provider)
-    const key = assertEx(this.account?.private?.hex, () => new Error('Account private key is required'))
-    this._wallet = new Wallet(key, provider)
-    this._bridge = LiquidityPoolBridge__factory.connect(getAddress(bridgeAddress), this._wallet)
-
-    // Parse bridge network chain ID
-    const network = await provider.getNetwork()
-    this._bridgeChainId = assertEx(hexFromBigInt(network.chainId), () => new Error('Failed to parse bridgeChainId'))
-
-    // Parse bridge token address
-    const tokenAddress = await this.bridge.token()
-    this._bridgeTokenAddress = toAddress(tokenAddress)
-
-    // Parse bridge remote chain ID
-    const bridgeRemoteChain = await this.bridge.remoteChain()
-    this._bridgeRemoteChainId = asHex(bridgeRemoteChain)
-
-    await this.bridge.on(this.bridge.getEvent('BridgedFromRemote'), (id, from, to, amount, remoteChain, args) => {
-      const txHash = args.transactionHash
-      const destConfirmation = asHex(txHash)
-      const observation: BridgeDestinationObservation = new PayloadBuilder<BridgeDestinationObservation>({ schema: BridgeDestinationObservationSchema })
-        .fields({
-          src: this.bridgeRemoteChainId,
-          dest: this.bridgeChainId,
-          srcAddress: toAddress(from),
-          destAddress: toAddress(to),
-          srcToken: this.bridgeTokenAddress,
-          destToken: this.bridgeTokenAddress,
-          srcAmount: amount.toString(),
-          destAmount: amount.toString(),
-          destConfirmation,
-        }).build()
-      this.onDestinationObservation(observation).catch(console.error)
-    })
-  }
-
-  /**
-   * Handles a BridgeDestinationObservation.
-   * @param bridgeDestinationObservation The BridgeDestinationObservation to process
-   * @returns True if the observation was processed as a completion for an outstanding relay, false otherwise
-   */
-  async onDestinationObservation(bridgeDestinationObservation: BridgeDestinationObservation): Promise<boolean> {
-    // Ensure intent exists
-    const bridgeIntent = await this.destinationObservations.getIntentForObservation(bridgeDestinationObservation)
-    if (!isNull(bridgeIntent)) {
-      // Ensure not already processed
-      const processed = await this.intentProcessed.isLocked(bridgeIntent)
-      if (isNull(processed)) {
-        // Ensure we are the processor
-        const processor = await this.intentProcessing.isLocked(bridgeIntent)
-        if (!isNull(processor) && processor === this.account.address) {
-          // Mark as completed
-          await this.intentProcessed.lock(this.account.address, bridgeIntent)
-          await this.intentProcessing.unlock(this.account.address, bridgeIntent)
-          return true
-        }
-      }
-    }
-    return false
-  }
-
-  /**
-   * Relays a given BridgeIntent.
-   * @param bridgeIntent The BridgeIntent to relay
-   * @returns Relays the intent in a blocking manner, returning the resulting BridgeDestinationObservation if successful
-   */
-  async relaySync(bridgeIntent: BridgeIntent): Promise<BridgeDestinationObservation | null> {
-    // Ensure source observation exists
-    const bridgeSourceObservation = await this.sourceObservations.getObservationForIntent(bridgeIntent)
-    if (!isNull(bridgeSourceObservation)) {
-      let canProcess = isNull(await this.intentProcessing.isLocked(bridgeIntent))
-      try {
-        canProcess = await this.intentProcessing.lock(this.account.address, bridgeIntent)
-        if (canProcess) {
-          const amount = hexToBigInt(bridgeIntent.destAmount)
-          const nonce = await this.wallet.getNonce()
-          const tx = await this.bridge.bridgeFromRemote(
-            getAddress(bridgeIntent.srcAddress),
-            getAddress(bridgeIntent.destAddress),
-            amount,
-            nonce,
-          )
-          const confirmation = await tx.wait()
-          const transactionResponse = await confirmation?.getTransaction()
-          const destConfirmation = asHex(transactionResponse?.hash ?? '')
-          const { schema, ...rest } = bridgeIntent
-          const result: BridgeDestinationObservation = new PayloadBuilder<BridgeDestinationObservation>({ schema: BridgeDestinationObservationSchema })
-            .fields({ ...rest, destConfirmation }).build()
-          await this.destinationObservations.addObservation(result, bridgeIntent)
-          await this.intentProcessed.lock(this.account.address, bridgeIntent)
-          return result
-        }
-      } finally {
-        if (!isNull(bridgeIntent)) {
-          await this.intentProcessing.unlock(this.account.address, bridgeIntent)
-        }
-      }
-    }
-    return null
-  }
-}

package/src/interface/service/Relay/LiquidityPoolBridgeRelay/index.ts

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

package/src/interface/service/Relay/index.ts

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

package/src/interface/service/index.ts

@@ -1,2 +0,0 @@
-export * from './Observer/index.ts'
-export * from './Relay/index.ts'

package/src/interface/util/getBridgeIntentIdentifier.ts

@@ -1,18 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import {
-  type BridgeDestinationObservation, type BridgeIntent, BridgeIntentSchema, type BridgeSourceObservation,
-} from '@xyo-network/xl1-sdk'
-
-export const getBridgeIntentFromObservation = (observation: BridgeSourceObservation | BridgeDestinationObservation, nonce: string): BridgeIntent => {
-  const {
-    src, srcAddress, srcAmount, srcToken, dest, destAddress, destAmount, destToken,
-  } = observation
-  return new PayloadBuilder<BridgeIntent>({ schema: BridgeIntentSchema }).fields({
-    src, srcAddress, srcAmount, srcToken, dest, destAddress, destAmount, destToken, nonce,
-  }).build()
-}
-
-export const getBridgeIntentIdentifier = async (bridgeIntent: BridgeIntent): Promise<Hash> => {
-  return await PayloadBuilder.hash(bridgeIntent)
-}

package/src/interface/util/index.ts

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

package/src/modules/EVMLiquidityBridgeTransactionCompletionMonitorSentinel/EVMLiquidityBridgeTransactionCompletionMonitorSentinel.ts

@@ -1,235 +0,0 @@
-import type { Attributes, Counter } from '@opentelemetry/api'
-import type {
-  Address, Hash, Hex,
-} from '@xylabs/sdk-js'
-import {
-  asAddress, asHex, assertEx, delay, hexFromBigInt, hexToBigInt, isDefined, isUndefined,
-} from '@xylabs/sdk-js'
-import type {
-  AnyConfigSchema, Payload,
-  SentinelConfig, SentinelInstance, SentinelModuleEventData, SentinelParams,
-} from '@xyo-network/sdk-js'
-import {
-  AbstractSentinel, asSchema, PayloadBuilder,
-} from '@xyo-network/sdk-js'
-import { type LiquidityPoolBridge, LiquidityPoolBridge__factory } from '@xyo-network/typechain'
-import type {
-  BridgeDestinationObservation, BridgeIntent, IterableMap, MapType,
-  SignedHydratedTransaction,
-} from '@xyo-network/xl1-sdk'
-import {
-  BridgeDestinationObservationSchema, flattenHydratedTransaction, flattenHydratedTransactions, isBridgeIntent,
-  tryUnflattenHydratedTransaction,
-} from '@xyo-network/xl1-sdk'
-import { Mutex } from 'async-mutex'
-import { getAddress } from 'ethers/address'
-import type { Provider } from 'ethers/providers'
-import { Wallet } from 'ethers/wallet'
-
-export const EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema
-  = asSchema('network.xyo.sentinel.chain.evm.liquidity.bridge.transaction.completion.monitor.config', true)
-export type EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema = typeof EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema
-
-/**
- * The configuration for the sentinel
- */
-export type EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfig = SentinelConfig<{
-  /**
-   * The interval in milliseconds between checking for jobs to fulfill
-   */
-  jobCheckInterval: number
-
-  /**
-   * The schema for the sentinel config
-   */
-  schema: EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema
-}>
-
-interface EVMLiquidityBridgeTransactionCompletionMonitorSentinelParamFields {
-  /**
-   * The address to watch for incoming or outgoing ERC-20 token transfers.
-   */
-  bridgeAddress: string
-
-  /**
-   * The map of completed transactions to monitor for completion
-   */
-  completedTransactions: MapType<Hash, BridgeDestinationObservation>
-
-  /**
-   * The map of pending transactions to monitor for completion
-   */
-  pendingTransactions: IterableMap<Hash, SignedHydratedTransaction>
-
-  /**
-   * An ethers.js Provider connected to the Ethereum network to monitor for ERC-20 transfers.
-   */
-  provider: Provider
-}
-
-export type EVMLiquidityBridgeTransactionCompletionMonitorSentinelParams<TConfig extends
-AnyConfigSchema<EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfig> = AnyConfigSchema<EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfig>,
-> = SentinelParams<TConfig> & EVMLiquidityBridgeTransactionCompletionMonitorSentinelParamFields
-
-const defaultJobCheckIntervalMs = 15_000
-
-export class EVMLiquidityBridgeTransactionCompletionMonitorSentinel<
-  TParams extends EVMLiquidityBridgeTransactionCompletionMonitorSentinelParams = EVMLiquidityBridgeTransactionCompletionMonitorSentinelParams,
-  TEventData extends SentinelModuleEventData<SentinelInstance<TParams>> = SentinelModuleEventData<SentinelInstance<TParams>>,
-> extends AbstractSentinel<TParams, TEventData> {
-  static override readonly configSchemas = [EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema]
-  static override readonly defaultConfigSchema = EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema
-  protected _attemptsCounter: Counter<Attributes> | undefined
-  protected _bridge: LiquidityPoolBridge | undefined
-  protected _bridgeChainId: Hex | undefined
-  protected _bridgeRemoteChainId: Hex | undefined
-  protected _bridgeTokenAddress: Address | undefined
-  protected _checkCounter: Counter<Attributes> | undefined
-  protected _errorCounter: Counter<Attributes> | undefined
-  protected _reportMutex = new Mutex()
-  protected _successCounter: Counter<Attributes> | undefined
-  protected _wallet: Wallet | undefined
-
-  protected get bridge(): LiquidityPoolBridge {
-    return assertEx(this._bridge, () => new Error('Bridge contract not initialized'))
-  }
-
-  protected get completedTransactions(): MapType<Hash, BridgeDestinationObservation> {
-    return assertEx(this.params.completedTransactions, () => 'Completed transactions map is not defined')
-  }
-
-  protected get jobCheckInterval(): number {
-    return isDefined(this.config.jobCheckInterval) ? this.config.jobCheckInterval : defaultJobCheckIntervalMs
-  }
-
-  protected get pendingTransactions(): IterableMap<Hash, SignedHydratedTransaction> {
-    return assertEx(this.params.pendingTransactions, () => 'Pending transactions map is not defined')
-  }
-
-  protected get wallet(): Wallet {
-    return assertEx(this._wallet, () => 'wallet is required')
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    // Create meters for tracking bridge attempts, successes, and errors.
-    this._attemptsCounter = this.meter?.createCounter(
-      'evm_liquidity_bridge_transaction_completion_monitor_sentinel_attempts_total',
-      { description: 'Number of attempts' },
-    )
-    this._checkCounter = this.meter?.createCounter(
-      'evm_liquidity_bridge_transaction_completion_monitor_sentinel_check_total',
-      { description: 'Number of checks' },
-    )
-    this._successCounter = this.meter?.createCounter(
-      'evm_liquidity_bridge_transaction_completion_monitor_sentinel_success_total',
-      { description: 'Number of successes' },
-    )
-    this._errorCounter = this.meter?.createCounter(
-      'evm_liquidity_bridge_transaction_completion_monitor_sentinel_errors_total',
-      { description: 'Number of errors' },
-    )
-    const { provider, bridgeAddress } = this.params
-
-    // Connect to the bridge contract
-    // Create a wallet bound to the provider (signer + provider)
-    const key = assertEx(this.account?.private?.hex, () => new Error('Account private key is required'))
-    this._wallet = new Wallet(key, provider)
-    this._bridge = LiquidityPoolBridge__factory.connect(getAddress(bridgeAddress), this._wallet)
-
-    // Parse bridge network chain ID
-    const network = await provider.getNetwork()
-    this._bridgeChainId = assertEx(hexFromBigInt(network.chainId), () => new Error('Failed to parse bridgeChainId'))
-
-    // Parse bridge token address
-    const tokenAddress = await this.bridge.token()
-    this._bridgeTokenAddress = asAddress(tokenAddress, true)
-
-    // Parse bridge remote chain ID
-    const bridgeRemoteChain = await this.bridge.remoteChain()
-    this._bridgeRemoteChainId = asHex(bridgeRemoteChain)
-  }
-
-  override async reportHandler(payloads?: Payload[]): Promise<Payload[]> {
-    if (isDefined(payloads) && payloads.length > 0) {
-      const signedHydratedTransaction = tryUnflattenHydratedTransaction(payloads)
-      if (isDefined(signedHydratedTransaction)) {
-        // Insert into pending transactions for monitoring
-        const txHash = await PayloadBuilder.hash(signedHydratedTransaction[0])
-        this.logger?.info(`Adding transaction ${signedHydratedTransaction[0]} with hash ${txHash} to pending transactions for monitoring`)
-        await this.pendingTransactions.set(txHash, signedHydratedTransaction)
-        return flattenHydratedTransaction(signedHydratedTransaction)
-      }
-      return []
-    } else {
-      if (this._reportMutex.isLocked()) {
-        this.logger?.debug(`EVMLiquidityBridgeTransactionCompletionMonitorSentinel [${this.id}] is already running, skipping report [${Date.now()}]`)
-        return []
-      }
-      return await this._reportMutex.runExclusive(async () => {
-        const response: Payload[] = []
-        if (isUndefined(payloads) || payloads.length === 0) {
-          await this.processAllTransactions()
-        }
-        return response
-      })
-    }
-  }
-
-  private async processAllTransactions(): Promise<Payload[]> {
-    const results: SignedHydratedTransaction[] = []
-    for await (const [hash, signedHydratedTransaction] of this.pendingTransactions) {
-      const result = await this.processTransaction([hash, signedHydratedTransaction])
-      if (isDefined(result)) results.push(result[1])
-      await delay(this.jobCheckInterval)
-    }
-    return flattenHydratedTransactions(results)
-  }
-
-  private async processTransaction(
-    [hash, signedHydratedTransaction]: [Hash, SignedHydratedTransaction],
-  ): Promise<[Hash, SignedHydratedTransaction] | undefined> {
-    this.logger?.info(`Checking for transaction ${signedHydratedTransaction[0]} with hash ${hash}`)
-    try {
-      let ret: [Hash, SignedHydratedTransaction] | undefined = undefined
-      this._checkCounter?.add(1)
-      const bridgeIntents = signedHydratedTransaction[1].filter(isBridgeIntent)
-      // Only support a single intent per transaction for now
-      if (bridgeIntents.length !== 1) {
-        await this.pendingTransactions.delete(hash)
-        return ret
-      }
-      const bridgeIntent = bridgeIntents[0]
-      this._attemptsCounter?.add(1)
-      const bridgeDestinationObservation = await this.relayBridgeIntentSync(bridgeIntent)
-      await this.completedTransactions.set(hash, bridgeDestinationObservation)
-      await this.pendingTransactions.delete(hash)
-      this._successCounter?.add(1)
-      return ret
-    } catch (error) {
-      this._errorCounter?.add(1)
-      this.logger?.error(`Error checking for transaction ${signedHydratedTransaction[0]} with hash ${hash}:`, error)
-    }
-  }
-
-  /**
-   * Relays a given BridgeIntent.
-   * @param bridgeIntent The BridgeIntent to relay
-   * @returns Relays the intent in a blocking manner, returning the resulting BridgeDestinationObservation if successful
-   */
-  private async relayBridgeIntentSync(bridgeIntent: BridgeIntent): Promise<BridgeDestinationObservation> {
-    // Ensure source observation exists
-    const amount = hexToBigInt(bridgeIntent.destAmount)
-    const nonce = await this.wallet.getNonce()
-    const srcAddress = getAddress(bridgeIntent.srcAddress)
-    const destAddress = getAddress(bridgeIntent.destAddress)
-    const tx = await this.bridge.bridgeFromRemote(srcAddress, destAddress, amount, nonce)
-    const confirmation = await tx.wait()
-    const transactionResponse = await confirmation?.getTransaction()
-    const destConfirmation = asHex(transactionResponse?.hash ?? '', true)
-    const { schema, ...rest } = bridgeIntent
-    const result: BridgeDestinationObservation = new PayloadBuilder<BridgeDestinationObservation>({ schema: BridgeDestinationObservationSchema })
-      .fields({ ...rest, destConfirmation }).build()
-    return result
-  }
-}

package/src/modules/EVMLiquidityBridgeTransactionCompletionMonitorSentinel/index.ts

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

package/src/modules/index.ts

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

package/src/queue/connection.ts

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

package/src/queue/flowProducer.ts

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