@xyo-network/chain-bridge 1.15.2

package/src/driver/mongo/MongoMap.ts

@@ -0,0 +1,62 @@
+import { assertEx } from '@xylabs/assert'
+import {
+  AbstractCreatable, creatable, CreatableParams,
+} from '@xylabs/creatable'
+import { BaseMongoSdk } from '@xylabs/mongo'
+import { isNull } from '@xylabs/typeof'
+import { AsynchronousMap } from '@xyo-network/chain-protocol'
+import {
+  Document, Filter, OptionalUnlessRequiredId, WithId,
+} from 'mongodb'
+
+export interface MongoMapParams<TData extends Document = Document> extends CreatableParams {
+  sdk: BaseMongoSdk<TData>
+}
+
+function stripMongoId<V extends Document>(doc: WithId<V>): V {
+  const { _id, ...rest } = doc
+  return rest as unknown as V
+}
+
+@creatable()
+export class MongoMap<K = string, V extends Document = Document>
+  extends AbstractCreatable<MongoMapParams<V>>
+  implements AsynchronousMap<K, V> {
+  get sdk(): BaseMongoSdk<V> {
+    return assertEx(this.params.sdk, () => 'No sdk specified')
+  }
+
+  async clear(): Promise<void> {
+    await this.sdk.deleteMany({})
+  }
+
+  async delete(id: K): Promise<boolean> {
+    const filter = { _id: id } as Filter<V>
+    const result = await this.sdk.deleteOne(filter)
+    return result.deletedCount > 0
+  }
+
+  async get(id: K): Promise<V | undefined> {
+    const filter = { _id: id } as Filter<V>
+    const doc = await this.sdk.findOne(filter)
+    return isNull(doc) ? undefined : stripMongoId(doc)
+  }
+
+  async has(id: K): Promise<boolean> {
+    const filter = { _id: id } as Filter<V>
+    const exists = await this.sdk.findOne(filter)
+    return isNull(exists) ? false : true
+  }
+
+  async set(id: K, data: V): Promise<this> {
+    const filter = { _id: id } as Filter<V>
+    const value = { ...data, _id: id } as OptionalUnlessRequiredId<V>
+    await this.sdk.replaceOne(filter, value, { upsert: true })
+    return this
+  }
+
+  override async startHandler(): Promise<void> {
+    await super.startHandler()
+    // TODO: Ensure index
+  }
+}

package/src/driver/mongo/index.ts

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

package/src/driver/mongo/spec/MongoMap.spec.ts

@@ -0,0 +1,67 @@
+import { BaseMongoSdk } from '@xylabs/mongo'
+import { getBaseMongoSdkPrivateConfig, hasMongoDBConfig } from '@xyo-network/module-abstract-mongodb'
+import {
+  beforeAll, beforeEach, describe, expect, it,
+} from 'vitest'
+
+import { MongoMap } from '../MongoMap.ts'
+
+describe.runIf(hasMongoDBConfig())('MongoMap', () => {
+  interface TestDoc {
+    name: string
+    value: number
+  }
+  const collection = 'test_mongo_map'
+  let sdk: BaseMongoSdk<TestDoc>
+  let map: MongoMap<string, TestDoc>
+  beforeAll(async () => {
+    const payloadSdkConfig = getBaseMongoSdkPrivateConfig()
+    sdk = new BaseMongoSdk<TestDoc>({ ...payloadSdkConfig, collection })
+    map = await MongoMap.create<MongoMap<string, TestDoc>>({ sdk })
+    await map.start()
+  })
+
+  beforeEach(async () => {
+    await map.clear()
+  })
+
+  it('can set and get a value', async () => {
+    await map.set('foo', { name: 'Test', value: 42 })
+    const result = await map.get('foo')
+    expect(result).toEqual({ name: 'Test', value: 42 })
+  })
+
+  it('returns undefined for missing key', async () => {
+    const result = await map.get('missing')
+    expect(result).toBeUndefined()
+  })
+
+  it('can detect if key exists', async () => {
+    await map.set('exists', { name: 'Check', value: 100 })
+    const hasExists = await map.has('exists')
+    const hasMissing = await map.has('does-not-exist')
+    expect(hasExists).toBe(true)
+    expect(hasMissing).toBe(false)
+  })
+
+  it('can delete a key', async () => {
+    await map.set('delete-me', { name: 'ToDelete', value: 1 })
+    const deleted = await map.delete('delete-me')
+    const stillExists = await map.has('delete-me')
+    expect(deleted).toBe(true)
+    expect(stillExists).toBe(false)
+  })
+
+  it('delete returns false for non-existent key', async () => {
+    const deleted = await map.delete('non-existent')
+    expect(deleted).toBe(false)
+  })
+
+  it('can clear all entries', async () => {
+    await map.set('one', { name: 'A', value: 1 })
+    await map.set('two', { name: 'B', value: 2 })
+    await map.clear()
+    expect(await map.has('one')).toBe(false)
+    expect(await map.has('two')).toBe(false)
+  })
+})

package/src/index.ts

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

package/src/interface/index.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,9 @@
+import type { BridgeDestinationObservation, BridgeIntent } from '@xyo-network/xl1-protocol'
+
+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

@@ -0,0 +1,7 @@
+import type { Address } from '@xylabs/hex'
+
+export interface IntentIndexerInterface<T> {
+  // TODO: Hex or string instead to handle alternative addressing schemes
+  getIntent(src: Address, nonce: string): Promise<T | null>
+  getIntents(src: Address): Promise<T[]>
+}

package/src/interface/interface/LockingProcessorInterface.ts

@@ -0,0 +1,10 @@
+import type { Address } from '@xylabs/hex'
+
+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

@@ -0,0 +1,12 @@
+import type {
+  BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation,
+} from '@xyo-network/xl1-protocol'
+
+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

@@ -0,0 +1,26 @@
+import { type BaseAccountableServiceParams } from '@xyo-network/chain-services'
+import type {
+  BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation,
+} from '@xyo-network/xl1-protocol'
+
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,28 @@
+import type { Address } from '@xylabs/hex'
+import type {
+  BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation,
+} from '@xyo-network/xl1-protocol'
+
+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

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

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

@@ -0,0 +1,11 @@
+import type { BridgeDestinationObservation, BridgeIntent } from '@xyo-network/xl1-protocol'
+
+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> {}

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

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

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

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

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

@@ -0,0 +1,264 @@
+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,
+} from '@xyo-network/xl1-protocol'
+import {
+  AttoXL1ConvertFactor, BridgeDestinationObservationSchema, BridgeIntentSchema,
+  BridgeSourceObservationSchema,
+} from '@xyo-network/xl1-protocol'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+import { getDefaultConfig } from '@xyo-network/xl1-protocol-sdk'
+import {
+  beforeAll, describe, expect, it, vi,
+} from 'vitest'
+
+import type {
+  BridgeDestinationObservationIndexerInterface, BridgeIntentIndexerInterface, BridgeServiceParams,
+  BridgeSourceObservationIndexerInterface,
+  ChainBridgeRelayInterface,
+  LockingBridgeIntentProcessorInterface, UnlockingBridgeIntentProcessorInterface,
+} from '../../../interface/index.ts'
+import { ChainBridgeRelayService } from '../ChainBridgeRelayService.ts'
+
+describe('ChainBridgeRelayService', () => {
+  let account: WalletInstance
+  let config: Config
+  let destinationObservations: BridgeDestinationObservationIndexerInterface
+  let destinationRelay: ChainBridgeRelayInterface
+  let intentProcessed: LockingBridgeIntentProcessorInterface
+  let intentProcessing: UnlockingBridgeIntentProcessorInterface
+  let intents: BridgeIntentIndexerInterface
+  let sourceObservations: BridgeSourceObservationIndexerInterface
+  let relay: ChainBridgeRelayService
+
+  const srcAmount = toHex(100n * AttoXL1ConvertFactor.xl1) // 100 XL1 in AttoXL1
+  const destAmount = srcAmount // 1:1 for test
+
+  const xl1ChainId: Chain = toHex('dd381fbb392c85160d8b0453e446757b12384046')
+  const ethChainId = toHex('0x1')
+
+  const xl1Address = toAddress('1111111111111111111111111111111111111111')
+  const ethAddress = toAddress('0x2222222222222222222222222222222222222222')
+
+  const bridgeableTokenContract = toHex('0x3333333333333333333333333333333333333333')
+
+  const nonce = 'd5eeff33-d5bc-4aca-9ecb-3406c02a5dc4'
+
+  const xl1TxHash = toHex('0x4444444444444444444444444444444444444444444444444444444444444444') // Some XL1 tx hash
+  const ethTxHash = toHex('0x5555555555555555555555555555555555555555555555555555555555555555') // Some Eth tx hash
+
+  const intent: BridgeIntent = {
+    // Source
+    src: xl1ChainId, // From XL1
+    srcAddress: xl1Address, // From XL1 sender
+    srcAmount,
+    srcToken: xl1ChainId, // In XL1
+
+    // Destination
+    dest: ethChainId, // To Ethereum
+    destAddress: ethAddress,
+    destAmount,
+    destToken: bridgeableTokenContract,
+
+    // Details
+    nonce,
+
+    schema: BridgeIntentSchema,
+  }
+
+  const srcObservation: BridgeSourceObservation = {
+    // Source
+    src: xl1ChainId, // From XL1
+    srcAddress: xl1Address, // From XL1 sender
+    srcAmount,
+    srcToken: xl1ChainId, // In XL1
+
+    // Destination
+    dest: ethChainId, // To Ethereum
+    destAddress: ethAddress,
+    destAmount,
+    destToken: bridgeableTokenContract,
+
+    // Observation
+    srcConfirmation: xl1TxHash,
+
+    schema: BridgeSourceObservationSchema,
+  }
+
+  const destObservation: BridgeDestinationObservation = {
+    // Source
+    src: xl1ChainId, // From XL1
+    srcAddress: xl1Address, // From XL1 sender
+    srcAmount,
+    srcToken: xl1ChainId, // In XL1
+
+    // Destination
+    dest: ethChainId, // To Ethereum
+    destAddress: ethAddress,
+    destAmount,
+    destToken: bridgeableTokenContract,
+
+    // Observation
+    destConfirmation: ethTxHash,
+
+    schema: BridgeDestinationObservationSchema,
+  }
+
+  beforeAll(async () => {
+    account = await HDWallet.random()
+    config = getDefaultConfig()
+
+    intents = {
+      getIntent: vi.fn().mockResolvedValue(null),
+      getIntents: vi.fn().mockResolvedValue([]),
+    }
+
+    sourceObservations = {
+      addObservation: vi.fn().mockResolvedValue(true),
+      getIntentForObservation: vi.fn().mockResolvedValue(null),
+      getObservationForIntent: vi.fn().mockResolvedValue(null),
+    }
+
+    destinationObservations = {
+      addObservation: vi.fn().mockResolvedValue(true),
+      getIntentForObservation: vi.fn().mockResolvedValue(null),
+      getObservationForIntent: vi.fn().mockResolvedValue(null),
+    }
+
+    intentProcessed = {
+      isLocked: vi.fn().mockResolvedValue(null),
+      lock: vi.fn().mockResolvedValue(true),
+    }
+
+    intentProcessing = {
+      isLocked: vi.fn().mockResolvedValue(null),
+      lock: vi.fn().mockResolvedValue(true),
+      unlock: vi.fn().mockResolvedValue(true),
+    }
+
+    destinationRelay = {
+      beginRelay: vi.fn().mockResolvedValue(true),
+      relaySync: vi.fn().mockResolvedValue(null),
+      onDestinationObservation: vi.fn().mockResolvedValue(false),
+    }
+
+    const params: BridgeServiceParams = {
+      account,
+      config,
+      destinationObservations,
+      destinationRelay,
+      intentProcessed,
+      intentProcessing,
+      intents,
+      sourceObservations,
+    }
+    relay = await ChainBridgeRelayService.create(params)
+  })
+  describe('beginRelay', () => {
+    it('should do nothing if source observation is null', async () => {
+      // Arrange
+      sourceObservations.getObservationForIntent = vi.fn().mockResolvedValue(null)
+
+      // Act
+      const result = await relay.beginRelay(intent)
+
+      // Assert
+      expect(intentProcessing.lock).not.toHaveBeenCalled()
+      expect(result).toBe(false)
+    })
+
+    it('should lock and call destinationRelay.beginRelay if observation exists', async () => {
+      // Arrange
+      sourceObservations.getObservationForIntent = vi.fn().mockResolvedValue(srcObservation)
+      intentProcessing.lock = vi.fn().mockResolvedValue(true)
+      destinationRelay.beginRelay = vi.fn().mockResolvedValue(true)
+
+      // Act
+      const result = await relay.beginRelay(intent)
+
+      // Assert
+      expect(sourceObservations.getObservationForIntent).toHaveBeenCalledWith(intent)
+      expect(intentProcessing.lock).toHaveBeenCalledWith(account.address, intent)
+      expect(destinationRelay.beginRelay).toHaveBeenCalledWith(intent)
+      expect(result).toBe(true)
+    })
+
+    it('should unlock if an exception is thrown', async () => {
+      // Arrange
+      sourceObservations.getObservationForIntent = vi.fn().mockResolvedValue(srcObservation)
+      intentProcessing.lock = vi.fn().mockResolvedValue(true)
+      destinationRelay.beginRelay = vi.fn().mockImplementation(() => {
+        throw new Error('boom')
+      })
+      intentProcessing.unlock = vi.fn()
+
+      // Act
+      const result = await relay.beginRelay(intent)
+
+      // Assert
+      expect(intentProcessing.unlock).toHaveBeenCalledWith(account.address, intent)
+      expect(result).toBe(false)
+    })
+  })
+  describe('onBridgeDestinationObservation', () => {
+    it('should return false if no intent exists for observation', async () => {
+      // Arrange
+      destinationObservations.getIntentForObservation = vi.fn().mockResolvedValue(null)
+
+      // Act
+      const result = await relay.onDestinationObservation(destObservation)
+
+      // Assert
+      expect(intentProcessed.isLocked).not.toHaveBeenCalled()
+      expect(result).toBe(false)
+    })
+
+    it('should return false if already processed', async () => {
+      // Arrange
+      const other = await HDWallet.random()
+      destinationObservations.getIntentForObservation = vi.fn().mockResolvedValue(intent)
+      intentProcessed.isLocked = vi.fn().mockResolvedValue(other.address)
+
+      // Act
+      const result = await relay.onDestinationObservation(destObservation)
+
+      // Assert
+      expect(intentProcessed.isLocked).toHaveBeenCalledWith(intent)
+      expect(result).toBe(false)
+    })
+
+    it('should return false if not the processor', async () => {
+      // Arrange
+      const other = await HDWallet.random()
+      destinationObservations.getIntentForObservation = vi.fn().mockResolvedValue(intent)
+      intentProcessed.isLocked = vi.fn().mockResolvedValue(null)
+      intentProcessing.isLocked = vi.fn().mockResolvedValue(other.address)
+
+      // Act
+      const result = await relay.onDestinationObservation(destObservation)
+
+      // Assert
+      expect(intentProcessing.isLocked).toHaveBeenCalledWith(intent)
+      expect(result).toBe(false)
+    })
+
+    it('should process if we are the processor', async () => {
+      // Arrange
+      destinationObservations.getIntentForObservation = vi.fn().mockResolvedValue(intent)
+      intentProcessed.isLocked = vi.fn().mockResolvedValue(null)
+      intentProcessing.isLocked = vi.fn().mockResolvedValue(account.address)
+      intentProcessed.lock = vi.fn().mockResolvedValue(true)
+      intentProcessing.unlock = vi.fn().mockResolvedValue(true)
+
+      // Act
+      const result = await relay.onDestinationObservation(destObservation)
+
+      // Assert
+      expect(intentProcessed.lock).toHaveBeenCalledWith(account.address, intent)
+      expect(intentProcessing.unlock).toHaveBeenCalledWith(account.address, intent)
+      expect(result).toBe(true)
+    })
+  })
+})