@xyo-network/chain-bridge 1.16.15 → 1.16.17

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

@@ -1,314 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import {
-  assertEx, delay,
-  toAddress, toHex,
-} from '@xylabs/sdk-js'
-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/Relay/ChainBridgeRelay/spec/ChainBridgeRelayService.spec.ts

@@ -1,266 +0,0 @@
-import { toAddress, toHex } from '@xylabs/sdk-js'
-import { HDWallet } from '@xyo-network/wallet'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import type {
-  BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation, ChainId,
-} 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: ChainId = 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 = {
-      addIntent: vi.fn().mockResolvedValue(true),
-      getIntentByNonce: vi.fn(),
-      getIntentsForDestination: vi.fn().mockResolvedValue([]),
-      getIntentsForSource: 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)
-    })
-  })
-})