[612] Implement node reputation scoring for decentralized RPC node selection

backend/config/sorobanNodeRegistry.ts

@@ -0,0 +1,92 @@
+/**
+ * Soroban RPC node registry — endpoints and metadata for decentralized selection.
+ * Issue #612
+ */
+
+export type SorobanNetwork = 'testnet' | 'mainnet' | 'futurenet';
+
+export interface SorobanNodeConfig {
+  /** Unique node identifier */
+  id: string;
+  /** Human-readable label */
+  name: string;
+  /** RPC endpoint URL */
+  endpoint: string;
+  /** Stellar/Soroban network */
+  network: SorobanNetwork;
+  /** Optional priority hint (lower = preferred when scores tie) */
+  priority?: number;
+  /** Arbitrary metadata (region, provider, etc.) */
+  metadata?: Record<string, string>;
+}
+
+/** Default Soroban RPC nodes for testnet and mainnet */
+export const DEFAULT_SOROBAN_NODES: SorobanNodeConfig[] = [
+  {
+    id: 'soroban-testnet-primary',
+    name: 'Stellar Testnet RPC (Primary)',
+    endpoint: 'https://soroban-testnet.stellar.org',
+    network: 'testnet',
+    priority: 1,
+    metadata: { provider: 'stellar', region: 'us-east' },
+  },
+  {
+    id: 'soroban-testnet-secondary',
+    name: 'Stellar Testnet RPC (Secondary)',
+    endpoint: 'https://soroban-testnet-alt.stellar.org',
+    network: 'testnet',
+    priority: 2,
+    metadata: { provider: 'stellar', region: 'eu-west' },
+  },
+  {
+    id: 'soroban-mainnet-primary',
+    name: 'Stellar Mainnet RPC (Primary)',
+    endpoint: 'https://soroban-mainnet.stellar.org',
+    network: 'mainnet',
+    priority: 1,
+    metadata: { provider: 'stellar', region: 'us-east' },
+  },
+  {
+    id: 'soroban-mainnet-secondary',
+    name: 'Stellar Mainnet RPC (Secondary)',
+    endpoint: 'https://soroban-mainnet-alt.stellar.org',
+    network: 'mainnet',
+    priority: 2,
+    metadata: { provider: 'stellar', region: 'ap-southeast' },
+  },
+];
+
+export class SorobanNodeRegistry {
+  private nodes = new Map<string, SorobanNodeConfig>();
+
+  constructor(initialNodes: SorobanNodeConfig[] = DEFAULT_SOROBAN_NODES) {
+    for (const node of initialNodes) {
+      this.register(node);
+    }
+  }
+
+  register(node: SorobanNodeConfig): void {
+    if (!node.id || !node.endpoint) {
+      throw new Error('Node id and endpoint are required');
+    }
+    this.nodes.set(node.id, { ...node });
+  }
+
+  unregister(nodeId: string): boolean {
+    return this.nodes.delete(nodeId);
+  }
+
+  get(nodeId: string): SorobanNodeConfig | undefined {
+    return this.nodes.get(nodeId);
+  }
+
+  getAll(): SorobanNodeConfig[] {
+    return [...this.nodes.values()];
+  }
+
+  getByNetwork(network: SorobanNetwork): SorobanNodeConfig[] {
+    return this.getAll().filter((n) => n.network === network);
+  }
+}
+
+export const sorobanNodeRegistry = new SorobanNodeRegistry();

backend/monitoring/__tests__/nodeReputationMetrics.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Tests for node reputation monitoring metrics — Issue #612
+ */
+
+import { NodeReputationMetrics } from '../nodeReputationMetrics';
+import { NodeReputationService } from '../../shared/soroban/NodeReputationService';
+
+describe('NodeReputationMetrics', () => {
+  let reputation: NodeReputationService;
+  let metrics: NodeReputationMetrics;
+  let now: number;
+
+  beforeEach(() => {
+    now = 3_000_000;
+    reputation = new NodeReputationService(undefined, undefined, undefined, () => now);
+    metrics = new NodeReputationMetrics(reputation);
+  });
+
+  afterEach(() => {
+    reputation.destroy();
+  });
+
+  it('collects per-node metrics including latency percentiles and score', () => {
+    reputation.registerNode('node-1');
+    for (let i = 0; i < 5; i++) {
+      reputation.recordOutcome({
+        nodeId: 'node-1',
+        success: true,
+        responseTimeMs: 100 + i * 10,
+        blockHeight: 5000,
+        timestamp: now + i,
+      });
+    }
+
+    const snapshot = metrics.collect();
+    expect(snapshot.totalNodes).toBe(1);
+    expect(snapshot.aliveNodes).toBe(1);
+    expect(snapshot.avgScore).toBeGreaterThan(0);
+
+    const names = snapshot.entries.map((e) => e.name);
+    expect(names).toContain('node_latency_p50_ms');
+    expect(names).toContain('node_latency_p95_ms');
+    expect(names).toContain('node_latency_p99_ms');
+    expect(names).toContain('node_success_rate');
+    expect(names).toContain('node_reputation_score');
+    expect(names).toContain('node_last_block_height');
+    expect(names).toContain('node_liveness');
+  });
+
+  it('reports circuit breaker state', () => {
+    reputation.registerNode('dead-node');
+    for (let i = 0; i < 5; i++) {
+      reputation.recordOutcome({
+        nodeId: 'dead-node',
+        success: false,
+        responseTimeMs: 100,
+        timestamp: now + i,
+      });
+    }
+    const snapshot = metrics.collect();
+    expect(snapshot.circuitBreakerOpen).toBe(true);
+    expect(snapshot.deadNodes).toBe(1);
+  });
+});

backend/monitoring/nodeReputationMetrics.ts

@@ -0,0 +1,81 @@
+/**
+ * Node reputation and health metrics for monitoring dashboards.
+ * Issue #612
+ */
+
+import type { NodeReputationService } from '../shared/soroban/NodeReputationService';
+import type { NodeMetrics, NodeReputationScore } from '../shared/soroban/types';
+
+export interface NodeMetricEntry {
+  name: string;
+  value: number;
+  nodeId: string;
+  timestamp: number;
+}
+
+export interface NodeReputationMetricsSnapshot {
+  entries: NodeMetricEntry[];
+  totalNodes: number;
+  aliveNodes: number;
+  deadNodes: number;
+  avgScore: number;
+  circuitBreakerOpen: boolean;
+}
+
+export class NodeReputationMetrics {
+  constructor(private readonly reputation: NodeReputationService) {}
+
+  collect(): NodeReputationMetricsSnapshot {
+    const dashboard = this.reputation.getDashboard();
+    const now = Date.now();
+    const entries: NodeMetricEntry[] = [];
+
+    for (const { nodeId, metrics, score } of dashboard.nodes) {
+      entries.push(
+        this.entry('node_success_rate', metrics.successRate, nodeId, now),
+        this.entry('node_latency_p50_ms', metrics.latency.p50, nodeId, now),
+        this.entry('node_latency_p95_ms', metrics.latency.p95, nodeId, now),
+        this.entry('node_latency_p99_ms', metrics.latency.p99, nodeId, now),
+        this.entry('node_last_block_height', metrics.lastBlockHeight, nodeId, now),
+        this.entry('node_liveness', metrics.isLive ? 1 : 0, nodeId, now),
+        this.entry('node_reputation_score', score.score, nodeId, now),
+        this.entry('node_consecutive_failures', metrics.consecutiveFailures, nodeId, now),
+        this.entry('node_is_dead', metrics.isDead ? 1 : 0, nodeId, now),
+      );
+    }
+
+    const scores = dashboard.nodes.map((n) => n.score.score);
+    const avgScore =
+      scores.length > 0 ? scores.reduce((a, b) => a + b, 0) / scores.length : 0;
+
+    return {
+      entries,
+      totalNodes: dashboard.nodes.length,
+      aliveNodes: dashboard.aliveCount,
+      deadNodes: dashboard.deadCount,
+      avgScore,
+      circuitBreakerOpen: dashboard.circuitBreaker.open,
+    };
+  }
+
+  getNodeMetrics(nodeId: string): NodeMetrics | undefined {
+    return this.reputation.getMetrics(nodeId);
+  }
+
+  getNodeScore(nodeId: string): NodeReputationScore {
+    return this.reputation.getScore(nodeId);
+  }
+
+  private entry(
+    name: string,
+    value: number,
+    nodeId: string,
+    timestamp: number,
+  ): NodeMetricEntry {
+    return { name, value, nodeId, timestamp };
+  }
+}
+
+import { nodeReputationService } from '../shared/soroban/NodeReputationService';
+
+export const nodeReputationMetrics = new NodeReputationMetrics(nodeReputationService);

backend/services/index.ts

@@ -328,3 +328,42 @@ export type {
 
 // ── DI Container ──────────────────────────────────────────────────────────────
 export { container, Container } from './container';
+
+// ── Soroban Node Reputation (#612) ───────────────────────────────────────────
+export {
+  SorobanNodeRegistry,
+  sorobanNodeRegistry,
+  DEFAULT_SOROBAN_NODES,
+} from '../config/sorobanNodeRegistry';
+export type { SorobanNodeConfig, SorobanNetwork } from '../config/sorobanNodeRegistry';
+export { NodeScoreCache } from '../shared/cache/nodeScoreCache';
+export type { NodeScoreRecord, NodeScoreCacheConfig } from '../shared/cache/nodeScoreCache';
+export {
+  NodeReputationService,
+  nodeReputationService,
+  NodeSelector,
+  nodeSelector,
+  REPUTATION_WEIGHTS,
+  REPUTATION_THRESHOLDS,
+} from '../shared/soroban';
+export type {
+  LivenessProvider,
+  OpsAlertDispatcher,
+  RandomSource,
+  LatencyPercentiles,
+  NodeMetrics,
+  NodeReputationScore,
+  NodeSelectionResult,
+  CircuitBreakerState,
+  RpcRequestOutcome,
+  NodeHealthSnapshot,
+  ReputationDashboardSnapshot,
+} from '../shared/soroban';
+export {
+  NodeReputationMetrics,
+  nodeReputationMetrics,
+} from '../monitoring/nodeReputationMetrics';
+export type {
+  NodeMetricEntry,
+  NodeReputationMetricsSnapshot,
+} from '../monitoring/nodeReputationMetrics';