@xyo-network/chain-bridge 1.15.2 → 1.15.3

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

@@ -0,0 +1,181 @@
+import type { Address } from '@xylabs/hex'
+import {
+  asAddress, asHex, hexToBigInt, toAddress,
+} from '@xylabs/hex'
+import {
+  isBigInt, isNull, isUndefined,
+} from '@xylabs/typeof'
+import type { BridgeDestinationObservation, BridgeSourceObservation } from '@xyo-network/xl1-protocol'
+import {
+  BridgeDestinationObservationSchema, BridgeSourceObservationSchema, XYO_ZERO_ADDRESS,
+} from '@xyo-network/xl1-protocol'
+import type { EventLog, WebSocketProvider } from 'ethers'
+import { Contract } from 'ethers'
+import { getAddress } from 'ethers/address'
+
+import type { BridgeServiceParams } from '../../../interface/index.ts'
+import { BridgeObserverService } from '../Observer.ts'
+
+export type ERC20TransferObserverParams = BridgeServiceParams & {
+  /**
+   * An ethers.js WebSocketProvider connected to the Ethereum network to monitor for ERC-20 transfers.
+   */
+  provider: WebSocketProvider
+  /**
+   * The ERC-20 token contract address to monitor (e.g., XYO, USDC).
+   */
+  tokenAddress: string
+  /**
+   * The address to watch for incoming or outgoing ERC-20 token transfers.
+   */
+  watchAddress: string
+  /**
+   * Specify whether to watch for 'incoming' or 'outgoing' types of transfers.
+   */
+  watchDirection: 'incoming' | 'outgoing'
+}
+
+// Minimal ERC-20 ABI only with Transfer event
+const ERC20_ABI = [
+  'event Transfer(address indexed from, address indexed to, uint256 value)',
+]
+
+export class ERC20TransferObserver extends BridgeObserverService<ERC20TransferObserverParams> {
+  protected get tokenAddress(): Address {
+    return toAddress(this.params.tokenAddress)
+  }
+
+  override async createHandler(): Promise<void> {
+    const {
+      provider, tokenAddress, watchAddress, watchDirection,
+    } = this.params
+    // The custodial wallet to watch for transfers
+    const normalizedWatchAddress = getAddress(watchAddress)
+
+    // Create a Contract for the ERC-20 token
+    const token = new Contract(getAddress(tokenAddress), ERC20_ABI, provider)
+
+    // Listen for transfers involving WATCH_ADDRESS
+    const filterIncoming = token.filters.Transfer(null, normalizedWatchAddress)
+    const filterOutgoing = token.filters.Transfer(normalizedWatchAddress, null)
+
+    // Pick correct filter + direction
+    const filter = watchDirection === 'incoming' ? filterIncoming : filterOutgoing
+
+    // Replay old logs
+    const currentBlock = await provider.getBlockNumber()
+    const pastEvents = await token.queryFilter(filter, 0, currentBlock)
+    for (const ev of pastEvents) {
+      const {
+        from, to, value,
+      } = (ev as EventLog)?.args
+      await (watchDirection === 'incoming' ? this.handleTransfer(from, value, 'incoming') : this.handleTransfer(to, value, 'outgoing'))
+    }
+
+    // Watch for new events
+    if (watchDirection === 'incoming') {
+      await token.on(filterIncoming, (ev: EventLog) => {
+        // Sanitize event log
+        const { from, value } = ev.args
+        if (isUndefined(from) || isUndefined(value)) return
+        const sender = asAddress(from)
+        // Ignore mints
+        if (isUndefined(sender) || sender === XYO_ZERO_ADDRESS) return
+        // Ensure value is bigint and non-zero
+        if (!isBigInt(value) || value === 0n) return
+        // Handle transfer
+        this.handleTransfer(sender, value, 'incoming').catch(console.error)
+      })
+    } else if (watchDirection === 'outgoing') {
+      await token.on(filterOutgoing, (ev: EventLog) => {
+        // Sanitize event log
+        const { to, value } = ev.args
+        if (isUndefined(to) || isUndefined(value)) return
+        const receiver = asAddress(to)
+        // Ignore burns
+        if (isUndefined(receiver) || receiver === XYO_ZERO_ADDRESS) return
+        // Ensure value is bigint and non-zero
+        if (!isBigInt(value) || value === 0n) return
+        this.handleTransfer(receiver, value, 'outgoing').catch(console.error)
+      })
+    } else {
+      throw new Error(`Invalid watchDirection: ${watchDirection}`)
+    }
+  }
+
+  private async handleTransfer(account: Address, value: bigint, direction: 'incoming' | 'outgoing'): Promise<void> {
+    if (direction === 'incoming') {
+      const sender = asAddress(account)
+      if (isUndefined (sender) || sender === XYO_ZERO_ADDRESS) return
+      const intents = await this.intents.getIntentsForSource(sender)
+      if (intents.length === 0) return
+      // Find the intent that matches the transfer amount (chain and token are implicit to provider and intents were already indexed by address)
+      const intent = intents.findLast((i) => {
+        try {
+          // Source address matches intent
+          const address = asAddress(i.srcAddress)
+          if (isUndefined(address) || address !== sender) return false
+          // Source token must match
+          const token = asHex(i.srcToken)
+          if (isUndefined(token) || token !== this.tokenAddress) return false
+          // Source amount must match
+          const hexAmount = asHex(i.srcAmount)
+          if (isUndefined(hexAmount)) return false
+          const amount = hexToBigInt(hexAmount)
+          if (amount !== value) return false
+          // Otherwise matches
+          return true
+        } catch {
+          return false
+        }
+      })
+      if (isUndefined(intent)) return
+      // Found matching intent, check if observation already exists
+      const observations = this.sourceObservations
+      const existing = await observations.getObservationForIntent(intent)
+      // Only add if observation not already existing
+      if (isUndefined(existing) || isNull(existing)) {
+        const { schema, ...rest } = intent
+        const observation: BridgeSourceObservation = { schema: BridgeSourceObservationSchema, ...rest }
+        await observations.addObservation(observation, intent)
+      }
+    } else if (direction === 'outgoing') {
+      const receiver = asAddress(account)
+      if (isUndefined (receiver) || receiver === XYO_ZERO_ADDRESS) return
+      const intents = await this.intents.getIntentsForDestination(receiver)
+      if (intents.length === 0) return
+      // Find the intent that matches the transfer amount (chain and token are implicit to provider and intents were already indexed by address)
+      const intent = intents.findLast((i) => {
+        try {
+          // Source address matches intent
+          const address = asAddress(i.destAddress)
+          if (isUndefined(address) || address !== receiver) return false
+          // Source token must match
+          const token = asHex(i.destToken)
+          if (isUndefined(token) || token !== this.tokenAddress) return false
+          // Source amount must match
+          const hexAmount = asHex(i.destAmount)
+          if (isUndefined(hexAmount)) return false
+          const amount = hexToBigInt(hexAmount)
+          if (amount !== value) return false
+          // Otherwise matches
+          return true
+        } catch {
+          return false
+        }
+      })
+      if (isUndefined(intent)) return
+      // Found matching intent, check if observation already exists
+      const observations = this.destinationObservations
+      const existing = await observations.getObservationForIntent(intent)
+      // Only add if observation not already existing
+      if (isUndefined(existing) || isNull(existing)) {
+        const { schema, ...rest } = intent
+        const observation: BridgeDestinationObservation = { schema: BridgeDestinationObservationSchema, ...rest }
+        await observations.addObservation(observation, intent)
+      }
+    } else {
+      throw new Error(`Invalid direction: ${direction}`)
+    }
+  }
+}

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

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

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

@@ -0,0 +1,271 @@
+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 } from '@xyo-network/typechain'
+import { BridgeableToken__factory } from '@xyo-network/typechain'
+import {
+  AttoXL1ConvertFactor, type BridgeIntent, BridgeIntentSchema, type ChainId,
+} from '@xyo-network/xl1-protocol'
+import {
+  parseEther, Wallet, WebSocketProvider,
+} from 'ethers'
+import {
+  beforeAll, beforeEach, describe, expect, it, vi,
+} from 'vitest'
+
+import type {
+  BridgeDestinationObservationIndexerInterface, BridgeIntentIndexerInterface, BridgeSourceObservationIndexerInterface,
+} from '../../../../interface/index.ts'
+import { ERC20TransferObserver } from '../ERC20TransferObserver.ts'
+
+describe.skip('ERC20TransferObserver', () => {
+  // Test ERC-20 deployed to Hardhat local chain
+  const TOKEN_ADDRESS = '0x5FbDB2315678afecb367f032d93F642f64180aa3'
+  const WS_URL = 'ws://127.0.0.1:8545'
+  const provider = new WebSocketProvider(WS_URL)
+  let ethBridgeSender: Wallet
+  let ethBridgeReceiver: Wallet
+  let custodialWallet: Wallet
+  let token: BridgeableToken
+  let xl1Address: Address
+  let xl1ChainId: ChainId
+  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
+  }
+
+  beforeAll(async () => {
+    const tokenOwner = await provider.getSigner(0)
+    ethBridgeSender = await createRandomWallet()
+    ethBridgeReceiver = await createRandomWallet()
+    custodialWallet = await createRandomWallet()
+
+    token = BridgeableToken__factory.connect(TOKEN_ADDRESS, tokenOwner)
+    await token.mint(custodialWallet.address, parseEther((srcAmountBigint * 2n).toString()))
+    await token.mint(ethBridgeSender.address, parseEther((srcAmountBigint * 2n).toString()))
+  })
+
+  beforeEach(async () => {
+    xl1Address = (await Account.random()).address
+    xl1ChainId = (await Account.random()).address
+  })
+
+  describe('when bridging from Ethereum', () => {
+    beforeEach(() => {
+      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: ethChainId,
+        srcAddress: toAddress(ethBridgeSender.address),
+        srcAmount,
+        srcToken: bridgeableTokenContract,
+
+        // Destination
+        dest: xl1ChainId,
+        destAddress: xl1Address,
+        destAmount,
+        destToken: xl1ChainId,
+
+        // Details
+        nonce,
+
+        schema: BridgeIntentSchema,
+      }
+      intents = {
+        addIntent: vi.fn().mockResolvedValue(true),
+        getIntentByNonce: vi.fn().mockResolvedValue(intent),
+        getIntentsForDestination: vi.fn().mockResolvedValue([]),
+        getIntentsForSource: vi.fn().mockResolvedValue([intent]),
+      }
+    })
+    describe('for new transfers to custodial wallet', () => {
+      it('should observe transfer', async () => {
+      // Arrange
+      // Create observer before transfer
+        const observer = await ERC20TransferObserver.create({
+          destinationObservations,
+          intents,
+          provider,
+          sourceObservations,
+          tokenAddress: TOKEN_ADDRESS,
+          watchAddress: toAddress(custodialWallet.address),
+          watchDirection: 'incoming',
+        })
+        expect(observer).toBeDefined()
+        // Ensure sender has tokens
+        const balance = await token.balanceOf(ethBridgeSender.address)
+        expect(balance).toBeGreaterThan(0n)
+        const sender = token.connect(ethBridgeSender)
+
+        // Act
+        // Transfer from sender to custodial wallet
+        await sender.transfer(custodialWallet.address, srcAmountBigint)
+
+        // Wait for event
+        await delay(2000)
+
+        // Assert
+        // Ensure transfer was observed
+        expect(sourceObservations.addObservation).toHaveBeenCalled()
+      })
+    })
+    describe('for previous transfers to custodial wallet', () => {
+      it('should observe transfer', async () => {
+      // Arrange
+      // Ensure sender has tokens
+        const balance = await token.balanceOf(ethBridgeSender.address)
+        expect(balance).toBeGreaterThan(0n)
+        const sender = token.connect(ethBridgeSender)
+        // Transfer from sender to custodial wallet
+        await sender.transfer(custodialWallet.address, srcAmountBigint)
+
+        // Act
+        // Create observer after transfer
+        const observer = await ERC20TransferObserver.create({
+          destinationObservations,
+          intents,
+          provider,
+          sourceObservations,
+          tokenAddress: TOKEN_ADDRESS,
+          watchAddress: toAddress(custodialWallet.address),
+          watchDirection: 'incoming',
+        })
+        expect(observer).toBeDefined()
+
+        // Assert
+        // Ensure transfer was observed
+        expect(sourceObservations.addObservation).toHaveBeenCalled()
+      })
+    })
+  })
+
+  describe('when bridging to Ethereum', () => {
+    beforeEach(() => {
+      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 custodial wallet', () => {
+      it('should observe transfer', async () => {
+      // Arrange
+      // Create observer before transfer
+        const observer = await ERC20TransferObserver.create({
+          destinationObservations,
+          intents,
+          provider,
+          sourceObservations,
+          tokenAddress: TOKEN_ADDRESS,
+          watchAddress: toAddress(custodialWallet.address),
+          watchDirection: 'outgoing',
+        })
+        expect(observer).toBeDefined()
+
+        // Act
+        const sender = token.connect(custodialWallet)
+        await sender.transfer(ethBridgeReceiver.address, srcAmountBigint.toString())
+
+        // Wait for event
+        await delay(2000)
+
+        // Assert
+        // Ensure transfer was observed
+        expect(destinationObservations.addObservation).toHaveBeenCalled()
+      })
+    })
+    describe('for previous transfers from custodial wallet', () => {
+      it('should observe transfer', async () => {
+      // Arrange
+        const sender = token.connect(custodialWallet)
+        await sender.transfer(ethBridgeReceiver.address, srcAmountBigint.toString())
+
+        // Act
+        // Create observer after transfer
+        const observer = await ERC20TransferObserver.create({
+          destinationObservations,
+          intents,
+          provider,
+          sourceObservations,
+          tokenAddress: TOKEN_ADDRESS,
+          watchAddress: toAddress(custodialWallet.address),
+          watchDirection: 'outgoing',
+        })
+        expect(observer).toBeDefined()
+
+        // Assert
+        // Ensure transfer was observed
+        expect(destinationObservations.addObservation).toHaveBeenCalled()
+      })
+    })
+  })
+})

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

@@ -0,0 +1,212 @@
+import { assertEx } from '@xylabs/assert'
+import type { Address, Hex } from '@xylabs/hex'
+import {
+  asAddress, asHex, hexFromBigInt, hexToBigInt, toAddress,
+} from '@xylabs/hex'
+import { isNull, isUndefined } from '@xylabs/typeof'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { LiquidityPoolBridge } from '@xyo-network/typechain'
+import { LiquidityPoolBridge__factory } from '@xyo-network/typechain'
+import type {
+  BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation,
+} from '@xyo-network/xl1-protocol'
+import {
+  BridgeDestinationObservationSchema, BridgeIntentSchema, BridgeSourceObservationSchema,
+} from '@xyo-network/xl1-protocol'
+import type { ContractEventPayload, WebSocketProvider } from 'ethers'
+import { getAddress } from 'ethers'
+
+import type { BridgeServiceParams } from '../../../interface/index.ts'
+import { BridgeObserverService } from '../Observer.ts'
+
+export type LiquidityPoolBridgeObserverParams = 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
+  /**
+   * The block number to start monitoring from.
+   */
+  startBlock?: number
+}
+
+export class LiquidityPoolBridgeObserver extends BridgeObserverService<LiquidityPoolBridgeObserverParams> {
+  protected _bridge: LiquidityPoolBridge | undefined
+  protected _bridgeChainId: Hex | undefined
+  protected _bridgeRemoteChainId: Hex | undefined
+  protected _bridgeTokenAddress: Address | undefined
+
+  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 provider(): WebSocketProvider {
+    return assertEx(this.params.provider, () => new Error('Provider not initialized'))
+  }
+
+  protected get startBlock(): number {
+    return isUndefined(this.params.startBlock) ? 0 : this.params.startBlock
+  }
+
+  override async createHandler(): Promise<void> {
+    const { provider, bridgeAddress } = this.params
+
+    // Connect to the bridge contract
+    this._bridge = LiquidityPoolBridge__factory.connect(getAddress(bridgeAddress), provider)
+
+    // 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)
+
+    // Grab the current block number to avoid processing old events
+    const currentBlock = await provider.getBlockNumber()
+    const manualIndexThroughBlockNumber = Math.max(currentBlock, this.startBlock)
+
+    // Watch for & process new events
+    await this.bridge.on(this.bridge.getEvent('BridgedToRemote'), (id, from, to, amount, remoteChain, args) => {
+      const contractEvent = args as unknown as ContractEventPayload
+      if (contractEvent?.log?.blockNumber <= manualIndexThroughBlockNumber) return
+      this.handleBridgeToRemote(id, from, to, amount, remoteChain).catch(console.error)
+    })
+    await this.bridge.on(this.bridge.getEvent('BridgedFromRemote'), (id, from, to, amount, remoteChain, args) => {
+      const contractEvent = args as unknown as ContractEventPayload
+      if (contractEvent?.log?.blockNumber <= manualIndexThroughBlockNumber) return
+      this.handleBridgeFromRemote(id, from, to, amount, remoteChain).catch(console.error)
+    })
+
+    // Process old events
+    await this.processOldEvents(this.startBlock, manualIndexThroughBlockNumber)
+  }
+
+  private async handleBridgeFromRemote(id: bigint, from: string, to: string, value: bigint, remoteChain: string): Promise<void> {
+    const srcAddress = asAddress(from)
+    const destAddress = asAddress(to)
+    const remoteChainId = asHex(remoteChain)
+    if (isUndefined (srcAddress) || isUndefined (destAddress) || isUndefined (remoteChainId)) return
+    if (remoteChainId != this.bridgeRemoteChainId) return
+
+    const intents = await this.intents.getIntentsForDestination(destAddress)
+    if (intents.length === 0) return
+    // Find the intent that matches the transfer amount (chain and token are implicit to provider and intents were already indexed by address)
+    const intent = intents.findLast((i) => {
+      try {
+        // TODO: Add source to event signature to capture intent
+        // Source address matches intent
+        // const intentSrcAddress = asAddress(i.srcAddress)
+        // if (isUndefined(intentSrcAddress) || intentSrcAddress !== srcAddress) return false
+        // Destination address matches intent
+        const intentDestAddress = asAddress(i.destAddress)
+        if (isUndefined(intentDestAddress) || intentDestAddress !== destAddress) return false
+
+        // Source token matches intent
+        const intentSrcToken = i.srcToken
+        if (isUndefined(intentSrcToken) || intentSrcToken !== this.bridgeRemoteChainId) return false
+        // Destination token matches intent
+        const intentDestToken = asHex(i.destToken)
+        if (isUndefined(intentDestToken) || intentDestToken !== this.bridgeTokenAddress) return false
+
+        // Destination amount must match
+        const intentDestAmountHex = asHex(i.destAmount)
+        if (isUndefined(intentDestAmountHex)) return false
+        const intentDestAmountBigInt = hexToBigInt(intentDestAmountHex)
+        if (intentDestAmountBigInt !== value) return false
+
+        // Otherwise matches
+        return true
+      } catch {
+        return false
+      }
+    })
+
+    if (isUndefined(intent)) return
+    // Found matching intent, check if observation already exists
+    const observations = this.destinationObservations
+    const existing = await observations.getObservationForIntent(intent)
+    // Only add if observation not already existing
+    if (isUndefined(existing) || isNull(existing)) {
+      const { schema, ...rest } = intent
+      const observation: BridgeDestinationObservation = { schema: BridgeDestinationObservationSchema, ...rest }
+      await observations.addObservation(observation, intent)
+    }
+  }
+
+  private async handleBridgeToRemote(id: bigint, from: string, to: string, value: bigint, remoteChain: string): Promise<void> {
+    const srcAddress = asAddress(from)
+    const destAddress = asAddress(to)
+    const remoteChainId = asHex(remoteChain)
+    if (isUndefined (srcAddress) || isUndefined (destAddress) || isUndefined (remoteChainId)) return
+    if (remoteChainId != this.bridgeRemoteChainId) return
+
+    // If we don't have an intent for this nonce already
+    const nonce = hexFromBigInt(id)
+    let intent = await this.intents.getIntentByNonce(nonce)
+    if (isUndefined(intent)) {
+      // Create observation for intent if none exists
+      intent = new PayloadBuilder<BridgeIntent>({ schema: BridgeIntentSchema }).fields({
+        nonce,
+        dest: this.bridgeRemoteChainId,
+        destAddress,
+        destAmount: hexFromBigInt(value),
+        destToken: this.bridgeRemoteChainId,
+        src: this.bridgeChainId,
+        srcAddress,
+        srcAmount: hexFromBigInt(value),
+        srcToken: this.bridgeTokenAddress,
+      }).build()
+      await this.intents.addIntent(intent)
+    }
+    // Ensure we have an intent to match against
+    if (isUndefined(intent)) return
+    // Found matching intent, check if observation already exists
+    const observations = this.sourceObservations
+    const existing = await observations.getObservationForIntent(intent)
+    // Only add if observation not already existing
+    if (isUndefined(existing) || isNull(existing)) {
+      const { schema, ...rest } = intent
+      const observation: BridgeSourceObservation = { schema: BridgeSourceObservationSchema, ...rest }
+      await observations.addObservation(observation, intent)
+    }
+  }
+
+  private async processOldEvents(startBlock: number, endBlock: number): Promise<void> {
+    const bridgedToRemote = await this.bridge.queryFilter(this.bridge.filters.BridgedToRemote(), startBlock, endBlock)
+    for (const log of bridgedToRemote) {
+      const {
+        id, srcAddress, destAddress, amount, destToken,
+      } = log.args
+      await this.handleBridgeToRemote(id, srcAddress, destAddress, amount, destToken)
+    }
+
+    const bridgedFromRemote = await this.bridge.queryFilter(this.bridge.filters.BridgedFromRemote(), startBlock, endBlock)
+    for (const log of bridgedFromRemote) {
+      const {
+        id, srcAddress, destAddress, amount, srcToken,
+      } = log.args
+      await this.handleBridgeFromRemote(id, srcAddress, destAddress, amount, srcToken)
+    }
+  }
+}

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

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