Initial commit

src/infrastructure/compute/dscm-x/compute-distribution.service.ts

@@ -0,0 +1,149 @@
+// Compute Distribution Service
+// Task distribution: compute_cost + latency + sovereign_priority + risk_weight
+
+import prisma from '@/shared/database/prisma';
+import { Decimal } from '@prisma/client/runtime/library';
+import { v4 as uuidv4 } from 'uuid';
+import { dscmNodeManagerService } from './dscm-node-manager.service';
+
+
+export interface ComputeTaskRequest {
+  taskType: string;
+  taskPayload: Record<string, unknown>;
+  preferredNodeType?: string;
+  sovereignBankId?: string;
+}
+
+export class ComputeDistributionService {
+  /**
+   * Distribute compute task
+   */
+  async distributeTask(request: ComputeTaskRequest) {
+    // Get available nodes
+    let nodes;
+    if (request.preferredNodeType) {
+      nodes = await dscmNodeManagerService.getNodesByType(request.preferredNodeType);
+    } else {
+      nodes = await prisma.dscmNode.findMany({
+        where: {
+          status: 'active',
+        },
+      });
+    }
+
+    if (nodes.length === 0) {
+      throw new Error('No available compute nodes');
+    }
+
+    // Calculate distribution score for each node
+    const nodeScores = await Promise.all(
+      nodes.map(async (node) => {
+        const computeCost = node.computeCapacity ? parseFloat(node.computeCapacity.toString()) : 0;
+        const latency = node.latency || 0;
+        const sovereignPriority = node.sovereignPriority || 0;
+        const riskWeight = node.riskWeight ? parseFloat(node.riskWeight.toString()) : 0;
+
+        // Distribution score calculation
+        // Lower is better, so we use inverse for cost and risk
+        const distributionScore = 
+          (1 / (computeCost + 1)) + // Inverse cost
+          (latency / 1000) + // Normalize latency
+          (sovereignPriority / 10) + // Priority boost
+          riskWeight; // Risk penalty
+
+        return {
+          nodeId: node.nodeId,
+          nodeType: node.nodeType,
+          distributionScore,
+          computeCost,
+          latency,
+          sovereignPriority,
+          riskWeight,
+        };
+      })
+    );
+
+    // Select node with best (lowest) distribution score
+    const selectedNode = nodeScores.reduce((best, current) =>
+      current.distributionScore < best.distributionScore ? current : best
+    );
+
+    // Create compute task
+    const taskId = `TASK-${uuidv4()}`;
+
+    const task = await prisma.computeTask.create({
+      data: {
+        taskId,
+        nodeId: selectedNode.nodeId,
+        taskType: request.taskType,
+        taskPayload: request.taskPayload,
+        computeCost: new Decimal(selectedNode.computeCost),
+        latency: selectedNode.latency,
+        distributionScore: new Decimal(selectedNode.distributionScore),
+        status: 'pending',
+        assignedAt: new Date(),
+      },
+    });
+
+    return task;
+  }
+
+  /**
+   * Start task execution
+   */
+  async startTask(taskId: string) {
+    return await prisma.computeTask.update({
+      where: { taskId },
+      data: {
+        status: 'executing',
+        startedAt: new Date(),
+      },
+    });
+  }
+
+  /**
+   * Complete task
+   */
+  async completeTask(taskId: string, result: Record<string, unknown>) {
+    return await prisma.computeTask.update({
+      where: { taskId },
+      data: {
+        status: 'completed',
+        completedAt: new Date(),
+        result,
+      },
+    });
+  }
+
+  /**
+   * Get task by ID
+   */
+  async getTask(taskId: string) {
+    return await prisma.computeTask.findUnique({
+      where: { taskId },
+      include: {
+        node: true,
+      },
+    });
+  }
+
+  /**
+   * Get tasks for node
+   */
+  async getTasksForNode(nodeId: string, status?: string) {
+    const where: any = { nodeId };
+    if (status) {
+      where.status = status;
+    }
+
+    return await prisma.computeTask.findMany({
+      where,
+      orderBy: {
+        assignedAt: 'desc',
+      },
+    });
+  }
+}
+
+export const computeDistributionService = new ComputeDistributionService();
+

src/infrastructure/compute/dscm-x/cross-node-consensus.service.ts

@@ -0,0 +1,102 @@
+// Cross-Node Consensus Service
+// Deterministic results across nodes
+
+import prisma from '@/shared/database/prisma';
+import { computeDistributionService } from './compute-distribution.service';
+
+
+export class CrossNodeConsensusService {
+  /**
+   * Execute task across multiple nodes and reach consensus
+   */
+  async executeWithConsensus(
+    taskType: string,
+    taskPayload: Record<string, unknown>,
+    nodeIds: string[]
+  ) {
+    // Create tasks on multiple nodes
+    const tasks = [];
+
+    for (const nodeId of nodeIds) {
+      const node = await prisma.dscmNode.findUnique({
+        where: { nodeId },
+      });
+
+      if (!node || node.status !== 'active') {
+        continue;
+      }
+
+      // Create task on this node
+      const task = await prisma.computeTask.create({
+        data: {
+          taskId: `CONSENSUS-TASK-${nodeId}-${Date.now()}`,
+          nodeId,
+          taskType,
+          taskPayload,
+          status: 'executing',
+          assignedAt: new Date(),
+          startedAt: new Date(),
+        },
+      });
+
+      tasks.push(task);
+    }
+
+    // Wait for all tasks to complete (in production, would use async coordination)
+    // Collect results
+    const results = tasks.map((task) => ({
+      nodeId: task.nodeId,
+      taskId: task.taskId,
+      result: {},
+    }));
+
+    // Apply consensus logic
+    const consensusResult = this.applyConsensusLogic(results);
+
+    // Update all tasks with consensus result
+    for (const task of tasks) {
+      await prisma.computeTask.update({
+        where: { taskId: task.taskId },
+        data: {
+          status: 'completed',
+          completedAt: new Date(),
+          result: {
+            consensusResult,
+            deterministic: true,
+          },
+        },
+      });
+    }
+
+    return consensusResult;
+  }
+
+  /**
+   * Apply consensus logic to results
+   */
+  private applyConsensusLogic(results: Array<{ nodeId: string; result: Record<string, unknown> }>): Record<string, unknown> {
+    // Simple majority consensus
+    // In production, would use Byzantine Fault Tolerant consensus algorithm
+    return {
+      consensusType: 'majority',
+      participatingNodes: results.length,
+      consensusReached: true,
+      result: {},
+    };
+  }
+
+  /**
+   * Verify deterministic result
+   */
+  async verifyDeterministicResult(
+    taskType: string,
+    taskPayload: Record<string, unknown>,
+    expectedResult: Record<string, unknown>
+  ): Promise<boolean> {
+    // In production, would re-execute on different nodes and compare results
+    return true;
+  }
+}
+
+export const crossNodeConsensusService = new CrossNodeConsensusService();
+

src/infrastructure/compute/dscm-x/dscm-node-manager.service.ts

@@ -0,0 +1,100 @@
+// DSCM-X Node Manager Service
+// Node registration and management (SEN, CEN, FXN, CTN)
+
+import prisma from '@/shared/database/prisma';
+import { Decimal } from '@prisma/client/runtime/library';
+import { v4 as uuidv4 } from 'uuid';
+
+
+export interface NodeRegistrationRequest {
+  nodeType: string; // SEN, CEN, FXN, CTN
+  nodeName: string;
+  sovereignBankId?: string;
+  computeCapacity?: number;
+  latency?: number;
+  sovereignPriority?: number;
+  riskWeight?: number;
+}
+
+export class DscmNodeManagerService {
+  /**
+   * Register compute node
+   */
+  async registerNode(request: NodeRegistrationRequest) {
+    const nodeId = `DSCM-${request.nodeType}-${uuidv4()}`;
+
+    return await prisma.dscmNode.create({
+      data: {
+        nodeId,
+        sovereignBankId: request.sovereignBankId,
+        nodeType: request.nodeType,
+        nodeName: request.nodeName,
+        computeCapacity: request.computeCapacity ? new Decimal(request.computeCapacity) : null,
+        latency: request.latency || null,
+        sovereignPriority: request.sovereignPriority || null,
+        riskWeight: request.riskWeight ? new Decimal(request.riskWeight) : null,
+        status: 'active',
+        registeredAt: new Date(),
+        lastHeartbeat: new Date(),
+      },
+    });
+  }
+
+  /**
+   * Update node heartbeat
+   */
+  async updateHeartbeat(nodeId: string) {
+    return await prisma.dscmNode.update({
+      where: { nodeId },
+      data: {
+        lastHeartbeat: new Date(),
+      },
+    });
+  }
+
+  /**
+   * Get node by ID
+   */
+  async getNode(nodeId: string) {
+    return await prisma.dscmNode.findUnique({
+      where: { nodeId },
+    });
+  }
+
+  /**
+   * Get nodes by type
+   */
+  async getNodesByType(nodeType: string) {
+    return await prisma.dscmNode.findMany({
+      where: {
+        nodeType,
+        status: 'active',
+      },
+    });
+  }
+
+  /**
+   * Get nodes for sovereign bank
+   */
+  async getNodesForBank(sovereignBankId: string) {
+    return await prisma.dscmNode.findMany({
+      where: {
+        sovereignBankId,
+        status: 'active',
+      },
+    });
+  }
+
+  /**
+   * Update node status
+   */
+  async updateNodeStatus(nodeId: string, status: string) {
+    return await prisma.dscmNode.update({
+      where: { nodeId },
+      data: { status },
+    });
+  }
+}
+
+export const dscmNodeManagerService = new DscmNodeManagerService();
+

src/infrastructure/compute/dscm-x/dscm.routes.ts

@@ -0,0 +1,38 @@
+// DSCM-X API Routes
+
+import { Router } from 'express';
+import { dscmNodeManagerService } from './dscm-node-manager.service';
+import { computeDistributionService } from './compute-distribution.service';
+import { federatedAiService } from './federated-ai.service';
+
+const router = Router();
+
+router.post('/nodes/register', async (req, res, next) => {
+  try {
+    const node = await dscmNodeManagerService.registerNode(req.body);
+    res.status(201).json(node);
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post('/tasks/distribute', async (req, res, next) => {
+  try {
+    const task = await computeDistributionService.distributeTask(req.body);
+    res.json(task);
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post('/federated-ai', async (req, res, next) => {
+  try {
+    const task = await federatedAiService.executeFederatedAiTask(req.body);
+    res.json(task);
+  } catch (error) {
+    next(error);
+  }
+});
+
+export default router;
+

src/infrastructure/compute/dscm-x/federated-ai.service.ts

@@ -0,0 +1,119 @@
+// Federated AI Service
+// Federated AI for risk/compliance tasks
+
+import prisma from '@/shared/database/prisma';
+import { v4 as uuidv4 } from 'uuid';
+import { dscmNodeManagerService } from './dscm-node-manager.service';
+
+
+export interface FederatedAiRequest {
+  aiType: string; // risk_analysis, compliance_check, threat_detection
+  taskPayload: Record<string, unknown>;
+  participatingNodeIds?: string[];
+}
+
+export class FederatedAiService {
+  /**
+   * Execute federated AI task
+   */
+  async executeFederatedAiTask(request: FederatedAiRequest) {
+    // Get participating nodes
+    let nodeIds: string[];
+    if (request.participatingNodeIds && request.participatingNodeIds.length > 0) {
+      nodeIds = request.participatingNodeIds;
+    } else {
+      // Get all active nodes for federated computation
+      const nodes = await prisma.dscmNode.findMany({
+        where: {
+          status: 'active',
+          nodeType: {
+            in: ['SEN', 'CEN'], // Use Sovereign Execution Nodes and Compliance Execution Nodes
+          },
+        },
+        take: 5, // Limit to 5 nodes for federated task
+      });
+      nodeIds = nodes.map((n) => n.nodeId);
+    }
+
+    if (nodeIds.length === 0) {
+      throw new Error('No nodes available for federated AI task');
+    }
+
+    // Create federated AI task on primary node
+    const primaryNodeId = nodeIds[0];
+    const taskId = `FED-AI-${uuidv4()}`;
+
+    const task = await prisma.federatedAiTask.create({
+      data: {
+        taskId,
+        nodeId: primaryNodeId,
+        aiType: request.aiType,
+        taskPayload: request.taskPayload,
+        federatedNodes: nodeIds,
+        status: 'running',
+        startedAt: new Date(),
+      },
+    });
+
+    // In production, would distribute task across nodes and wait for consensus
+    // For now, simulate consensus result
+    const consensusResult = await this.reachConsensus(taskId, nodeIds);
+
+    await prisma.federatedAiTask.update({
+      where: { taskId },
+      data: {
+        status: 'consensus_reached',
+        consensusResult,
+        consensusReachedAt: new Date(),
+      },
+    });
+
+    return task;
+  }
+
+  /**
+   * Reach consensus across federated nodes
+   */
+  private async reachConsensus(
+    taskId: string,
+    nodeIds: string[]
+  ): Promise<Record<string, unknown>> {
+    // Simulate consensus algorithm
+    // In production, would collect results from all nodes and apply consensus logic
+    return {
+      consensusType: 'majority',
+      participatingNodes: nodeIds,
+      consensusReached: true,
+      result: {},
+    };
+  }
+
+  /**
+   * Get federated AI task
+   */
+  async getTask(taskId: string) {
+    return await prisma.federatedAiTask.findUnique({
+      where: { taskId },
+      include: {
+        node: true,
+      },
+    });
+  }
+
+  /**
+   * Get tasks by AI type
+   */
+  async getTasksByAiType(aiType: string) {
+    return await prisma.federatedAiTask.findMany({
+      where: {
+        aiType,
+      },
+      orderBy: {
+        startedAt: 'desc',
+      },
+    });
+  }
+}
+
+export const federatedAiService = new FederatedAiService();
+

src/infrastructure/compute/dscm-x/smart-contract-execution.service.ts

@@ -0,0 +1,47 @@
+// Smart Contract Execution Service
+// Distributed smart contract execution
+
+import { computeDistributionService } from './compute-distribution.service';
+
+export class SmartContractExecutionService {
+  /**
+   * Execute smart contract on distributed nodes
+   */
+  async executeSmartContract(
+    contractId: string,
+    contractCode: string,
+    parameters: Record<string, unknown>
+  ) {
+    // Distribute contract execution task
+    const task = await computeDistributionService.distributeTask({
+      taskType: 'smart_contract',
+      taskPayload: {
+        contractId,
+        contractCode,
+        parameters,
+      },
+      preferredNodeType: 'SEN', // Use Sovereign Execution Nodes
+    });
+
+    // Start execution
+    await computeDistributionService.startTask(task.taskId);
+
+    // In production, would execute contract and wait for deterministic result
+    // For now, simulate execution
+    const result = {
+      contractId,
+      executionResult: {},
+      deterministic: true,
+    };
+
+    await computeDistributionService.completeTask(task.taskId, result);
+
+    return {
+      taskId: task.taskId,
+      result,
+    };
+  }
+}
+
+export const smartContractExecutionService = new SmartContractExecutionService();
+

src/infrastructure/compute/gpu-edge/gpu-edge-deployment.service.ts

@@ -0,0 +1,126 @@
+// GPU Edge Deployment Service
+// 325-region deployment orchestration
+
+import prisma from '@/shared/database/prisma';
+import { v4 as uuidv4 } from 'uuid';
+import { logger } from '@/infrastructure/monitoring/logger';
+import { gpuEdgeNodeService } from './gpu-edge-node.service';
+
+
+export interface GpuEdgeDeploymentRequest {
+  regionId: string;
+  nodeTypes: Array<'MGN' | 'QGN' | 'ZKN' | 'SAN'>;
+  gpuCapacityPerNode: number;
+  quantumSafeTunnelingEnabled: boolean;
+}
+
+export interface GpuEdgeDeploymentResult {
+  deploymentId: string;
+  regionId: string;
+  nodesCreated: number;
+  status: string;
+}
+
+export class GpuEdgeDeploymentService {
+  /**
+   * Deploy GPU edge nodes to a region
+   * Supports deployment across 325 regions globally
+   */
+  async deployToRegion(
+    request: GpuEdgeDeploymentRequest
+  ): Promise<GpuEdgeDeploymentResult> {
+    logger.info('GPU Edge: Deploying to region', { request });
+
+    const deploymentId = `GPU-DEPLOY-${uuidv4()}`;
+
+    // Step 1: Verify or create region
+    let region = await prisma.gpuEdgeRegion.findUnique({
+      where: { regionId: request.regionId },
+    });
+
+    if (!region) {
+      region = await prisma.gpuEdgeRegion.create({
+        data: {
+          regionId: request.regionId,
+          regionName: `Region ${request.regionId}`,
+          status: 'active',
+        },
+      });
+    }
+
+    // Step 2: Create nodes for each node type
+    const nodesCreated: string[] = [];
+
+    for (const nodeType of request.nodeTypes) {
+      const nodeResult = await gpuEdgeNodeService.createGpuEdgeNode({
+        nodeType,
+        regionId: request.regionId,
+        nodeName: `${nodeType}-${request.regionId}-${uuidv4().substring(0, 8)}`,
+        gpuCapacity: request.gpuCapacityPerNode,
+        networkAddress: `6g://${request.regionId}/${nodeType}`,
+        quantumSafeTunnelingEnabled: request.quantumSafeTunnelingEnabled,
+      });
+
+      nodesCreated.push(nodeResult.nodeId);
+    }
+
+    // Step 3: Create deployment record
+    const deployment = await prisma.gpuEdgeDeployment.create({
+      data: {
+        deploymentId,
+        regionId: request.regionId,
+        nodeTypes: request.nodeTypes as any,
+        nodesCreated: nodesCreated as any,
+        status: 'completed',
+        deployedAt: new Date(),
+      },
+    });
+
+    logger.info('GPU Edge: Deployment completed', {
+      deploymentId,
+      nodesCreated: nodesCreated.length,
+    });
+
+    return {
+      deploymentId,
+      regionId: request.regionId,
+      nodesCreated: nodesCreated.length,
+      status: deployment.status,
+    };
+  }
+
+  /**
+   * Get deployment by ID
+   */
+  async getDeployment(deploymentId: string) {
+    return await prisma.gpuEdgeDeployment.findUnique({
+      where: { deploymentId },
+      include: {
+        region: true,
+      },
+    });
+  }
+
+  /**
+   * Get deployments for region
+   */
+  async getDeploymentsForRegion(regionId: string) {
+    return await prisma.gpuEdgeDeployment.findMany({
+      where: { regionId },
+      orderBy: { deployedAt: 'desc' },
+    });
+  }
+
+  /**
+   * Get all active regions
+   */
+  async getAllActiveRegions() {
+    return await prisma.gpuEdgeRegion.findMany({
+      where: { status: 'active' },
+      orderBy: { regionName: 'asc' },
+    });
+  }
+}
+
+export const gpuEdgeDeploymentService = new GpuEdgeDeploymentService();
+

src/infrastructure/compute/gpu-edge/gpu-edge-monitoring.service.ts

@@ -0,0 +1,128 @@
+// GPU Edge Monitoring Service
+// Node health, performance, quantum-safe tunneling monitoring
+
+import prisma from '@/shared/database/prisma';
+import { logger } from '@/infrastructure/monitoring/logger';
+
+
+export interface GpuEdgeHealthCheck {
+  nodeId: string;
+  health: 'healthy' | 'degraded' | 'unhealthy';
+  gpuUtilization: number;
+  latency: number;
+  quantumTunnelStatus: 'active' | 'inactive';
+  issues: string[];
+}
+
+export class GpuEdgeMonitoringService {
+  /**
+   * Perform health check on GPU edge node
+   */
+  async performHealthCheck(nodeId: string): Promise<GpuEdgeHealthCheck> {
+    const node = await prisma.gpuEdgeNode.findUnique({
+      where: { nodeId },
+    });
+
+    if (!node) {
+      throw new Error(`Node not found: ${nodeId}`);
+    }
+
+    // Simulate health check (in production, would query actual node)
+    const gpuUtilization = Math.random() * 100; // 0-100%
+    const latency = Math.random() * 2; // 0-2ms
+    const quantumTunnelStatus = node.quantumSafeTunnelingEnabled
+      ? 'active'
+      : 'inactive';
+
+    const issues: string[] = [];
+
+    let health: 'healthy' | 'degraded' | 'unhealthy' = 'healthy';
+
+    if (gpuUtilization > 90) {
+      issues.push('High GPU utilization');
+      health = 'degraded';
+    }
+
+    if (latency > 1) {
+      issues.push('Latency exceeds 1ms threshold');
+      health = 'degraded';
+    }
+
+    if (node.status !== 'active') {
+      issues.push('Node status is not active');
+      health = 'unhealthy';
+    }
+
+    // Save health check record
+    await prisma.gpuEdgeTask.create({
+      data: {
+        taskId: `HEALTH-${Date.now()}`,
+        nodeId,
+        taskType: 'health_check',
+        status: 'completed',
+        result: {
+          health,
+          gpuUtilization,
+          latency,
+          quantumTunnelStatus,
+          issues,
+        } as any,
+      },
+    });
+
+    return {
+      nodeId,
+      health,
+      gpuUtilization,
+      latency,
+      quantumTunnelStatus,
+      issues,
+    };
+  }
+
+  /**
+   * Get monitoring metrics for node
+   */
+  async getNodeMetrics(nodeId: string) {
+    const tasks = await prisma.gpuEdgeTask.findMany({
+      where: { nodeId },
+      orderBy: { createdAt: 'desc' },
+      take: 100,
+    });
+
+    return {
+      nodeId,
+      totalTasks: tasks.length,
+      completedTasks: tasks.filter((t) => t.status === 'completed').length,
+      failedTasks: tasks.filter((t) => t.status === 'failed').length,
+      averageLatency:
+        tasks.reduce((sum, t) => {
+          const result = t.result as any;
+          return sum + (result?.latency || 0);
+        }, 0) / tasks.length || 0,
+    };
+  }
+
+  /**
+   * Get monitoring metrics for region
+   */
+  async getRegionMetrics(regionId: string) {
+    const nodes = await prisma.gpuEdgeNode.findMany({
+      where: { regionId },
+    });
+
+    const metrics = await Promise.all(
+      nodes.map((node) => this.getNodeMetrics(node.nodeId))
+    );
+
+    return {
+      regionId,
+      totalNodes: nodes.length,
+      activeNodes: nodes.filter((n) => n.status === 'active').length,
+      nodeMetrics: metrics,
+    };
+  }
+}
+
+export const gpuEdgeMonitoringService = new GpuEdgeMonitoringService();
+

src/infrastructure/compute/gpu-edge/gpu-edge-node.service.ts

@@ -0,0 +1,109 @@
+// GPU Edge Node Service
+// GPU edge node management (MGN, QGN, ZKN, SAN types)
+
+import prisma from '@/shared/database/prisma';
+import { v4 as uuidv4 } from 'uuid';
+import { logger } from '@/infrastructure/monitoring/logger';
+
+
+export interface GpuEdgeNodeRequest {
+  nodeType: 'MGN' | 'QGN' | 'ZKN' | 'SAN'; // Metaverse GPU Node, Quantum Gateway Node, ZK Validation Node, Sovereign AI Node
+  regionId: string;
+  nodeName: string;
+  gpuCapacity: number; // GPU units
+  networkAddress: string;
+  quantumSafeTunnelingEnabled: boolean;
+}
+
+export interface GpuEdgeNodeResult {
+  nodeId: string;
+  nodeType: string;
+  regionId: string;
+  status: string;
+}
+
+export class GpuEdgeNodeService {
+  /**
+   * Create GPU edge node
+   * Node types:
+   * - MGN: Metaverse GPU Node (metaverse rendering)
+   * - QGN: Quantum Gateway Node (quantum proxy operations)
+   * - ZKN: ZK Validation Node (ZK ledger validation)
+   * - SAN: Sovereign AI Node (AI behavioral engines)
+   */
+  async createGpuEdgeNode(
+    request: GpuEdgeNodeRequest
+  ): Promise<GpuEdgeNodeResult> {
+    logger.info('GPU Edge: Creating edge node', { request });
+
+    const nodeId = `GPU-EDGE-${uuidv4()}`;
+
+    const node = await prisma.gpuEdgeNode.create({
+      data: {
+        nodeId,
+        nodeType: request.nodeType,
+        regionId: request.regionId,
+        nodeName: request.nodeName,
+        gpuCapacity: request.gpuCapacity,
+        networkAddress: request.networkAddress,
+        quantumSafeTunnelingEnabled: request.quantumSafeTunnelingEnabled,
+        status: 'active',
+      },
+    });
+
+    logger.info('GPU Edge: Node created', { nodeId });
+
+    return {
+      nodeId,
+      nodeType: node.nodeType,
+      regionId: node.regionId,
+      status: node.status,
+    };
+  }
+
+  /**
+   * Get node by ID
+   */
+  async getNode(nodeId: string) {
+    return await prisma.gpuEdgeNode.findUnique({
+      where: { nodeId },
+      include: {
+        region: true,
+        tasks: true,
+      },
+    });
+  }
+
+  /**
+   * Get nodes by type
+   */
+  async getNodesByType(nodeType: string) {
+    return await prisma.gpuEdgeNode.findMany({
+      where: { nodeType, status: 'active' },
+      orderBy: { createdAt: 'desc' },
+    });
+  }
+
+  /**
+   * Get nodes for region
+   */
+  async getNodesForRegion(regionId: string) {
+    return await prisma.gpuEdgeNode.findMany({
+      where: { regionId, status: 'active' },
+      orderBy: { createdAt: 'desc' },
+    });
+  }
+
+  /**
+   * Update node status
+   */
+  async updateNodeStatus(nodeId: string, status: string) {
+    return await prisma.gpuEdgeNode.update({
+      where: { nodeId },
+      data: { status },
+    });
+  }
+}
+
+export const gpuEdgeNodeService = new GpuEdgeNodeService();
+

src/infrastructure/compute/gpu-edge/gpu-edge-routing.service.ts

@@ -0,0 +1,142 @@
+// GPU Edge Routing Service
+// 6G network routing with ultra-low latency (<1ms)
+
+import prisma from '@/shared/database/prisma';
+import { v4 as uuidv4 } from 'uuid';
+import { logger } from '@/infrastructure/monitoring/logger';
+
+
+export interface GpuEdgeRoutingRequest {
+  sourceRegionId: string;
+  targetRegionId: string;
+  taskType: 'metaverse' | 'quantum' | 'zk' | 'ai';
+  latencyRequirement?: number; // Milliseconds (default: <1ms)
+}
+
+export interface GpuEdgeRoutingResult {
+  routeId: string;
+  path: string[];
+  estimatedLatency: number;
+  quantumSafe: boolean;
+}
+
+export class GpuEdgeRoutingService {
+  /**
+   * Calculate optimal 6G route for GPU edge task
+   * Ultra-low latency requirement: <1ms
+   */
+  async calculateOptimalRoute(
+    request: GpuEdgeRoutingRequest
+  ): Promise<GpuEdgeRoutingResult> {
+    logger.info('GPU Edge: Calculating optimal 6G route', { request });
+
+    const latencyRequirement = request.latencyRequirement || 1; // <1ms default
+
+    // Step 1: Get available nodes in source and target regions
+    const sourceNodes = await prisma.gpuEdgeNode.findMany({
+      where: {
+        regionId: request.sourceRegionId,
+        status: 'active',
+      },
+    });
+
+    const targetNodes = await prisma.gpuEdgeNode.findMany({
+      where: {
+        regionId: request.targetRegionId,
+        status: 'active',
+      },
+    });
+
+    if (sourceNodes.length === 0 || targetNodes.length === 0) {
+      throw new Error('No nodes available in source or target region');
+    }
+
+    // Step 2: Select appropriate node type based on task
+    const nodeTypeMap: Record<string, string> = {
+      metaverse: 'MGN',
+      quantum: 'QGN',
+      zk: 'ZKN',
+      ai: 'SAN',
+    };
+
+    const requiredNodeType = nodeTypeMap[request.taskType] || 'MGN';
+
+    // Step 3: Find nodes with required type
+    const sourceNode = sourceNodes.find((n) => n.nodeType === requiredNodeType);
+    const targetNode = targetNodes.find((n) => n.nodeType === requiredNodeType);
+
+    if (!sourceNode || !targetNode) {
+      throw new Error(`No ${requiredNodeType} nodes available`);
+    }
+
+    // Step 4: Calculate route path (6G network)
+    const path = [sourceNode.nodeId, targetNode.nodeId];
+
+    // Step 5: Estimate latency (6G ultra-low latency: <1ms)
+    const estimatedLatency = 0.5; // 0.5ms for 6G
+
+    // Step 6: Check quantum-safe tunneling
+    const quantumSafe =
+      sourceNode.quantumSafeTunnelingEnabled &&
+      targetNode.quantumSafeTunnelingEnabled;
+
+    // Step 7: Create route record
+    const routeId = `GPU-ROUTE-${uuidv4()}`;
+
+    await prisma.gpuEdgeNetwork.create({
+      data: {
+        routeId,
+        sourceRegionId: request.sourceRegionId,
+        targetRegionId: request.targetRegionId,
+        sourceNodeId: sourceNode.nodeId,
+        targetNodeId: targetNode.nodeId,
+        path: path as any,
+        estimatedLatency,
+        quantumSafe,
+        latencyRequirement,
+        status: 'active',
+      },
+    });
+
+    logger.info('GPU Edge: Route calculated', {
+      routeId,
+      estimatedLatency,
+    });
+
+    return {
+      routeId,
+      path,
+      estimatedLatency,
+      quantumSafe,
+    };
+  }
+
+  /**
+   * Get route by ID
+   */
+  async getRoute(routeId: string) {
+    return await prisma.gpuEdgeNetwork.findUnique({
+      where: { routeId },
+    });
+  }
+
+  /**
+   * Get routes for region pair
+   */
+  async getRoutesForRegionPair(
+    sourceRegionId: string,
+    targetRegionId: string
+  ) {
+    return await prisma.gpuEdgeNetwork.findMany({
+      where: {
+        sourceRegionId,
+        targetRegionId,
+        status: 'active',
+      },
+      orderBy: { estimatedLatency: 'asc' },
+    });
+  }
+}
+
+export const gpuEdgeRoutingService = new GpuEdgeRoutingService();
+

src/infrastructure/compute/gpu-edge/gpu-edge.routes.ts

@@ -0,0 +1,139 @@
+// GPU Edge API Routes
+
+import { Router } from 'express';
+import { gpuEdgeNodeService } from './gpu-edge-node.service';
+import { gpuEdgeDeploymentService } from './gpu-edge-deployment.service';
+import { gpuEdgeRoutingService } from './gpu-edge-routing.service';
+import { gpuEdgeMonitoringService } from './gpu-edge-monitoring.service';
+import { zeroTrustAuthMiddleware } from '@/integration/api-gateway/middleware/auth.middleware';
+
+const router = Router();
+
+/**
+ * @route POST /api/gpu-edge/node
+ * @desc Create GPU edge node
+ */
+router.post(
+  '/node',
+  zeroTrustAuthMiddleware,
+  async (req, res, next) => {
+    try {
+      const result = await gpuEdgeNodeService.createGpuEdgeNode(req.body);
+      res.json(result);
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+/**
+ * @route GET /api/gpu-edge/node/:nodeId
+ * @desc Get node by ID
+ */
+router.get(
+  '/node/:nodeId',
+  zeroTrustAuthMiddleware,
+  async (req, res, next) => {
+    try {
+      const node = await gpuEdgeNodeService.getNode(req.params.nodeId);
+      if (!node) {
+        return res.status(404).json({ error: 'Node not found' });
+      }
+      res.json(node);
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+/**
+ * @route POST /api/gpu-edge/deploy
+ * @desc Deploy GPU edge nodes to region
+ */
+router.post(
+  '/deploy',
+  zeroTrustAuthMiddleware,
+  async (req, res, next) => {
+    try {
+      const result = await gpuEdgeDeploymentService.deployToRegion(req.body);
+      res.json(result);
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+/**
+ * @route GET /api/gpu-edge/regions
+ * @desc Get all active regions
+ */
+router.get(
+  '/regions',
+  zeroTrustAuthMiddleware,
+  async (req, res, next) => {
+    try {
+      const regions = await gpuEdgeDeploymentService.getAllActiveRegions();
+      res.json(regions);
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+/**
+ * @route POST /api/gpu-edge/route
+ * @desc Calculate optimal 6G route
+ */
+router.post(
+  '/route',
+  zeroTrustAuthMiddleware,
+  async (req, res, next) => {
+    try {
+      const result = await gpuEdgeRoutingService.calculateOptimalRoute(req.body);
+      res.json(result);
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+/**
+ * @route POST /api/gpu-edge/monitor/health/:nodeId
+ * @desc Perform health check on node
+ */
+router.post(
+  '/monitor/health/:nodeId',
+  zeroTrustAuthMiddleware,
+  async (req, res, next) => {
+    try {
+      const result = await gpuEdgeMonitoringService.performHealthCheck(
+        req.params.nodeId
+      );
+      res.json(result);
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+/**
+ * @route GET /api/gpu-edge/monitor/metrics/node/:nodeId
+ * @desc Get monitoring metrics for node
+ */
+router.get(
+  '/monitor/metrics/node/:nodeId',
+  zeroTrustAuthMiddleware,
+  async (req, res, next) => {
+    try {
+      const metrics = await gpuEdgeMonitoringService.getNodeMetrics(
+        req.params.nodeId
+      );
+      res.json(metrics);
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+export default router;
+