@xyo-network/chain-bridge 1.20.15 → 1.20.16

package/src/config/getXl1TokenAddress.ts

@@ -1,12 +0,0 @@
-import type { Hex } from '@xylabs/sdk-js'
-import { isDefined } from '@xylabs/sdk-js'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-
-import { asToken } from './asToken.ts'
-import { getXl1ChainId } from './getXl1ChainId.ts'
-
-export const getXl1TokenAddress = (config: BridgeConfig): Hex => {
-  const token = asToken(config.xl1TokenAddress)
-  if (isDefined(token)) return token
-  return getXl1ChainId(config)
-}

package/src/config/index.ts

@@ -1,15 +0,0 @@
-export * from './asChainId.ts'
-export * from './asToken.ts'
-export * from './getBridgeEscrowAddress.ts'
-export * from './getBridgeFeesAddress.ts'
-export * from './getBridgeSettings.ts'
-export * from './getBridgeWalletAccount.ts'
-export * from './getFeeStructure.ts'
-export * from './getMaxBridgeAmount.ts'
-export * from './getMinBridgeAmount.ts'
-export * from './getRemoteChainId.ts'
-export * from './getRemoteTokenAddress.ts'
-export * from './getTestGateway.ts'
-export * from './getTransferAddresses.ts'
-export * from './getXl1ChainId.ts'
-export * from './getXl1TokenAddress.ts'

package/src/index.ts

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

package/src/interface/index.ts

@@ -1,4 +0,0 @@
-export * from './interface/index.ts'
-export * from './repository/index.ts'
-export * from './service/index.ts'
-export * from './util/index.ts'

package/src/interface/interface/ChainBridgeRelayInterface.ts

@@ -1,9 +0,0 @@
-import type { BridgeDestinationObservation, BridgeIntent } from '@xyo-network/xl1-sdk'
-
-import type { AsynchronousRelayInterface, SynchronousRelayInterface } from './RelayInterface.ts'
-
-export interface AsynchronousChainBridgeRelayInterface extends AsynchronousRelayInterface<BridgeIntent, BridgeDestinationObservation> {}
-
-export interface SynchronousChainBridgeRelayInterface extends SynchronousRelayInterface<BridgeIntent, BridgeDestinationObservation> {}
-
-export interface ChainBridgeRelayInterface extends AsynchronousChainBridgeRelayInterface, SynchronousChainBridgeRelayInterface {}

package/src/interface/interface/IntentIndexerInterface.ts

@@ -1,8 +0,0 @@
-import type { Address, Hex } from '@xylabs/sdk-js'
-
-export interface IntentIndexerInterface<T> {
-  addIntent(intent: T): Promise<boolean>
-  getIntentByNonce(nonce: Hex): Promise<T | undefined>
-  getIntentsForDestination(dest: Address): Promise<T[]>
-  getIntentsForSource(src: Address): Promise<T[]>
-}

package/src/interface/interface/LockingProcessorInterface.ts

@@ -1,10 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-
-export interface LockingProcessorInterface<T> {
-  isLocked(intent: T): Promise<Address | null>
-  lock(processor: Address, intent: T): Promise<boolean>
-}
-
-export interface UnlockingProcessorInterface<T> extends LockingProcessorInterface<T> {
-  unlock(processor: Address, intent: T): Promise<boolean>
-}

package/src/interface/interface/ObservationIndexerInterface.ts

@@ -1,12 +0,0 @@
-import type {
-  BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation,
-} from '@xyo-network/xl1-sdk'
-
-export interface ObservationIndexerInterface<
-  TObservation extends BridgeSourceObservation | BridgeDestinationObservation,
-  TIntent extends BridgeIntent = BridgeIntent,
-> {
-  addObservation(observation: TObservation, intent: TIntent): Promise<boolean>
-  getIntentForObservation(observation: TObservation): Promise<TIntent | null>
-  getObservationForIntent(intent: TIntent): Promise<TObservation | null>
-}

package/src/interface/interface/Params.ts

@@ -1,26 +0,0 @@
-import { type BaseAccountableServiceParams } from '@xyo-network/chain-services'
-import type {
-  BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation,
-} from '@xyo-network/xl1-sdk'
-
-import type { ChainBridgeRelayInterface } from './ChainBridgeRelayInterface.ts'
-import type { IntentIndexerInterface } from './IntentIndexerInterface.ts'
-import type { LockingProcessorInterface, UnlockingProcessorInterface } from './LockingProcessorInterface.ts'
-import type { ObservationIndexerInterface } from './ObservationIndexerInterface.ts'
-
-export interface BridgeIntentIndexerInterface extends IntentIndexerInterface<BridgeIntent> {}
-export interface BridgeSourceObservationIndexerInterface extends ObservationIndexerInterface<BridgeSourceObservation> {}
-export interface BridgeDestinationObservationIndexerInterface extends ObservationIndexerInterface<BridgeDestinationObservation> {}
-export interface LockingBridgeIntentProcessorInterface extends LockingProcessorInterface<BridgeIntent> {}
-export interface UnlockingBridgeIntentProcessorInterface extends UnlockingProcessorInterface<BridgeIntent> {}
-
-export type BridgeServiceCollection = {
-  destinationObservations: BridgeDestinationObservationIndexerInterface
-  destinationRelay: ChainBridgeRelayInterface
-  intentProcessed: LockingBridgeIntentProcessorInterface
-  intentProcessing: UnlockingBridgeIntentProcessorInterface
-  intents: BridgeIntentIndexerInterface
-  sourceObservations: BridgeSourceObservationIndexerInterface
-}
-
-export type BridgeServiceParams = BaseAccountableServiceParams & BridgeServiceCollection

package/src/interface/interface/RelayInterface.ts

@@ -1,8 +0,0 @@
-export interface SynchronousRelayInterface<T, U> {
-  relaySync(message: T): Promise<U | null>
-}
-
-export interface AsynchronousRelayInterface<T, U> {
-  beginRelay(message: T): Promise<boolean>
-  onDestinationObservation(observation: U): Promise<boolean>
-}

package/src/interface/interface/index.ts

@@ -1,6 +0,0 @@
-export * from './ChainBridgeRelayInterface.ts'
-export * from './IntentIndexerInterface.ts'
-export * from './LockingProcessorInterface.ts'
-export * from './ObservationIndexerInterface.ts'
-export * from './Params.ts'
-export * from './RelayInterface.ts'

package/src/interface/repository/RepositoryInterface.ts

@@ -1,28 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import type {
-  BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation,
-} from '@xyo-network/xl1-sdk'
-
-export interface IntentRepository {
-  getBridgeIntents(src: Address, nonce?: string): Promise<BridgeIntent[]>
-}
-
-export interface SourceObservationRepository {
-  getBridgeSourceObservation(intent: BridgeIntent): Promise<BridgeSourceObservation[]>
-}
-
-export interface DestinationObservationRepository {
-  getBridgeDestinationObservation(intent: BridgeIntent): Promise<BridgeDestinationObservation[]>
-}
-
-export interface IntentProcessingRepository {
-  isIntentProcessing(intent: BridgeIntent): Promise<boolean>
-  markIntentProcessed(intent: BridgeIntent): Promise<void>
-  markIntentProcessing(intent: BridgeIntent): Promise<void>
-  unmarkIntentProcessing(intent: BridgeIntent): Promise<void>
-}
-
-export interface IntentProcessedRepository {
-  isIntentProcessed(intent: BridgeIntent): Promise<boolean>
-  markIntentProcessed(intent: BridgeIntent): Promise<void>
-}

package/src/interface/repository/index.ts

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

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

@@ -1,180 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import {
-  asAddress, asHex, hexToBigInt, isBigInt, isNull, isUndefined,
-  toAddress,
-} from '@xylabs/sdk-js'
-import type { BridgeDestinationObservation, BridgeSourceObservation } from '@xyo-network/xl1-sdk'
-import {
-  BridgeDestinationObservationSchema, BridgeSourceObservationSchema, XYO_ZERO_ADDRESS,
-} from '@xyo-network/xl1-sdk'
-import type { EventLog, WebSocketProvider } from 'ethers'
-import { Contract } from 'ethers'
-import { getAddress } from 'ethers/address'
-
-import type { BridgeServiceParams } from '../../../interface/index.ts'
-import { AbstractBridgeObserverService } 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 AbstractBridgeObserverService<ERC20TransferObserverParams> {
-  moniker = 'ERC20TransferObserver'
-  protected get tokenAddress(): Address {
-    return toAddress(this.params.tokenAddress)
-  }
-
-  override async createHandler() {
-    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

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

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

@@ -1,210 +0,0 @@
-import type { Address, Hex } from '@xylabs/sdk-js'
-import {
-  asAddress, asHex, assertEx, hexFromBigInt, hexToBigInt, isNull, isUndefined, toAddress,
-} from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { ILiquidityPoolBridge } from '@xyo-network/typechain'
-import { ILiquidityPoolBridge__factory } from '@xyo-network/typechain'
-import type {
-  BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation,
-} from '@xyo-network/xl1-sdk'
-import {
-  BridgeDestinationObservationSchema, BridgeIntentSchema, BridgeSourceObservationSchema,
-} from '@xyo-network/xl1-sdk'
-import type { ContractEventPayload, WebSocketProvider } from 'ethers'
-import { getAddress } from 'ethers'
-
-import type { BridgeServiceParams } from '../../../interface/index.ts'
-import { AbstractBridgeObserverService } from '../Observer.ts'
-
-export type LiquidityPoolBridgeObserverParams = BridgeServiceParams & {
-  /**
-   * The address to watch for incoming or outgoing ERC-20 token transfers.
-   */
-  bridgeAddress: Address
-  /**
-   * 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 AbstractBridgeObserverService<LiquidityPoolBridgeObserverParams> {
-  moniker = 'LiquidityPoolBridgeObserver'
-  protected _bridge: ILiquidityPoolBridge | undefined
-  protected _bridgeChainId: Hex | undefined
-  protected _bridgeRemoteChainId: Hex | undefined
-  protected _bridgeTokenAddress: Address | undefined
-
-  protected get bridge(): ILiquidityPoolBridge {
-    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() {
-    const { provider, bridgeAddress } = this.params
-
-    // Connect to the bridge contract
-    this._bridge = ILiquidityPoolBridge__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
-
-    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

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

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

@@ -1,48 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import { AbstractCreatableProvider } from '@xyo-network/xl1-sdk'
-
-import type {
-  BridgeDestinationObservationIndexerInterface, BridgeIntentIndexerInterface, BridgeServiceParams,
-  BridgeSourceObservationIndexerInterface,
-  ChainBridgeRelayInterface,
-  LockingBridgeIntentProcessorInterface, UnlockingBridgeIntentProcessorInterface,
-} from '../../interface/index.ts'
-
-export interface BridgeObserverInterface {
-  // TODO:
-}
-
-export abstract class AbstractBridgeObserverService<TParams extends BridgeServiceParams = BridgeServiceParams>
-  extends AbstractCreatableProvider<TParams> implements BridgeObserverInterface {
-  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 intents(): BridgeIntentIndexerInterface {
-    return assertEx(this.params.intents, () => 'intents is required')
-  }
-
-  protected get sourceObservations(): BridgeSourceObservationIndexerInterface {
-    return assertEx(this.params.sourceObservations, () => 'sourceObservations is required')
-  }
-
-  async process(): Promise<void> {
-    await Promise.resolve()
-  }
-}

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

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

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

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