chore: Add domains endpoint

.env

@@ -2,10 +2,4 @@ DB_NAME=postgres
 DB_PASS=postgres
 DB_PORT=5432
 DB_USERNAME=postgres
-DB_HOST=db
-SHARED_CONFIG_URL="https://ipfs.io/ipfs/bafkreiasnla2ya55of6nwm3swjstip4q2ixfa3t6tvixyibclfovxnerte"
-1_METADATA='{"id": 1, "rpcUrl": "http://evm1:8545"}'
-2_METADATA='{"id": 2, "rpcUrl": "http://evm2:8545"}'
-3_METADATA='{"id": 3, "rpcUrl": "ws://substrate-pallet:9944"}'
-
-ENV_DOMAINS='[1,2,3]'
+DB_HOST=db

schema.graphql

@@ -67,6 +67,8 @@ type Domain @entity {
   id: ID!
   type: String!
   name: String!
+  iconURL: String
+  explorerURL: String
   routesFrom: [Route!] @derivedFrom(field: "fromDomain")
   routesTo: [Route!] @derivedFrom(field: "toDomain")
   token: [Token!] @derivedFrom(field: "domain")

src/api/controllers/DomainsController.ts

@@ -0,0 +1,30 @@
+/*
+The Licensed Work is (c) 2024 Sygma
+SPDX-License-Identifier: LGPL-3.0-only
+*/
+import type { FastifyReply, FastifyRequest } from "fastify";
+import type { DataSource } from "typeorm";
+
+import { logger } from "../../utils/logger";
+import { DomainsService } from "../services/dataAccess/domains.service";
+
+export class DomainsController {
+  private domainsService: DomainsService;
+
+  constructor(dataSource: DataSource) {
+    this.domainsService = new DomainsService(dataSource);
+  }
+
+  public async getDomains(
+    request: FastifyRequest,
+    reply: FastifyReply,
+  ): Promise<void> {
+    try {
+      const domainsResult = await this.domainsService.findDomains({});
+      await reply.status(200).send(domainsResult);
+    } catch (error) {
+      logger.error("Error occurred when fetching domains", error);
+      await reply.status(500).send({ error: "Internal server error" });
+    }
+  }
+}

src/api/routes/domains.routes.ts

@@ -0,0 +1,18 @@
+/*
+The Licensed Work is (c) 2024 Sygma
+SPDX-License-Identifier: LGPL-3.0-only
+*/
+import type { FastifyInstance } from "fastify";
+
+import { DomainsController } from "../controllers/DomainsController";
+import { domainsSchema } from "../schemas/domains.schema";
+
+export async function domainRoutes(server: FastifyInstance): Promise<void> {
+  const domainsController = new DomainsController(server.db);
+  server.get(
+    "/domains",
+    { schema: domainsSchema },
+    domainsController.getDomains.bind(domainsController),
+  );
+  return Promise.resolve();
+}

src/api/routes/index.ts

@@ -4,8 +4,10 @@ SPDX-License-Identifier: LGPL-3.0-only
 */
 import type { FastifyInstance } from "fastify";
 
+import { domainRoutes } from "./domains.routes";
 import { transferRoutes } from "./transfers.routes";
 
 export async function registerRoutes(server: FastifyInstance): Promise<void> {
   await server.register(transferRoutes, { prefix: "/api" });
+  await server.register(domainRoutes, { prefix: "/api" });
 }

src/api/schemas/domains.schema.ts

@@ -0,0 +1,25 @@
+/*
+The Licensed Work is (c) 2024 Sygma
+SPDX-License-Identifier: LGPL-3.0-only
+*/
+import { domainMetadataSchema, domainSchema } from ".";
+
+export const domainsSchema = {
+  summary: "Get domains",
+  response: {
+    200: {
+      description: "List of domains",
+      content: {
+        "application/json": {
+          schema: {
+            type: "array",
+            items: {
+              ...domainSchema.properties,
+              ...domainMetadataSchema.properties,
+            },
+          },
+        },
+      },
+    },
+  },
+};

src/api/schemas/index.ts

@@ -25,6 +25,14 @@ export const domainSchema = {
   },
 };
 
+export const domainMetadataSchema = {
+  type: "object",
+  properties: {
+    iconURL: { type: "string", example: "https://example.com/icon1.png" },
+    explorerURL: { type: "string", example: "https://explorer.com/1" },
+  },
+};
+
 export const tokenSchema = {
   tpye: "object",
   properties: {

src/api/services/dataAccess/domains.service.ts

@@ -0,0 +1,24 @@
+/*
+The Licensed Work is (c) 2024 Sygma
+SPDX-License-Identifier: LGPL-3.0-only
+*/
+import type { DataSource, FindOptionsWhere, Repository } from "typeorm";
+
+import { Domain } from "../../../model";
+
+export class DomainsService {
+  private domainRepository: Repository<Domain>;
+  constructor(dataSource: DataSource) {
+    this.domainRepository = dataSource.getRepository(Domain);
+  }
+
+  public async findDomains(where: FindOptionsWhere<Domain>): Promise<Domain[]> {
+    const domains = await this.domainRepository.find({
+      where,
+      order: {
+        id: "ASC",
+      },
+    });
+    return domains;
+  }
+}

src/indexer/config/envLoader.ts

@@ -15,6 +15,8 @@ export type DomainMetadata = {
   domainId: number;
   rpcUrl: string;
   domainGateway?: string;
+  iconUrl?: string;
+  explorerUrl?: string;
 };
 
 export type EnvVariables = {

src/indexer/evmIndexer/evmProcessor.ts

@@ -72,7 +72,7 @@ export class EVMProcessor implements IProcessor {
 
     for (const block of ctx.blocks) {
       this.logger.info(
-        `Processing block ${block.header.height} on networ ${domain.name}(${domain.id})`,
+        `Processing block ${block.header.height} on network ${domain.name}(${domain.id})`,
       );
       for (const log of block.logs) {
         try {

src/indexer/substrateIndexer/substrateParser.ts

@@ -73,7 +73,7 @@ export class SubstrateParser implements ISubstrateParser {
     });
     if (!resource) {
       throw new NotFoundError(
-        `Unssupported resource with ID ${event.resourceId}`,
+        `Unsupported resource with ID ${event.resourceId}`,
       );
     }
 
@@ -218,7 +218,7 @@ export class SubstrateParser implements ISubstrateParser {
     });
     if (!resource) {
       throw new NotFoundError(
-        `Unssupported resource with ID ${event.resourceId}`,
+        `Unsupported resource with ID ${event.resourceId}`,
       );
     }
 

src/indexer/substrateIndexer/substrateProcessor.ts

@@ -87,7 +87,7 @@ export class SubstrateProcessor implements IProcessor {
     const fees: FeeCollectedData[] = [];
     for (const block of ctx.blocks) {
       this.logger.info(
-        `processing bloc ${block.header.height} on networ ${domain.name}(${domain.id})`,
+        `Processing block ${block.header.height} on network ${domain.name}(${domain.id})`,
       );
       for (const event of block.events) {
         try {

src/main_init.ts

@@ -7,7 +7,7 @@ import type { EntityManager } from "typeorm";
 
 import type { Domain as DomainConfig } from "./indexer/config";
 import { fetchSharedConfig } from "./indexer/config";
-import { getEnv } from "./indexer/config/envLoader";
+import { getDomainMetadata, getEnv } from "./indexer/config/envLoader";
 import { Domain, Resource, Token } from "./model";
 import { initDatabase } from "./utils";
 
@@ -18,21 +18,33 @@ export async function init(): Promise<void> {
   const dataSource = await initDatabase(envVars.dbConfig);
   const sharedConfig = await fetchSharedConfig(envVars.sharedConfigURL);
 
-  await insertDomains(sharedConfig.domains, dataSource.manager);
+  await insertDomains(
+    sharedConfig.domains,
+    dataSource.manager,
+    envVars.envDomains,
+  );
   await dataSource.destroy();
 }
 
 async function insertDomains(
   domains: Array<DomainConfig>,
   manager: EntityManager,
+  supportedDomainsIDs: number[],
 ): Promise<void> {
-  for (const domain of domains) {
+  for (const domainID of supportedDomainsIDs) {
+    const domain = domains.find((domain) => domain.id == domainID);
+    if (!domain) {
+      throw new Error(`domain with id ${domainID} not found in shared-config`);
+    }
+    const domainMetadata = getDomainMetadata(domain.id.toString());
     await manager.upsert(
       Domain,
       {
         id: domain.id.toString(),
         type: domain.type,
         name: domain.name,
+        iconURL: domainMetadata.iconUrl ?? "",
+        explorerURL: domainMetadata.explorerUrl ?? "",
       },
       ["id"],
     );

src/model/generated/domain.model.ts

@@ -21,6 +21,12 @@ export class Domain {
     @StringColumn_({nullable: false})
     name!: string
 
+    @StringColumn_({nullable: true})
+    iconURL!: string | undefined | null
+
+    @StringColumn_({nullable: true})
+    explorerURL!: string | undefined | null
+
     @OneToMany_(() => Route, e => e.fromDomain)
     routesFrom!: Route[]