@xyo-network/chain-bridge 1.15.2 → 1.15.3

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

@@ -0,0 +1,237 @@
+import { assertEx } from '@xylabs/assert'
+import type { Address } from '@xylabs/hex'
+import { toAddress, toHex } from '@xylabs/hex'
+import { Account } from '@xyo-network/account'
+import type { AccountInstance } from '@xyo-network/account-model'
+import {
+  type BridgeableToken, BridgeableToken__factory, type LiquidityPoolBridge, LiquidityPoolBridge__factory,
+} from '@xyo-network/typechain'
+import type {
+  BridgeIntent, BridgeSourceObservation, ChainId,
+} from '@xyo-network/xl1-protocol'
+import {
+  AttoXL1ConvertFactor, 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 {
+  parseEther, Wallet, WebSocketProvider,
+} from 'ethers'
+import {
+  beforeAll, beforeEach, describe, expect, it, vi,
+} from 'vitest'
+
+import type {
+  BridgeDestinationObservationIndexerInterface, BridgeIntentIndexerInterface, BridgeSourceObservationIndexerInterface, ChainBridgeRelayInterface,
+  LockingBridgeIntentProcessorInterface, UnlockingBridgeIntentProcessorInterface,
+} from '../../../../interface/index.ts'
+import type { LiquidityPoolBridgeRelayParams } from '../LiquidityPoolBridgeRelay.ts'
+import { LiquidityPoolBridgeRelay } from '../LiquidityPoolBridgeRelay.ts'
+
+describe.skip('LiquidityPoolBridgeRelay', () => {
+  // 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
+  let account: AccountInstance
+  let config: Config
+  let destinationObservations: BridgeDestinationObservationIndexerInterface
+  let destinationRelay: ChainBridgeRelayInterface
+  let intentProcessed: LockingBridgeIntentProcessorInterface
+  let intentProcessing: UnlockingBridgeIntentProcessorInterface
+  let intents: BridgeIntentIndexerInterface
+  let sourceObservations: BridgeSourceObservationIndexerInterface
+  let relay: LiquidityPoolBridgeRelay
+  let intent: BridgeIntent
+  let srcObservation: BridgeSourceObservation
+
+  const xl1ChainId: ChainId = toAddress('0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9')
+  const xl1TxHash = toHex('0x4444444444444444444444444444444444444444444444444444444444444444') // Some XL1 tx hash
+  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 () => {
+    account = await Account.fromPrivateKey('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80')
+    config = getDefaultConfig()
+    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)
+
+    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),
+    }
+  })
+  describe('relaySync', () => {
+    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()
+      intent = {
+        // 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,
+      }
+      srcObservation = {
+        // 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,
+
+        // Observation
+        srcConfirmation: xl1TxHash,
+
+        schema: BridgeSourceObservationSchema,
+      }
+      intents = {
+        addIntent: vi.fn().mockResolvedValue(true),
+        getIntentByNonce: vi.fn().mockResolvedValue(intent),
+        getIntentsForDestination: vi.fn().mockResolvedValue([intent]),
+        getIntentsForSource: vi.fn().mockResolvedValue([]),
+      }
+      const params: LiquidityPoolBridgeRelayParams = {
+        account,
+        config,
+        bridgeAddress,
+        provider,
+        destinationObservations,
+        destinationRelay,
+        intentProcessed,
+        intentProcessing,
+        intents,
+        sourceObservations,
+      }
+      relay = await LiquidityPoolBridgeRelay.create(params)
+    })
+    it('should do nothing if source observation is null', async () => {
+      // Arrange
+      sourceObservations.getObservationForIntent = vi.fn().mockResolvedValue(null)
+      intentProcessing.lock = vi.fn().mockResolvedValue(true)
+      intentProcessing.unlock = vi.fn()
+
+      // Act
+      const result = await relay.relaySync(intent)
+
+      // Assert
+      expect(intentProcessing.lock).not.toHaveBeenCalled()
+      expect(result).toBe(null)
+    })
+
+    it('should lock and call destinationRelay.beginRelay if observation exists', async () => {
+      // Arrange
+      sourceObservations.getObservationForIntent = vi.fn().mockResolvedValue(srcObservation)
+      intentProcessing.lock = vi.fn().mockResolvedValue(true)
+      intentProcessing.unlock = vi.fn()
+
+      // Act
+      const result = await relay.relaySync(intent)
+
+      // Assert
+      expect(sourceObservations.getObservationForIntent).toHaveBeenCalledWith(intent)
+      expect(intentProcessing.lock).toHaveBeenCalledWith(account.address, intent)
+      expect(result).not.toBe(null)
+    })
+  })
+})

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

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

package/src/interface/service/index.ts

@@ -1,2 +1,2 @@
-export * from './ChainBridgeRelay/index.ts'
 export * from './Observer/index.ts'
+export * from './Relay/index.ts'

package/src/manifest/getLocator.ts

@@ -8,16 +8,18 @@ import { MemoryArchivist } from '@xyo-network/archivist-memory'
 import { MongoDBArchivistV2 } from '@xyo-network/archivist-mongodb'
 import { ViewArchivist } from '@xyo-network/archivist-view'
 import {
-  AddressBalanceDivinerV2, ArchivistSyncDiviner, balanceSummaryRepositoryFromMap, HeadValidationDiviner,
+  AddressBalanceDivinerV2, ArchivistSyncDiviner, HeadValidationDiviner,
 } from '@xyo-network/chain-modules'
-import type { MapType } from '@xyo-network/chain-protocol'
+import { MemoryMap } from '@xyo-network/chain-protocol'
 import { initTelemetry } from '@xyo-network/chain-telemetry'
 import { AbstractModule, LoggerModuleStatusReporter } from '@xyo-network/module-abstract'
 import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
 import type { MongoDBModuleParamsV2 } from '@xyo-network/module-model-mongodb'
 import type { WithStorageMeta } from '@xyo-network/payload-model'
 import { MemorySentinel } from '@xyo-network/sentinel-memory'
-import type { BalancesStepSummary, Config } from '@xyo-network/xl1-protocol-sdk'
+import type {
+  BalancesStepSummary, Config, MapType,
+} from '@xyo-network/xl1-protocol-sdk'
 import { hasMongoConfig } from '@xyo-network/xl1-protocol-sdk'
 
 import { MongoMap } from '../driver/index.ts'
@@ -52,7 +54,7 @@ export const getLocator = async (context: GetLocatorContext) => {
 
   const locator = new ModuleFactoryLocator()
   // Initialize with an in-memory map for backing the summary repository
-  let summaryMap: MapType<Hash, WithStorageMeta<BalancesStepSummary>> = new Map<Hash, WithStorageMeta<BalancesStepSummary>>()
+  let summaryMap: MapType<Hash, WithStorageMeta<BalancesStepSummary>> = new MemoryMap<Hash, WithStorageMeta<BalancesStepSummary>>()
   // If there's a MongoDB configuration
   const mongoConfig = config.storage?.mongo
   if (hasMongoConfig(mongoConfig)) {
@@ -74,9 +76,8 @@ export const getLocator = async (context: GetLocatorContext) => {
     summaryMap = await MongoMap.create<MongoMap<Hash, WithStorageMeta<BalancesStepSummary>>>({ sdk })
   }
 
-  const summaryRepository = balanceSummaryRepositoryFromMap(summaryMap)
   locator.register(AddressBalanceDivinerV2.factory<AddressBalanceDivinerV2>({
-    traceProvider, meterProvider, statusReporter, summaryRepository,
+    traceProvider, meterProvider, statusReporter, summaryMap,
   }))
 
   const chainId = isDefined(config.chain.id)

package/src/manifest/node.json

@@ -4,7 +4,7 @@
     {
       "config": {
         "accountPath": "44'/60'/1",
-        "name": "XYOChain",
+        "name": "XYOEthereumBridge",
         "schema": "network.xyo.node.config"
       },
       "modules": {

package/src/manifest/public/Chain.json

@@ -8,127 +8,21 @@
         "schema": "network.xyo.node.config"
       },
       "modules": {
-        "private": [
-          {
-            "config": {
-              "accountPath": "1/1'/1'",
-              "name": "Validated",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "payloadSdkConfig": {
-                "collection": "chain_validated"
-              },
-              "schema": "network.xyo.archivist.config"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "1/1'/2'",
-              "schema": "network.xyo.diviner.chain.head.validation.config",
-              "eventSubscriptions": [
-                {
-                  "sourceEvent": "inserted",
-                  "sourceModule": "Chain:Submissions",
-                  "targetModuleFunction": "divine"
-                }
-              ],
-              "inArchivist": "Chain:Submissions",
-              "outArchivist": "Chain:Validated",
-              "name": "HeadValidationDiviner"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "1/1'/3'",
-              "automations": [
-                {
-                  "frequency": 1000,
-                  "frequencyUnits": "millis",
-                  "schema": "network.xyo.automation.interval",
-                  "type": "interval"
-                }
-              ],
-              "name": "ChainValidationSentinel",
-              "schema": "network.xyo.sentinel.config",
-              "synchronous": true,
-              "tasks": [
-                {
-                  "mod": "HeadValidationDiviner",
-                  "endPoint": "divine"
-                }
-              ]
-            }
-          },
-          {
-            "config": {
-              "accountPath": "1/1'/4'",
-              "automations": [
-                {
-                  "frequency": 60000,
-                  "frequencyUnits": "millis",
-                  "schema": "network.xyo.automation.interval",
-                  "type": "interval"
-                }
-              ],
-              "name": "AddressBalancePollingSentinel",
-              "schema": "network.xyo.sentinel.config",
-              "synchronous": true,
-              "tasks": [
-                {
-                  "mod": "AddressBalanceDiviner",
-                  "endPoint": "divine"
-                }
-              ]
-            }
-          }
-        ],
+        "private": [],
         "public": [
           {
             "config": {
               "accountPath": "1/1/1",
-              "name": "Submissions",
+              "name": "Finalized",
               "getCache": {
                 "enabled": true,
                 "maxEntries": 5000
               },
               "payloadSdkConfig": {
-                "collection": "chain_submissions"
+                "collection": "chain_validated"
               },
               "schema": "network.xyo.archivist.config"
             }
-          },
-          {
-            "config": {
-              "accountPath": "1/1/2",
-              "name": "Finalized",
-              "allowedQueries": [
-                "network.xyo.query.archivist.get",
-                "network.xyo.query.archivist.next"
-              ],
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "originArchivist": "Chain:Validated",
-              "schema": "network.xyo.archivist.view.config"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "1/1/3",
-              "schema": "network.xyo.diviner.chain.address.balance.config",
-              "archivist": "Chain:Validated",
-              "name": "AddressBalanceDiviner",
-              "eventSubscriptions": [
-                {
-                  "sourceEvent": "inserted",
-                  "sourceModule": "Chain:Validated",
-                  "targetModuleFunction": "divine"
-                }
-              ]
-            }
           }
         ]
       }

package/src/manifest/public/Ethereum.json

@@ -0,0 +1,88 @@
+{
+  "$schema": "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  "nodes": [
+    {
+      "config": {
+        "accountPath": "3",
+        "name": "Ethereum",
+        "schema": "network.xyo.node.config"
+      },
+      "modules": {
+        "private": [
+          {
+            "config": {
+              "accountPath": "1/1'/1'",
+              "name": "BridgeIntent",
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "payloadSdkConfig": {
+                "collection": "chain_bridge_intents"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1'/2'",
+              "name": "BridgeSourceObservation",
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "payloadSdkConfig": {
+                "collection": "chain_bridge_intents"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1'/3'",
+              "name": "BridgeDestinationObservation",
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "payloadSdkConfig": {
+                "collection": "chain_bridge_intents"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1'/4'",
+              "name": "BridgeIntentProcessing",
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "payloadSdkConfig": {
+                "collection": "chain_bridge_intents"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1'/5'",
+              "name": "BridgeIntentProcessed",
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "payloadSdkConfig": {
+                "collection": "chain_bridge_intents"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          }
+        ],
+        "public": []
+      }
+    }
+  ],
+  "schema": "network.xyo.manifest"
+}

package/src/manifest/public/XL1.json

@@ -0,0 +1,88 @@
+{
+  "$schema": "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  "nodes": [
+    {
+      "config": {
+        "accountPath": "2",
+        "name": "XL1",
+        "schema": "network.xyo.node.config"
+      },
+      "modules": {
+        "private": [
+          {
+            "config": {
+              "accountPath": "1/1'/1'",
+              "name": "BridgeIntent",
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "payloadSdkConfig": {
+                "collection": "chain_bridge_intents"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1'/2'",
+              "name": "BridgeSourceObservation",
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "payloadSdkConfig": {
+                "collection": "chain_bridge_intents"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1'/3'",
+              "name": "BridgeDestinationObservation",
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "payloadSdkConfig": {
+                "collection": "chain_bridge_intents"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1'/4'",
+              "name": "BridgeIntentProcessing",
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "payloadSdkConfig": {
+                "collection": "chain_bridge_intents"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1'/5'",
+              "name": "BridgeIntentProcessed",
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "payloadSdkConfig": {
+                "collection": "chain_bridge_intents"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          }
+        ],
+        "public": []
+      }
+    }
+  ],
+  "schema": "network.xyo.manifest"
+}

package/src/manifest/public/index.ts

@@ -1,20 +1,29 @@
 import type { ModuleManifest, PackageManifestPayload } from '@xyo-network/manifest-model'
 
-import Chain from './Chain.json' with { type: 'json' }
-import Pending from './Pending.json' with { type: 'json' }
+import ChainNode from './Chain.json' with { type: 'json' }
+import XL1Node from './XL1.json' with { type: 'json' }
+import EthereumNode from './Ethereum.json' with { type: 'json' }
 
 /**
  * Chain Node Manifest
  */
-export const ChainNodeManifest = Chain as PackageManifestPayload
+export const ChainNodeManifest = ChainNode as PackageManifestPayload
+
 /**
- * Pending Node Manifest
+ * XL1 Node Manifest
  */
-export const PendingNodeManifest = Pending as PackageManifestPayload
+export const XL1NodeManifest = XL1Node as PackageManifestPayload
+
+/**
+ * Ethereum Node Manifest
+ */
+export const EthereumNodeManifest = EthereumNode as PackageManifestPayload
+
 /**
  * Public Child Manifests
  */
 export const PublicChildManifests: ModuleManifest[] = [
   ...ChainNodeManifest.nodes,
-  ...PendingNodeManifest.nodes,
+  ...XL1NodeManifest.nodes,
+  ...EthereumNodeManifest.nodes,
 ]

package/src/server/app.ts

@@ -1,14 +1,7 @@
 import {
-  customPoweredByHeader,
-  disableCaseSensitiveRouting,
-  disableExpressDefaultPoweredByHeader,
-  getJsonBodyParser,
-  getJsonBodyParserOptions,
-  responseProfiler,
-  standardErrors,
-  standardResponses,
+  customPoweredByHeader, disableCaseSensitiveRouting, disableExpressDefaultPoweredByHeader, getJsonBodyParser, getJsonBodyParserOptions, responseProfiler,
+  standardErrors, standardResponses,
 } from '@xylabs/express'
-import type { NodeInstance } from '@xyo-network/node-model'
 import compression from 'compression'
 import cors from 'cors'
 import type { Express } from 'express'
@@ -17,11 +10,11 @@ import express from 'express'
 import { addInstrumentation } from './instrumentation.ts'
 import { addRoutes } from './routes/index.ts'
 
-export const getApp = (node: NodeInstance): Express => {
+// export const getApp = (node: NodeInstance): Express => {
+export const getApp = (): Express => {
   addInstrumentation()
   const app = express()
   app.set('etag', false)
-
   app.use(cors())
   app.use(compression())
   app.use(responseProfiler)
@@ -30,7 +23,7 @@ export const getApp = (node: NodeInstance): Express => {
   disableExpressDefaultPoweredByHeader(app)
   app.use(customPoweredByHeader)
   disableCaseSensitiveRouting(app)
-  app.node = node
+  // app.node = node
   addRoutes(app)
   app.use(standardErrors)
   return app