@xyo-network/chain-bridge 1.15.2 → 1.15.4

package/src/interface/service/Observer/LiquidityPoolBridgeObserver/spec/LiquidityPoolBridgeObserver.spec.ts

@@ -0,0 +1,313 @@
+import { assertEx } from '@xylabs/assert'
+import { delay } from '@xylabs/delay'
+import type { Address } from '@xylabs/hex'
+import { toAddress, toHex } from '@xylabs/hex'
+import { Account } from '@xyo-network/account'
+import type { BridgeableToken, LiquidityPoolBridge } from '@xyo-network/typechain'
+import { BridgeableToken__factory, LiquidityPoolBridge__factory } from '@xyo-network/typechain'
+import type {
+  BridgeDetailsFields, BridgeIntent, ChainId,
+} from '@xyo-network/xl1-protocol'
+import {
+  AttoXL1ConvertFactor, BridgeIntentSchema, BridgeSourceObservationSchema,
+} from '@xyo-network/xl1-protocol'
+import {
+  getAddress,
+  parseEther, Wallet, WebSocketProvider,
+} from 'ethers'
+import {
+  beforeAll, beforeEach, describe, expect, it, vi,
+} from 'vitest'
+
+import type {
+  BridgeDestinationObservationIndexerInterface, BridgeIntentIndexerInterface, BridgeSourceObservationIndexerInterface,
+} from '../../../../interface/index.ts'
+import { LiquidityPoolBridgeObserver } from '../LiquidityPoolBridgeObserver.ts'
+
+describe.skip('LiquidityPoolBridgeObserver', () => {
+  // Test ERC-20 deployed to Hardhat local chain
+  const TOKEN_ADDRESS = '0x5FbDB2315678afecb367f032d93F642f64180aa3'
+  const bridgeAddress = '0xa85233C63b9Ee964Add6F2cffe00Fd84eb32338f'
+  const WS_URL = 'ws://127.0.0.1:8545'
+  const provider = new WebSocketProvider(WS_URL)
+  let ethBridgeSender: Wallet
+  let ethBridgeReceiver: Wallet
+  let token: BridgeableToken
+  let bridge: LiquidityPoolBridge
+  let xl1Address: Address
+  const xl1ChainId: ChainId = toAddress('0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9')
+  let sourceObservations: BridgeSourceObservationIndexerInterface
+  let destinationObservations: BridgeDestinationObservationIndexerInterface
+  let intents: BridgeIntentIndexerInterface
+
+  const srcAmountBigint = 100n * AttoXL1ConvertFactor.xl1
+  const srcAmount = toHex(srcAmountBigint)
+  const destAmount = srcAmount // 1:1 for test
+  const ethChainId = toHex('0x7A69')
+  const bridgeableTokenContract = toHex(TOKEN_ADDRESS)
+
+  const createRandomWallet = async (): Promise<Wallet> => {
+    // Create random account
+    const account = await Account.random()
+    expect(account.private?.hex).toBeDefined()
+    const key = assertEx(account.private?.hex)
+
+    // Create a wallet from the private key
+    const wallet = new Wallet(key, provider)
+    const deployer = await provider.getSigner(0)
+
+    // Fund the wallet with some ETH for gas
+    const fundTx = await deployer.sendTransaction({ to: wallet.address, value: parseEther('1') })
+    await fundTx.wait()
+
+    // Ensure wallet has ETH
+    const balance = await provider.getBalance(wallet.address)
+    expect(balance).toBeGreaterThan(0n)
+
+    // Return the created wallet
+    return wallet
+  }
+
+  const bridgeFromRemote = async (xl1Address: Address, ethBridgeReceiver: Wallet, srcAmountBigint: bigint) => {
+    const balance = await token.balanceOf(await bridge.getAddress())
+    expect(balance).toBeGreaterThanOrEqual(srcAmountBigint)
+    await bridge.bridgeFromRemote(getAddress(xl1Address), ethBridgeReceiver.address, srcAmountBigint)
+  }
+
+  const bridgeToRemote = async (ethBridgeSender: Wallet, xl1Address: Address, srcAmountBigint: bigint) => {
+    const balance = await token.balanceOf(ethBridgeSender.address)
+    expect(balance).toBeGreaterThanOrEqual(srcAmountBigint)
+    const destAddress = getAddress(xl1Address)
+    await token.connect(ethBridgeSender).approve(bridge.getAddress(), srcAmountBigint)
+    const nonce = await ethBridgeSender.getNonce()
+    await bridge.connect(ethBridgeSender).bridgeToRemote(destAddress, srcAmountBigint, { nonce })
+  }
+
+  beforeAll(async () => {
+    const deployer = await provider.getSigner(0)
+    ethBridgeSender = await createRandomWallet()
+
+    token = BridgeableToken__factory.connect(TOKEN_ADDRESS, deployer)
+    bridge = LiquidityPoolBridge__factory.connect(bridgeAddress, deployer)
+    const owner = await bridge.owner()
+    expect(owner).toBeDefined()
+    expect(owner).to.eq(deployer.address)
+    const amount = srcAmountBigint * 2n
+    await token.mint(await bridge.getAddress(), parseEther(amount.toString()))
+    expect(await token.balanceOf(await bridge.getAddress())).toBeGreaterThanOrEqual(amount)
+    await token.mint(ethBridgeSender.address, parseEther(amount.toString()))
+    expect(await token.balanceOf(ethBridgeSender.address)).toBeGreaterThanOrEqual(amount)
+  })
+
+  describe('when bridging from Ethereum', () => {
+    beforeEach(async () => {
+      xl1Address = (await Account.random()).address
+      ethBridgeReceiver = await createRandomWallet()
+      sourceObservations = {
+        addObservation: vi.fn().mockResolvedValue(true),
+        getObservationForIntent: vi.fn().mockResolvedValue(null),
+        getIntentForObservation: vi.fn().mockResolvedValue(null),
+      }
+      destinationObservations = {
+        addObservation: vi.fn().mockResolvedValue(true),
+        getObservationForIntent: vi.fn().mockResolvedValue(null),
+        getIntentForObservation: vi.fn().mockResolvedValue(null),
+      }
+      intents = {
+        addIntent: vi.fn().mockResolvedValue(true),
+        getIntentByNonce: vi.fn(),
+        getIntentsForDestination: vi.fn().mockResolvedValue([]),
+        getIntentsForSource: vi.fn().mockResolvedValue([]),
+      }
+    })
+    describe('for new transfers to XL1', () => {
+      it('should observe transfer', async () => {
+      // Arrange
+      // Create observer before transfer
+        const observer = await LiquidityPoolBridgeObserver.create({
+          destinationObservations,
+          intents,
+          provider,
+          sourceObservations,
+          bridgeAddress,
+        })
+        expect(observer).toBeDefined()
+
+        // Act
+        await bridgeToRemote(ethBridgeSender, xl1Address, srcAmountBigint)
+
+        // Wait for event
+        await delay(2000)
+
+        // Assert
+        // Ensure transfer was observed
+        const fields: BridgeDetailsFields = {
+          // Source
+          src: ethChainId,
+          srcAddress: toAddress(ethBridgeSender.address),
+          srcAmount,
+          srcToken: bridgeableTokenContract,
+
+          // Destination
+          dest: xl1ChainId,
+          destAddress: xl1Address,
+          destAmount,
+          destToken: xl1ChainId,
+        }
+        expect(intents.addIntent).toHaveBeenCalledWith({
+          ...fields,
+          nonce: expect.any(String),
+          schema: BridgeIntentSchema,
+        })
+        expect(sourceObservations.addObservation).toHaveBeenCalledWith({
+          ...fields,
+          nonce: expect.any(String),
+          schema: BridgeSourceObservationSchema,
+        }, {
+          ...fields,
+          nonce: expect.any(String),
+          schema: BridgeIntentSchema,
+        })
+      })
+    })
+    describe('for previous transfers to XL1', () => {
+      it('should observe transfer', async () => {
+        // Arrange
+        await bridgeToRemote(ethBridgeSender, xl1Address, srcAmountBigint)
+        // Wait for transaction to be mined
+        await delay(2000)
+
+        // Act
+        // Create observer after transfer
+        const observer = await LiquidityPoolBridgeObserver.create({
+          destinationObservations,
+          intents,
+          provider,
+          sourceObservations,
+          bridgeAddress,
+        })
+        expect(observer).toBeDefined()
+
+        // Assert
+        // Ensure transfer was observed
+        // Ensure transfer was observed
+        const fields: BridgeDetailsFields = {
+          // Source
+          src: ethChainId,
+          srcAddress: toAddress(ethBridgeSender.address),
+          srcAmount,
+          srcToken: bridgeableTokenContract,
+
+          // Destination
+          dest: xl1ChainId,
+          destAddress: xl1Address,
+          destAmount,
+          destToken: xl1ChainId,
+        }
+        expect(intents.addIntent).toHaveBeenCalledWith({
+          ...fields,
+          nonce: expect.any(String),
+          schema: BridgeIntentSchema,
+        })
+        expect(sourceObservations.addObservation).toHaveBeenCalledWith({
+          ...fields,
+          nonce: expect.any(String),
+          schema: BridgeSourceObservationSchema,
+        }, {
+          ...fields,
+          nonce: expect.any(String),
+          schema: BridgeIntentSchema,
+        })
+      })
+    })
+  })
+
+  describe('when bridging to Ethereum', () => {
+    beforeEach(async () => {
+      xl1Address = (await Account.random()).address
+      ethBridgeReceiver = await createRandomWallet()
+      sourceObservations = {
+        addObservation: vi.fn().mockResolvedValue(true),
+        getObservationForIntent: vi.fn().mockResolvedValue(null),
+        getIntentForObservation: vi.fn().mockResolvedValue(null),
+      }
+      destinationObservations = {
+        addObservation: vi.fn().mockResolvedValue(true),
+        getObservationForIntent: vi.fn().mockResolvedValue(null),
+        getIntentForObservation: vi.fn().mockResolvedValue(null),
+      }
+      const nonce = Date.now().toString()
+      const intent: BridgeIntent = {
+        // Source
+        src: xl1ChainId, // From XL1
+        srcAddress: xl1Address, // From XL1 sender
+        srcAmount,
+        srcToken: xl1ChainId, // In XL1
+
+        // Destination
+        dest: ethChainId, // To Ethereum
+        destAddress: toAddress(ethBridgeReceiver.address),
+        destAmount,
+        destToken: bridgeableTokenContract,
+
+        // Details
+        nonce,
+
+        schema: BridgeIntentSchema,
+      }
+      intents = {
+        addIntent: vi.fn().mockResolvedValue(true),
+        getIntentByNonce: vi.fn().mockResolvedValue(intent),
+        getIntentsForDestination: vi.fn().mockResolvedValue([intent]),
+        getIntentsForSource: vi.fn().mockResolvedValue([]),
+      }
+    })
+    describe('for new transfers from xl1 address', () => {
+      it('should observe transfer', async () => {
+      // Arrange
+      // Create observer before transfer
+        const observer = await LiquidityPoolBridgeObserver.create({
+          destinationObservations,
+          intents,
+          provider,
+          sourceObservations,
+          bridgeAddress,
+        })
+        expect(observer).toBeDefined()
+
+        // Act
+        await bridgeFromRemote(xl1Address, ethBridgeReceiver, srcAmountBigint)
+
+        // Wait for event
+        await delay(2000)
+
+        // Assert
+        // Ensure transfer was observed
+        expect(destinationObservations.addObservation).toHaveBeenCalled()
+      })
+    })
+    describe('for previous transfers from xl1 address', () => {
+      it('should observe transfer', async () => {
+      // Arrange
+        await bridgeFromRemote(xl1Address, ethBridgeReceiver, srcAmountBigint)
+        // Wait for transaction to be mined
+        await delay(2000)
+
+        // Act
+        // Create observer after transfer
+        const observer = await LiquidityPoolBridgeObserver.create({
+          destinationObservations,
+          intents,
+          provider,
+          sourceObservations,
+          bridgeAddress,
+        })
+        expect(observer).toBeDefined()
+
+        // Assert
+        // Ensure transfer was observed
+        expect(destinationObservations.addObservation).toHaveBeenCalled()
+      })
+    })
+  })
+})

package/src/interface/service/Observer/Observer.ts

@@ -34,7 +34,7 @@ export class BridgeObserverService<TParams extends BridgeServiceParams = BridgeS
     return assertEx(this.params.intentProcessing, () => 'intentProcessing is required')
   }
 
-  protected get intentResourceAccess(): BridgeIntentIndexerInterface {
+  protected get intents(): BridgeIntentIndexerInterface {
     return assertEx(this.params.intents, () => 'intents is required')
   }
 

package/src/interface/service/{ChainBridgeRelay → Relay/ChainBridgeRelay}/ChainBridgeRelayInterface.ts

@@ -1,6 +1,6 @@
 import type { BridgeDestinationObservation, BridgeIntent } from '@xyo-network/xl1-protocol'
 
-import type { AsynchronousRelayInterface, SynchronousRelayInterface } from '../../interface/index.ts'
+import type { AsynchronousRelayInterface, SynchronousRelayInterface } from '../../../interface/index.ts'
 
 export interface BlockingChainBridgeRelay extends SynchronousRelayInterface<BridgeIntent, BridgeDestinationObservation> {}
 

package/src/interface/service/{ChainBridgeRelay → Relay/ChainBridgeRelay}/ChainBridgeRelayService.ts

@@ -8,7 +8,7 @@ import type {
   BridgeServiceParams,
   BridgeSourceObservationIndexerInterface, ChainBridgeRelayInterface, LockingBridgeIntentProcessorInterface,
   UnlockingBridgeIntentProcessorInterface,
-} from '../../interface/index.ts'
+} from '../../../interface/index.ts'
 
 export class ChainBridgeRelayService<TParams extends BridgeServiceParams = BridgeServiceParams>
   extends BaseAccountableService<TParams> implements ChainBridgeRelayInterface {

package/src/interface/service/{ChainBridgeRelay → Relay/ChainBridgeRelay}/spec/ChainBridgeRelayService.spec.ts

@@ -2,7 +2,7 @@ import { toAddress, toHex } from '@xylabs/hex'
 import { HDWallet } from '@xyo-network/wallet'
 import type { WalletInstance } from '@xyo-network/wallet-model'
 import type {
-  BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation, Chain,
+  BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation, ChainId,
 } from '@xyo-network/xl1-protocol'
 import {
   AttoXL1ConvertFactor, BridgeDestinationObservationSchema, BridgeIntentSchema,
@@ -19,7 +19,7 @@ import type {
   BridgeSourceObservationIndexerInterface,
   ChainBridgeRelayInterface,
   LockingBridgeIntentProcessorInterface, UnlockingBridgeIntentProcessorInterface,
-} from '../../../interface/index.ts'
+} from '../../../../interface/index.ts'
 import { ChainBridgeRelayService } from '../ChainBridgeRelayService.ts'
 
 describe('ChainBridgeRelayService', () => {
@@ -36,7 +36,7 @@ describe('ChainBridgeRelayService', () => {
   const srcAmount = toHex(100n * AttoXL1ConvertFactor.xl1) // 100 XL1 in AttoXL1
   const destAmount = srcAmount // 1:1 for test
 
-  const xl1ChainId: Chain = toHex('dd381fbb392c85160d8b0453e446757b12384046')
+  const xl1ChainId: ChainId = toHex('dd381fbb392c85160d8b0453e446757b12384046')
   const ethChainId = toHex('0x1')
 
   const xl1Address = toAddress('1111111111111111111111111111111111111111')
@@ -111,8 +111,10 @@ describe('ChainBridgeRelayService', () => {
     config = getDefaultConfig()
 
     intents = {
-      getIntent: vi.fn().mockResolvedValue(null),
-      getIntents: vi.fn().mockResolvedValue([]),
+      addIntent: vi.fn().mockResolvedValue(true),
+      getIntentByNonce: vi.fn(),
+      getIntentsForDestination: vi.fn().mockResolvedValue([]),
+      getIntentsForSource: vi.fn().mockResolvedValue([]),
     }
 
     sourceObservations = {

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

@@ -0,0 +1,227 @@
+import { assertEx } from '@xylabs/assert'
+import type { Address, Hex } from '@xylabs/hex'
+import {
+  asHex, hexFromBigInt, hexToBigInt, toAddress,
+} from '@xylabs/hex'
+import { isNull } from '@xylabs/typeof'
+import { BaseAccountableService } from '@xyo-network/chain-services'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { LiquidityPoolBridge } from '@xyo-network/typechain'
+import { LiquidityPoolBridge__factory } from '@xyo-network/typechain'
+import {
+  type BridgeDestinationObservation, BridgeDestinationObservationSchema, type BridgeIntent,
+} from '@xyo-network/xl1-protocol'
+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 BaseAccountableService<TParams> implements ChainBridgeRelayInterface {
+  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(): Promise<void> {
+    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

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