Feat/discovery

apps/api/src/app.module.ts

@@ -26,6 +26,8 @@ import { IntelligenceHubModule } from './intelligence-hub/stellar/intelligence-h
 import { AssetDiscoveryModule } from './api/assets/discovery/stellar/asset-discovery.module';
 import { RecommendationMetricsModule } from './metrics/recommendations/recommendation-metrics.module';
 import { StellarEcosystemMetricsModule } from './metrics/ecosystem/stellar/stellar-ecosystem-metrics.module';
+import { StellarProviderDiscoveryModule } from '../../../src/providers/discovery/stellar/stellar-provider-discovery.module';
+import { AssetCoverageModule } from '../../../src/analytics/coverage/stellar/asset-coverage.module';
 import { RouteInsightsExporterModule } from './exporters/routes/stellar/route-insights-exporter.module';
 
 @Module({
@@ -65,6 +67,8 @@ import { RouteInsightsExporterModule } from './exporters/routes/stellar/route-in
     AssetDiscoveryModule,
     RecommendationMetricsModule,
     StellarEcosystemMetricsModule,
+    StellarProviderDiscoveryModule,
+    AssetCoverageModule,
     ThrottlerModule.forRoot([
       {
         ttl: 60000,
@@ -89,4 +93,4 @@ import { RouteInsightsExporterModule } from './exporters/routes/stellar/route-in
     AppService,
   ],
 })
-export class AppModule {}
+export class AppModule {}

src/analytics/coverage/stellar/asset-coverage.controller.ts

@@ -0,0 +1,13 @@
+import { Controller, Get } from '@nestjs/common';
+import { AssetCoverageService } from './asset-coverage.service';
+import { CoverageReport } from './asset-coverage.types';
+
+@Controller('coverage/stellar')
+export class AssetCoverageController {
+  constructor(private readonly coverageService: AssetCoverageService) {}
+
+  @Get()
+  async getCoverageReport(): Promise<CoverageReport> {
+    return this.coverageService.getCoverageReport();
+  }
+}

src/analytics/coverage/stellar/asset-coverage.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { AssetCoverageController } from './asset-coverage.controller';
+import { AssetCoverageService } from './asset-coverage.service';
+
+@Module({
+  controllers: [AssetCoverageController],
+  providers: [AssetCoverageService],
+})
+export class AssetCoverageModule {}

src/analytics/coverage/stellar/asset-coverage.service.ts

@@ -0,0 +1,57 @@
+import { Injectable } from '@nestjs/common';
+import { Asset, CoverageReport, Route } from './asset-coverage.types';
+
+@Injectable()
+export class AssetCoverageService {
+  async getCoverageReport(): Promise<CoverageReport> {
+    const allAssets = await this.getAllAssets();
+    const allRoutes = await this.getAllRoutes();
+
+    const supportedAssets = new Set<Asset>();
+    allRoutes.forEach((route) => {
+      supportedAssets.add(route.sourceAsset);
+      supportedAssets.add(route.destinationAsset);
+    });
+
+    const supportedAssetsArray = Array.from(supportedAssets);
+    const unsupportedAssets = allAssets.filter(
+      (asset) =>
+        !supportedAssetsArray.find(
+          (supportedAsset) => supportedAsset.id === asset.id,
+        ),
+    );
+
+    const coveragePercentage =
+      (supportedAssetsArray.length / allAssets.length) * 100;
+
+    return {
+      supportedAssets: supportedAssetsArray,
+      unsupportedAssets,
+      coveragePercentage,
+    };
+  }
+
+  private async getAllAssets(): Promise<Asset[]> {
+    // In a real application, this would fetch data from a database or API
+    return [
+      { id: 'XLM', name: 'Stellar Lumens' },
+      { id: 'USDC', name: 'USD Coin' },
+      { id: 'ARST', name: 'Argentine Peso' },
+      { id: 'BRLT', name: 'Brazilian Real' },
+    ];
+  }
+
+  private async getAllRoutes(): Promise<Route[]> {
+    // In a real application, this would fetch data from a database or API
+    const xlm: Asset = { id: 'XLM', name: 'Stellar Lumens' };
+    const usdc: Asset = { id: 'USDC', name: 'USD Coin' };
+    const arst: Asset = { id: 'ARST', name: 'Argentine Peso' };
+
+    return [
+      { sourceAsset: xlm, destinationAsset: usdc },
+      { sourceAsset: usdc, destinationAsset: xlm },
+      { sourceAsset: xlm, destinationAsset: arst },
+      { sourceAsset: arst, destinationAsset: xlm },
+    ];
+  }
+}

src/analytics/coverage/stellar/asset-coverage.types.ts

@@ -0,0 +1,17 @@
+export interface Asset {
+  id: string;
+  name: string;
+  // Add any other relevant asset properties here
+}
+
+export interface Route {
+  sourceAsset: Asset;
+  destinationAsset: Asset;
+  // Add any other relevant route properties here
+}
+
+export interface CoverageReport {
+  supportedAssets: Asset[];
+  unsupportedAssets: Asset[];
+  coveragePercentage: number;
+}

src/providers/discovery/stellar/stellar-provider-discovery.controller.ts

@@ -0,0 +1,27 @@
+import { Controller, Get, Param, Post } from '@nestjs/common';
+import { StellarProviderDiscoveryService } from './stellar-provider-discovery.service';
+import { StellarProviderMetadata } from './stellar-provider-discovery.types';
+
+@Controller('providers/stellar')
+export class StellarProviderDiscoveryController {
+  constructor(
+    private readonly discoveryService: StellarProviderDiscoveryService,
+  ) {}
+
+  @Get()
+  async getAllProviders(): Promise<StellarProviderMetadata[]> {
+    return this.discoveryService.getAll();
+  }
+
+  @Get(':id')
+  async getProviderById(
+    @Param('id') id: string,
+  ): Promise<StellarProviderMetadata> {
+    const provider = this.discoveryService.get(id);
+    if (!provider) {
+      // In a real application, you'd throw a NotFoundException here
+      throw new Error('Provider not found');
+    }
+    return provider;
+  }
+}

src/providers/discovery/stellar/stellar-provider-discovery.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { StellarProviderDiscoveryController } from './stellar-provider-discovery.controller';
+import { StellarProviderDiscoveryService } from './stellar-provider-discovery.service';
+
+@Module({
+  controllers: [StellarProviderDiscoveryController],
+  providers: [StellarProviderDiscoveryService],
+})
+export class StellarProviderDiscoveryModule {}