Send address book along with tracking information (#114)

packages/backend/src/tracking/TrackingModule.ts

@@ -90,6 +90,7 @@ function createTrackingModule(dependencies: Dependencies): ApplicationModule {
     oAppRepo,
     oAppConfigurationRepo,
     oAppDefaultConfigurationRepo,
+    currDiscoveryRepo,
   )
 
   const router = createTrackingRouter(controller)

packages/backend/src/tracking/http/TrackingController.test.ts

@@ -1,7 +1,8 @@
 import { assert } from '@l2beat/backend-tools'
 import { ChainId, EthereumAddress } from '@lz/libs'
-import { expect, mockObject } from 'earl'
+import { expect, mockFn, mockObject } from 'earl'
 
+import { CurrentDiscoveryRepository } from '../../peripherals/database/CurrentDiscoveryRepository'
 import {
   OAppConfigurationRecord,
   OAppConfigurationRepository,
@@ -28,11 +29,15 @@ describe(TrackingController.name, () => {
         mockObject<OAppDefaultConfigurationRepository>({
           getBySourceChain: () => Promise.resolve([]),
         })
+      const currDiscoveryRepo = mockObject<CurrentDiscoveryRepository>({
+        find: mockFn().resolvesTo(null),
+      })
 
       const controller = new TrackingController(
         oAppRepo,
         oAppConfigRepo,
         oAppDefaultConfigRepo,
+        currDiscoveryRepo,
       )
       const result = await controller.getOApps(chainId)
 
@@ -127,6 +132,31 @@ describe(TrackingController.name, () => {
           },
         ]
 
+        const mockDiscoveryOutput = {
+          contracts: [
+            {
+              name: 'Oracle',
+              address: EthereumAddress.random(),
+              unverified: false,
+            },
+            {
+              name: 'Relayer',
+              address: EthereumAddress.random(),
+              unverified: true,
+            },
+            {
+              name: 'Endpoint',
+              address: EthereumAddress.random(),
+              unverified: false,
+            },
+          ],
+          eoas: [
+            EthereumAddress.random(),
+            EthereumAddress.random(),
+            EthereumAddress.random(),
+          ],
+        }
+
         const oAppRepo = mockObject<OAppRepository>({
           getBySourceChain: () => Promise.resolve([oAppA, oAppB]),
         })
@@ -138,11 +168,18 @@ describe(TrackingController.name, () => {
           mockObject<OAppDefaultConfigurationRepository>({
             getBySourceChain: () => Promise.resolve(mockDefaultConfigurations),
           })
+        const currDiscoveryRepo = mockObject<CurrentDiscoveryRepository>({
+          find: mockFn().resolvesTo({
+            chainId,
+            discoveryOutput: mockDiscoveryOutput,
+          }),
+        })
 
         const controller = new TrackingController(
           oAppRepo,
           oAppConfigRepo,
           oAppDefaultConfigRepo,
+          currDiscoveryRepo,
         )
 
         const result = await controller.getOApps(chainId)
@@ -199,6 +236,19 @@ describe(TrackingController.name, () => {
             configuration: c.configuration,
           })),
         )
+
+        expect(result.addressInfo).toEqual([
+          ...mockDiscoveryOutput.contracts.map((contract) => ({
+            name: contract.name,
+            address: contract.address,
+            verified: !contract.unverified,
+          })),
+          ...mockDiscoveryOutput.eoas.map((eoa) => ({
+            name: 'EOA',
+            address: eoa,
+            verified: true,
+          })),
+        ])
       })
     })
   })

packages/backend/src/tracking/http/TrackingController.ts

@@ -1,11 +1,14 @@
 import { assert } from '@l2beat/backend-tools'
+import { DiscoveryOutput } from '@l2beat/discovery-types'
 import {
+  AddressInfo,
   ChainId,
   OAppsResponse,
   OAppWithConfigs,
   ResolvedConfigurationWithAppId,
 } from '@lz/libs'
 
+import { CurrentDiscoveryRepository } from '../../peripherals/database/CurrentDiscoveryRepository'
 import {
   OAppConfigurationRecord,
   OAppConfigurationRepository,
@@ -27,9 +30,18 @@ class TrackingController {
     private readonly oAppRepo: OAppRepository,
     private readonly oAppConfigurationRepo: OAppConfigurationRepository,
     private readonly oAppDefaultConfigRepo: OAppDefaultConfigurationRepository,
+    private readonly currDiscoveryRepository: CurrentDiscoveryRepository,
   ) {}
 
   async getOApps(chainId: ChainId): Promise<OAppsResponse | null> {
+    const discovery = await this.currDiscoveryRepository.find(chainId)
+
+    if (!discovery) {
+      return null
+    }
+
+    const addressInfo = outputToAddressInfo(discovery.discoveryOutput)
+
     const defaultConfigurations =
       await this.oAppDefaultConfigRepo.getBySourceChain(chainId)
 
@@ -62,10 +74,23 @@ class TrackingController {
         targetChainId: record.targetChainId,
         configuration: record.configuration,
       })),
+
+      addressInfo,
     }
   }
 }
 
+function outputToAddressInfo(output: DiscoveryOutput): AddressInfo[] {
+  const { eoas, contracts } = output
+
+  return contracts
+    .map((contract) => ({
+      address: contract.address,
+      name: contract.name,
+      verified: !contract.unverified,
+    }))
+    .concat(eoas.map((eoa) => ({ address: eoa, name: 'EOA', verified: true })))
+}
 function attachConfigurations(
   oApps: OAppRecord[],
   configurations: ResolvedConfigurationWithAppId[],

packages/libs/src/apis/TrackingApi.ts

@@ -4,6 +4,7 @@ import { ChainId } from '../chainId'
 import { branded, EthereumAddress } from '../utils'
 
 export {
+  AddressInfo,
   OAppsResponse,
   OAppWithConfigs,
   ResolvedConfiguration,
@@ -65,6 +66,13 @@ const OAppWithConfigs = z.object({
 
 type OAppWithConfigs = z.infer<typeof OAppWithConfigs>
 
+const AddressInfo = z.object({
+  address: branded(z.string(), EthereumAddress),
+  name: z.string(),
+  verified: z.boolean(),
+})
+type AddressInfo = z.infer<typeof AddressInfo>
+
 const OAppsResponse = z.object({
   sourceChainId: branded(z.number(), ChainId),
   oApps: z.array(OAppWithConfigs),
@@ -74,6 +82,7 @@ const OAppsResponse = z.object({
       configuration: OAppConfiguration,
     }),
   ),
+  addressInfo: z.array(AddressInfo),
 })
 
 type OAppsResponse = z.infer<typeof OAppsResponse>