Merge pull request #151 from nafiuishaaq/feat/network

Feat/network

Author: mijinummi

apps/api-service/src/gas-estimation/__tests__/gas-estimation.spec.ts

@@ -6,6 +6,7 @@ import { Repository } from 'typeorm';
 import { getRepositoryToken } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { DynamicPricingService } from '../services/dynamic-pricing.service';
+import { NetworkConfigService } from '../config/network-config.service';
 import { NetworkMonitorService } from '../services/network-monitor.service';
 import { GasPriceHistoryService } from '../services/gas-price-history.service';
 import { GasEstimationController } from '../gas-estimation.controller';
@@ -23,6 +24,7 @@ describe('Dynamic Gas Estimation Engine', () => {
       controllers: [GasEstimationController],
       providers: [
         DynamicPricingService,
+        NetworkConfigService,
         NetworkMonitorService,
         GasPriceHistoryService,
         {

apps/api-service/src/gas-estimation/__tests__/network-config.service.spec.ts

@@ -0,0 +1,33 @@
+import { NetworkConfigService } from '../config/network-config.service';
+
+describe('NetworkConfigService', () => {
+  let service: NetworkConfigService;
+
+  beforeEach(() => {
+    service = new NetworkConfigService();
+  });
+
+  it('returns supported networks from a single source of truth', () => {
+    const networks = service.getSupportedNetworks();
+
+    expect(networks.map((network) => network.chainId)).toEqual([
+      'soroban-mainnet',
+      'soroban-testnet',
+    ]);
+    expect(networks[0]).toHaveProperty('chainName');
+    expect(networks[0]).toHaveProperty('baseFeePerInstruction');
+  });
+
+  it('resolves network metadata for a known chain', () => {
+    expect(service.getNetworkConfig('soroban-mainnet')).toMatchObject({
+      chainId: 'soroban-mainnet',
+      chainName: 'Soroban Mainnet',
+    });
+  });
+
+  it('rejects unknown chains', () => {
+    expect(() => service.getNetworkConfig('unknown-chain')).toThrow(
+      'Unsupported chainId: unknown-chain',
+    );
+  });
+});

apps/api-service/src/gas-estimation/config/network-config.service.ts

@@ -0,0 +1,60 @@
+import { Injectable } from '@nestjs/common';
+
+export interface GasEstimationNetworkConfig {
+  chainId: string;
+  chainName: string;
+  rpcUrl?: string;
+  baseFeePerInstruction: number;
+  historicalAverageGasPrice: number;
+  defaultBlockGasLimit: number;
+  baselineLoad: number;
+  averageBlockTimeMs: number;
+}
+
+@Injectable()
+export class NetworkConfigService {
+  private readonly networks: GasEstimationNetworkConfig[] = [
+    {
+      chainId: 'soroban-mainnet',
+      chainName: 'Soroban Mainnet',
+      rpcUrl:
+        process.env.GAS_ESTIMATION_SOROBAN_MAINNET_RPC_URL ||
+        process.env.GAS_ESTIMATION_SOROBAN_RPC_URL,
+      baseFeePerInstruction: 1000,
+      historicalAverageGasPrice: 1000,
+      defaultBlockGasLimit: 100000000,
+      baselineLoad: 40,
+      averageBlockTimeMs: 4000,
+    },
+    {
+      chainId: 'soroban-testnet',
+      chainName: 'Soroban Testnet',
+      rpcUrl:
+        process.env.GAS_ESTIMATION_SOROBAN_TESTNET_RPC_URL ||
+        process.env.GAS_ESTIMATION_SOROBAN_RPC_URL,
+      baseFeePerInstruction: 1000,
+      historicalAverageGasPrice: 1000,
+      defaultBlockGasLimit: 100000000,
+      baselineLoad: 30,
+      averageBlockTimeMs: 4500,
+    },
+  ];
+
+  getSupportedNetworks(): GasEstimationNetworkConfig[] {
+    return [...this.networks];
+  }
+
+  getSupportedChainIds(): string[] {
+    return this.networks.map((network) => network.chainId);
+  }
+
+  getNetworkConfig(chainId: string): GasEstimationNetworkConfig {
+    const network = this.networks.find((candidate) => candidate.chainId === chainId);
+
+    if (!network) {
+      throw new Error(`Unsupported chainId: ${chainId}`);
+    }
+
+    return network;
+  }
+}

apps/api-service/src/gas-estimation/gas-estimation.controller.ts

@@ -13,6 +13,7 @@ import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';
 import { DynamicPricingService } from './services/dynamic-pricing.service';
 import { GasPriceHistoryService } from './services/gas-price-history.service';
 import { NetworkMonitorService } from './services/network-monitor.service';
+import { NetworkConfigService } from './config/network-config.service';
 import {
   GetGasEstimateDto,
   GasEstimateResponseDto,
@@ -29,6 +30,7 @@ export class GasEstimationController {
     private dynamicPricingService: DynamicPricingService,
     private gasPriceHistoryService: GasPriceHistoryService,
     private networkMonitorService: NetworkMonitorService,
+    private networkConfigService: NetworkConfigService,
   ) {}
 
   /**
@@ -290,7 +292,7 @@ export class GasEstimationController {
       status: 'healthy',
       timestamp: new Date().toISOString(),
       version: '1.0.0',
-      supportedChains: ['soroban-mainnet', 'soroban-testnet'],
+      supportedChains: this.networkConfigService.getSupportedChainIds(),
     };
   }
 

apps/api-service/src/gas-estimation/gas-estimation.module.ts

@@ -2,6 +2,7 @@ import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { ScheduleModule } from '@nestjs/schedule';
 import { GasEstimationController } from './gas-estimation.controller';
+import { NetworkConfigService } from './config/network-config.service';
 import { NetworkMonitorService } from './services/network-monitor.service';
 import { DynamicPricingService } from './services/dynamic-pricing.service';
 import { GasPriceHistoryService } from './services/gas-price-history.service';
@@ -14,11 +15,13 @@ import { GasPriceHistory } from './entities/gas-price-history.entity';
   ],
   controllers: [GasEstimationController],
   providers: [
+    NetworkConfigService,
     NetworkMonitorService,
     DynamicPricingService,
     GasPriceHistoryService,
   ],
   exports: [
+    NetworkConfigService,
     NetworkMonitorService,
     DynamicPricingService,
     GasPriceHistoryService,

apps/api-service/src/gas-estimation/index.ts

@@ -1,5 +1,6 @@
 export { GasEstimationModule } from './gas-estimation.module';
 export { GasEstimationController } from './gas-estimation.controller';
+export * from './config/network-config.service';
 export * from './services/network-monitor.service';
 export * from './services/dynamic-pricing.service';
 export * from './services/gas-price-history.service';

apps/api-service/src/gas-estimation/services/network-monitor.service.ts

@@ -1,6 +1,7 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { NetworkMetrics, GasPriceSnapshot } from '../interfaces/gas-price.interface';
 import { Cron, CronExpression } from '@nestjs/schedule';
+import { NetworkConfigService } from '../config/network-config.service';
 
 /**
  * NetworkMonitorService
@@ -15,6 +16,8 @@ export class NetworkMonitorService {
   private metricsCache: Map<string, NetworkMetrics> = new Map();
   private priceSnapshotCache: Map<string, GasPriceSnapshot> = new Map();
 
+  constructor(private readonly networkConfigService: NetworkConfigService) {}
+
   /**
    * Get current network metrics for a chain
    */
@@ -51,8 +54,7 @@ export class NetworkMonitorService {
   @Cron(CronExpression.EVERY_10_SECONDS)
   async updateNetworkMetrics(): Promise<void> {
     try {
-      // Update for all monitored chains
-      const chainIds = ['soroban-testnet', 'soroban-mainnet'];
+      const chainIds = this.networkConfigService.getSupportedChainIds();
 
       for (const chainId of chainIds) {
         const metrics = await this.fetchNetworkMetricsFromRpc(chainId);
@@ -75,19 +77,22 @@ export class NetworkMonitorService {
   private async fetchNetworkMetricsFromRpc(chainId: string): Promise<NetworkMetrics> {
     // This would connect to actual Soroban RPC in production
     // For now, return mock data with some randomization to simulate network conditions
+    const network = this.networkConfigService.getNetworkConfig(chainId);
 
-    const baseLoad = 35; // baseline network load
+    const baseLoad = network.baselineLoad;
     const randomFluctuation = Math.random() * 30 - 15; // -15 to +15
     const congestionLevel = Math.max(0, Math.min(100, baseLoad + randomFluctuation));
 
     return {
       congestionLevel,
       gasPoolUtilization: congestionLevel * 0.8,
-      averageTransactionTime: 4000 + Math.random() * 2000, // 4-6 seconds
+      averageTransactionTime: network.averageBlockTimeMs + Math.random() * 2000,
       pendingTransactionCount: Math.floor(congestionLevel * 10),
-      lastBlockGasUsed: 75000000 + Math.floor(Math.random() * 25000000),
-      lastBlockGasLimit: 100000000,
-      historicalAverageGasPrice: 1000, // stroops per instruction
+      lastBlockGasUsed:
+        network.defaultBlockGasLimit * 0.75 +
+        Math.floor(Math.random() * (network.defaultBlockGasLimit * 0.25)),
+      lastBlockGasLimit: network.defaultBlockGasLimit,
+      historicalAverageGasPrice: network.historicalAverageGasPrice,
       priceVolatility: congestionLevel * 0.5, // volatility increases with congestion
     };
   }
@@ -96,13 +101,14 @@ export class NetworkMonitorService {
    * Create a gas price snapshot based on current metrics
    */
   private async createGasPriceSnapshot(chainId: string): Promise<GasPriceSnapshot> {
+    const network = this.networkConfigService.getNetworkConfig(chainId);
     const metrics = await this.getNetworkMetrics(chainId);
 
     // Calculate surge multiplier based on congestion
     const surgeMultiplier = this.calculateSurgeMultiplier(metrics.congestionLevel);
 
     // Base price (stroops per instruction) - Soroban default
-    const basePrice = 1000;
+    const basePrice = network.baseFeePerInstruction;
     const recommendedFeeRate = basePrice * surgeMultiplier;
 
     // Estimate price confidence (higher during stable, lower during volatile periods)
@@ -111,7 +117,7 @@ export class NetworkMonitorService {
     return {
       id: `snapshot-${chainId}-${Date.now()}`,
       chainId,
-      chainName: chainId === 'soroban-mainnet' ? 'Soroban Mainnet' : 'Soroban Testnet',
+      chainName: network.chainName,
       timestamp: new Date(),
       baseFeePerInstruction: basePrice,
       surgePriceMultiplier: surgeMultiplier,
@@ -153,6 +159,7 @@ export class NetworkMonitorService {
     chainId: string,
     hoursBack: number = 24,
   ): Promise<GasPriceSnapshot[]> {
+    const network = this.networkConfigService.getNetworkConfig(chainId);
     // In production, query database for historical snapshots
     const snapshots: GasPriceSnapshot[] = [];
     const now = Date.now();
@@ -164,15 +171,17 @@ export class NetworkMonitorService {
       snapshots.push({
         id: `hist-${chainId}-${i}`,
         chainId,
-        chainName: chainId === 'soroban-mainnet' ? 'Soroban Mainnet' : 'Soroban Testnet',
+        chainName: network.chainName,
         timestamp,
-        baseFeePerInstruction: 1000,
+        baseFeePerInstruction: network.baseFeePerInstruction,
         surgePriceMultiplier: this.calculateSurgeMultiplier(congestionAtTime),
-        recommendedFeeRate: 1000 * this.calculateSurgeMultiplier(congestionAtTime),
+        recommendedFeeRate:
+          network.baseFeePerInstruction *
+          this.calculateSurgeMultiplier(congestionAtTime),
         networkLoad: congestionAtTime,
         memoryPoolSize: 0,
         transactionCount: Math.floor(congestionAtTime * 10),
-        averageBlockTime: 4000 + Math.random() * 2000,
+        averageBlockTime: network.averageBlockTimeMs + Math.random() * 2000,
         volatilityIndex: congestionAtTime * 0.4,
         priceConfidence: Math.max(40, 100 - congestionAtTime),
       });

apps/api-service/src/performance-monitoring/__tests__/monitoring-hooks.service.spec.ts

@@ -0,0 +1,61 @@
+import { MonitoringHooksService } from '../services/monitoring-hooks.service';
+
+describe('MonitoringHooksService', () => {
+  let service: MonitoringHooksService;
+
+  beforeEach(() => {
+    service = new MonitoringHooksService();
+  });
+
+  it('increments counters using label-insensitive ordering', () => {
+    service.incrementCounter('http_requests_total', 1, {
+      statusCode: 200,
+      method: 'GET',
+    });
+    service.incrementCounter('http_requests_total', 2, {
+      method: 'GET',
+      statusCode: 200,
+    });
+
+    const snapshot = service.getSnapshot();
+
+    expect(snapshot.counters).toEqual([
+      {
+        name: 'http_requests_total',
+        labels: { method: 'GET', statusCode: '200' },
+        value: 3,
+      },
+    ]);
+  });
+
+  it('tracks gauges and histogram summaries', () => {
+    service.setGauge('http_requests_in_flight', 2, { method: 'POST' });
+    service.observeHistogram('http_request_duration_ms', 100, {
+      endpoint: '/api/scanner',
+    });
+    service.observeHistogram('http_request_duration_ms', 300, {
+      endpoint: '/api/scanner',
+    });
+
+    const snapshot = service.getSnapshot();
+
+    expect(snapshot.gauges).toEqual([
+      {
+        name: 'http_requests_in_flight',
+        labels: { method: 'POST' },
+        value: 2,
+      },
+    ]);
+    expect(snapshot.histograms).toEqual([
+      {
+        name: 'http_request_duration_ms',
+        labels: { endpoint: '/api/scanner' },
+        count: 2,
+        sum: 400,
+        min: 100,
+        max: 300,
+        average: 200,
+      },
+    ]);
+  });
+});

apps/api-service/src/performance-monitoring/controllers/metrics.controller.ts

@@ -0,0 +1,15 @@
+import { Controller, Get } from '@nestjs/common';
+import { ApiOperation, ApiTags } from '@nestjs/swagger';
+import { MonitoringHooksService } from '../services/monitoring-hooks.service';
+
+@ApiTags('Monitoring')
+@Controller('metrics')
+export class MetricsController {
+  constructor(private readonly monitoringHooksService: MonitoringHooksService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'Expose in-memory monitoring metrics snapshot' })
+  getMetrics() {
+    return this.monitoringHooksService.getSnapshot();
+  }
+}

apps/api-service/src/performance-monitoring/index.ts

@@ -0,0 +1,5 @@
+export * from './performance-monitoring.module';
+export * from './services/performance-metric.service';
+export * from './services/monitoring-hooks.service';
+export * from './middleware/performance-logging.middleware';
+export * from './entities/api-performance-metric.entity';