@xyo-network/chain-bridge 1.17.2 → 1.17.3

package/src/manifest/getLocator.ts

@@ -1,26 +1,32 @@
 import { BaseMongoSdk, type BaseMongoSdkPrivateConfig } from '@xylabs/mongo'
 import type { Hash, Logger } from '@xylabs/sdk-js'
-import {
-  asAddress, assertEx, isDefined,
-  ZERO_ADDRESS,
-} from '@xylabs/sdk-js'
+import { assertEx, isDefined } from '@xylabs/sdk-js'
 import { MemoryArchivist } from '@xyo-network/archivist-memory'
 import { MongoDBArchivistV2 } from '@xyo-network/archivist-mongodb'
 import { ViewArchivist } from '@xyo-network/archivist-view'
-import {
-  AddressBalanceDivinerV2, ArchivistSyncDiviner, HeadValidationDiviner,
-} from '@xyo-network/chain-modules'
-import { MongoMap } from '@xyo-network/chain-protocol'
+import { mapToMapType, MongoMap } from '@xyo-network/chain-protocol'
+import { initEvmProvider } from '@xyo-network/chain-services'
 import { initTelemetry } from '@xyo-network/chain-telemetry'
 import { AbstractModule, LoggerModuleStatusReporter } from '@xyo-network/module-abstract'
 import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
 import type { MongoDBModuleParamsV2 } from '@xyo-network/module-model-mongodb'
-import type { WithStorageMeta } from '@xyo-network/payload-model'
 import { MemorySentinel } from '@xyo-network/sentinel-memory'
+import { HDWallet } from '@xyo-network/wallet'
+import type { BridgeDestinationObservation, SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
 import type {
-  BalancesStepSummary, Config, MapType,
+  Config, IterableMap, XyoGatewayRunner,
+} from '@xyo-network/xl1-protocol-sdk'
+import {
+  hasMongoConfig, SimpleXyoGatewayRunner, SimpleXyoSigner,
 } from '@xyo-network/xl1-protocol-sdk'
-import { hasMongoConfig, MemoryMap } from '@xyo-network/xl1-protocol-sdk'
+import { HttpRpcXyoConnection } from '@xyo-network/xl1-rpc'
+import type { Document } from 'mongodb'
+
+import type { EVMLiquidityBridgeTransactionCompletionMonitorSentinelParams, XL1TransactionCompletionMonitorSentinelParams } from '../modules/index.ts'
+import {
+  EVMLiquidityBridgeTransactionCompletionMonitorSentinel, EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema,
+  XL1TransactionCompletionMonitorSentinel, XL1TransactionCompletionMonitorSentinelConfigSchema,
+} from '../modules/index.ts'
 
 export interface GetLocatorContext {
   config: Config
@@ -49,8 +55,6 @@ export const getLocator = async (context: GetLocatorContext) => {
   const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : undefined
 
   const locator = new ModuleFactoryLocator()
-  // Initialize with an in-memory map for backing the summary repository
-  let summaryMap: MapType<Hash, WithStorageMeta<BalancesStepSummary>> = new MemoryMap<Hash, WithStorageMeta<BalancesStepSummary>>()
   // If there's a MongoDB configuration
   const mongoConfig = config.storage?.mongo
   if (hasMongoConfig(mongoConfig)) {
@@ -66,26 +70,8 @@ export const getLocator = async (context: GetLocatorContext) => {
     }
     // Register the MongoDB Archivist as the default
     locator.register(MongoDBArchivistV2.factory(params), undefined, true)
-
-    // Use a persistent MongoMap for the summary repository if MongoDB is configured
-    const sdk = new BaseMongoSdk<WithStorageMeta<BalancesStepSummary>>({ ...payloadSdkConfig, collection: 'balance_summary_map' })
-    summaryMap = await MongoMap.create<MongoMap<Hash, WithStorageMeta<BalancesStepSummary>>>({ sdk })
   }
 
-  locator.register(AddressBalanceDivinerV2.factory<AddressBalanceDivinerV2>({
-    traceProvider, meterProvider, statusReporter, summaryMap,
-  }))
-
-  const chainId = isDefined(config.chain.id)
-    ? assertEx(asAddress(config.chain.id), () => 'chain.id must be an Address')
-    : ZERO_ADDRESS
-  locator.register(HeadValidationDiviner.factory<HeadValidationDiviner>({
-    traceProvider,
-    meterProvider,
-    statusReporter,
-    chainId,
-    allowedProducers: config.producer.allowlist,
-  }))
   locator.register(MemoryArchivist.factory({
     traceProvider, meterProvider, statusReporter,
   }))
@@ -95,8 +81,85 @@ export const getLocator = async (context: GetLocatorContext) => {
   locator.register(ViewArchivist.factory({
     traceProvider, meterProvider, statusReporter,
   }))
-  locator.register(ArchivistSyncDiviner.factory({
-    traceProvider, meterProvider, statusReporter,
-  }))
+
+  const gateway = await getGateway(config)
+  const viewer = assertEx(gateway.connectionInstance.viewer, () => 'Gateway viewer is not defined')
+  const pendingXl1ToEthXl1BridgeIntentTransactions = await getIterableMap<Hash, SignedHydratedTransaction>(
+    config,
+    'liquidity_bridge_xl1_to_eth_xl1_pending',
+  )
+  const completedXl1ToEthXl1BridgeIntentTransactions = await getIterableMap<Hash, SignedHydratedTransaction>(
+    config,
+    'liquidity_bridge_xl1_to_eth_xl1_completed',
+  )
+
+  const xl1TransactionCompletionMonitorSentinelParams: XL1TransactionCompletionMonitorSentinelParams = {
+    completedTransactions: completedXl1ToEthXl1BridgeIntentTransactions,
+    config: { schema: XL1TransactionCompletionMonitorSentinelConfigSchema },
+    meterProvider,
+    pendingTransactions: pendingXl1ToEthXl1BridgeIntentTransactions,
+    statusReporter,
+    traceProvider,
+    viewer,
+  }
+  locator.register(XL1TransactionCompletionMonitorSentinel.factory(xl1TransactionCompletionMonitorSentinelParams))
+
+  const completedEthXl1BridgeTransactions = await getIterableMap<Hash, BridgeDestinationObservation>(
+    config,
+    'liquidity_bridge_eth_xl1_bridge_completed',
+  )
+  const provider = await initEvmProvider({ config })
+  const bridgeAddress = config.bridge.remoteBridgeContractAddress
+  const evmLiquidityBridgeTransactionCompletionMonitorSentinelParams: EVMLiquidityBridgeTransactionCompletionMonitorSentinelParams = {
+    bridgeAddress,
+    completedTransactions: completedEthXl1BridgeTransactions,
+    config: { schema: EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema },
+    meterProvider,
+    pendingTransactions: completedXl1ToEthXl1BridgeIntentTransactions,
+    provider,
+    statusReporter,
+    traceProvider,
+  }
+  locator.register(EVMLiquidityBridgeTransactionCompletionMonitorSentinel.factory(evmLiquidityBridgeTransactionCompletionMonitorSentinelParams))
+
   return locator
 }
+
+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 connection = new HttpRpcXyoConnection({ endpoint })
+  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/public/Ethereum.json

@@ -12,75 +12,35 @@
           {
             "config": {
               "accountPath": "1/1'/1'",
-              "name": "BridgeIntent",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "payloadSdkConfig": {
-                "collection": "chain_bridge_intents"
-              },
-              "schema": "network.xyo.archivist.config"
+              "automations": [
+                {
+                  "frequency": 60000,
+                  "frequencyUnits": "millis",
+                  "schema": "network.xyo.automation.interval",
+                  "type": "interval"
+                }
+              ],
+              "name": "EVMLiquidityBridgeTransactionCompletionMonitorSentinelIntervalSentinel",
+              "schema": "network.xyo.sentinel.config",
+              "synchronous": true,
+              "tasks": [
+                {
+                  "mod": "EVMLiquidityBridgeTransactionCompletionMonitorSentinel",
+                  "endPoint": "report"
+                }
+              ]
             }
-          },
-          {
-            "config": {
-              "accountPath": "1/1'/2'",
-              "name": "BridgeSourceObservation",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "payloadSdkConfig": {
-                "collection": "chain_bridge_intents"
-              },
-              "schema": "network.xyo.archivist.config"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "1/1'/3'",
-              "name": "BridgeDestinationObservation",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "payloadSdkConfig": {
-                "collection": "chain_bridge_intents"
-              },
-              "schema": "network.xyo.archivist.config"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "1/1'/4'",
-              "name": "BridgeIntentProcessing",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "payloadSdkConfig": {
-                "collection": "chain_bridge_intents"
-              },
-              "schema": "network.xyo.archivist.config"
-            }
-          },
+          }
+        ],
+        "public": [
           {
             "config": {
-              "accountPath": "1/1'/5'",
-              "name": "BridgeIntentProcessed",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "payloadSdkConfig": {
-                "collection": "chain_bridge_intents"
-              },
-              "schema": "network.xyo.archivist.config"
+              "accountPath": "1/1/1",
+              "name": "EVMLiquidityBridgeTransactionCompletionMonitorSentinel",
+              "schema": "network.xyo.sentinel.chain.evm.liquidity.bridge.transaction.completion.monitor.config"
             }
           }
-        ],
-        "public": []
+        ]
       }
     }
   ],

package/src/manifest/public/XL1.json

@@ -12,75 +12,35 @@
           {
             "config": {
               "accountPath": "1/1'/1'",
-              "name": "BridgeIntent",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "payloadSdkConfig": {
-                "collection": "chain_bridge_intents"
-              },
-              "schema": "network.xyo.archivist.config"
+              "automations": [
+                {
+                  "frequency": 60000,
+                  "frequencyUnits": "millis",
+                  "schema": "network.xyo.automation.interval",
+                  "type": "interval"
+                }
+              ],
+              "name": "XL1BridgeIntentTransactionCompletionMonitorSentinelIntervalSentinel",
+              "schema": "network.xyo.sentinel.config",
+              "synchronous": true,
+              "tasks": [
+                {
+                  "mod": "XL1BridgeIntentTransactionCompletionMonitorSentinel",
+                  "endPoint": "report"
+                }
+              ]
             }
-          },
-          {
-            "config": {
-              "accountPath": "1/1'/2'",
-              "name": "BridgeSourceObservation",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "payloadSdkConfig": {
-                "collection": "chain_bridge_intents"
-              },
-              "schema": "network.xyo.archivist.config"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "1/1'/3'",
-              "name": "BridgeDestinationObservation",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "payloadSdkConfig": {
-                "collection": "chain_bridge_intents"
-              },
-              "schema": "network.xyo.archivist.config"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "1/1'/4'",
-              "name": "BridgeIntentProcessing",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "payloadSdkConfig": {
-                "collection": "chain_bridge_intents"
-              },
-              "schema": "network.xyo.archivist.config"
-            }
-          },
+          }
+        ],
+        "public": [
           {
             "config": {
-              "accountPath": "1/1'/5'",
-              "name": "BridgeIntentProcessed",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "payloadSdkConfig": {
-                "collection": "chain_bridge_intents"
-              },
-              "schema": "network.xyo.archivist.config"
+              "accountPath": "1/1/1",
+              "name": "XL1BridgeIntentTransactionCompletionMonitorSentinel",
+              "schema": "network.xyo.sentinel.chain.transaction.completion.monitor.config"
             }
           }
-        ],
-        "public": []
+        ]
       }
     }
   ],

package/src/manifest/public/index.ts

@@ -1,13 +1,8 @@
 import type { ModuleManifest, PackageManifestPayload } from '@xyo-network/manifest-model'
 
-import ChainNode from './Chain.json' with { type: 'json' }
 import XL1Node from './XL1.json' with { type: 'json' }
 import EthereumNode from './Ethereum.json' with { type: 'json' }
 
-/**
- * Chain Node Manifest
- */
-export const ChainNodeManifest = ChainNode as PackageManifestPayload
 
 /**
  * XL1 Node Manifest
@@ -23,7 +18,6 @@ export const EthereumNodeManifest = EthereumNode as PackageManifestPayload
  * Public Child Manifests
  */
 export const PublicChildManifests: ModuleManifest[] = [
-  ...ChainNodeManifest.nodes,
   ...XL1NodeManifest.nodes,
   ...EthereumNodeManifest.nodes,
 ]

package/src/modules/EVMLiquidityBridgeTransactionCompletionMonitorSentinel/EVMLiquidityBridgeTransactionCompletionMonitorSentinel.ts

@@ -0,0 +1,234 @@
+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 } from '@xyo-network/module-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload } from '@xyo-network/payload-model'
+import { AbstractSentinel } from '@xyo-network/sentinel-abstract'
+import type {
+  SentinelConfig, SentinelInstance, SentinelModuleEventData, SentinelParams,
+} from '@xyo-network/sentinel-model'
+import { type LiquidityPoolBridge, LiquidityPoolBridge__factory } from '@xyo-network/typechain'
+import {
+  type BridgeDestinationObservation, BridgeDestinationObservationSchema, type BridgeIntent, isBridgeIntent, type SignedHydratedTransaction,
+} from '@xyo-network/xl1-protocol'
+import type { IterableMap, MapType } from '@xyo-network/xl1-protocol-sdk'
+import {
+  flattenHydratedTransaction, flattenHydratedTransactions, tryUnflattenHydratedTransaction,
+} from '@xyo-network/xl1-protocol-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
+  = 'network.xyo.sentinel.chain.evm.liquidity.bridge.transaction.completion.monitor.config'
+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(): Promise<void> {
+    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

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