diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 000000000..599dd2562
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1,73 @@
+# Amana Project Code Ownership
+# 
+# This file defines code ownership and required review rules for critical paths.
+# PRs touching these paths require approval from designated code owners.
+#
+# Syntax: <path> <owner1> <owner2> ...
+# Owners are GitHub usernames or team references (@org/team-name)
+
+# ── Smart Contracts ────────────────────────────────────────────────────────────
+# Critical escrow contract logic
+contracts/amana_escrow/**                @KingFRANKHOOD
+
+# ── Backend: Core Services ─────────────────────────────────────────────────────
+# Authentication and authorization
+backend/src/auth/**                      @KingFRANKHOOD
+backend/src/common/guards/**             @KingFRANKHOOD
+backend/src/common/decorators/**         @KingFRANKHOOD
+
+# Blockchain integration and contract interaction
+backend/src/modules/blockchain/**        @KingFRANKHOOD
+backend/src/modules/transactions/**      @KingFRANKHOOD
+
+# Trade and dispute critical paths
+backend/src/modules/claims/**            @KingFRANKHOOD
+backend/src/modules/disputes/**          @KingFRANKHOOD
+
+# Observability and audit logging
+backend/src/common/interceptors/**       @KingFRANKHOOD
+backend/src/common/filters/**            @KingFRANKHOOD
+
+# Database migrations
+backend/src/migrations/**                @KingFRANKHOOD
+
+# ── Backend: Supporting Services ───────────────────────────────────────────────
+# User and admin management
+backend/src/modules/user/**              @KingFRANKHOOD
+backend/src/modules/admin/**             @KingFRANKHOOD
+
+# Savings and governance
+backend/src/modules/savings/**           @KingFRANKHOOD
+backend/src/modules/governance/**        @KingFRANKHOOD
+
+# Notifications and webhooks
+backend/src/modules/notifications/**     @KingFRANKHOOD
+backend/src/modules/webhooks/**          @KingFRANKHOOD
+
+# ── Frontend: Core Components ──────────────────────────────────────────────────
+# Dashboard and contract details
+frontend/app/components/dashboard/**     @KingFRANKHOOD
+
+# Trade and dispute flows
+frontend/app/components/trade/**         @KingFRANKHOOD
+frontend/app/components/disputes/**      @KingFRANKHOOD
+
+# ── Configuration & Infrastructure ────────────────────────────────────────────
+# Environment and deployment
+backend/.env.example                     @KingFRANKHOOD
+backend/Dockerfile                       @KingFRANKHOOD
+backend/docker-compose.yml               @KingFRANKHOOD
+
+# Package dependencies
+backend/package.json                     @KingFRANKHOOD
+frontend/package.json                    @KingFRANKHOOD
+
+# ── Testing ────────────────────────────────────────────────────────────────────
+# E2E and critical path tests
+backend/test/**                          @KingFRANKHOOD
+
+# ── Documentation ──────────────────────────────────────────────────────────────
+# Governance and contribution guidelines
+CONTRIBUTING.md                          @KingFRANKHOOD
+README.md                                @KingFRANKHOOD
+GOALS_PR_DESCRIPTION.md                  @KingFRANKHOOD
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 000000000..3397b8b50
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,193 @@
+# Contributing to Amana
+
+Thank you for your interest in contributing to Amana! This document outlines our contribution guidelines, code ownership policy, and review requirements.
+
+## Code Ownership & Review Requirements
+
+We maintain a CODEOWNERS file (`.github/CODEOWNERS`) that defines ownership of critical paths in the codebase. This ensures domain expertise is applied to high-impact changes.
+
+### Critical Paths Requiring Review
+
+The following areas require approval from designated code owners before merging:
+
+#### Smart Contracts
+- **Path**: `contracts/amana_escrow/**`
+- **Reason**: Core escrow logic affecting fund security and dispute resolution
+- **Owner**: @KingFRANKHOOD
+
+#### Backend: Authentication & Authorization
+- **Path**: `backend/src/auth/**`, `backend/src/common/guards/**`
+- **Reason**: Security-critical authentication and access control
+- **Owner**: @KingFRANKHOOD
+
+#### Backend: Blockchain Integration
+- **Path**: `backend/src/modules/blockchain/**`, `backend/src/modules/transactions/**`
+- **Reason**: Contract interaction and transaction integrity
+- **Owner**: @KingFRANKHOOD
+
+#### Backend: Trade & Dispute Critical Paths
+- **Path**: `backend/src/modules/claims/**`, `backend/src/modules/disputes/**`
+- **Reason**: Core business logic for trade lifecycle and dispute resolution
+- **Owner**: @KingFRANKHOOD
+
+#### Backend: Observability & Audit
+- **Path**: `backend/src/common/interceptors/**`, `backend/src/common/filters/**`
+- **Reason**: Request tracing, audit logging, and incident debugging
+- **Owner**: @KingFRANKHOOD
+
+#### Database Migrations
+- **Path**: `backend/src/migrations/**`
+- **Reason**: Schema changes affect all services and data integrity
+- **Owner**: @KingFRANKHOOD
+
+#### Frontend: Dashboard & Contract Details
+- **Path**: `frontend/app/components/dashboard/**`
+- **Reason**: User-facing contract and trade information
+- **Owner**: @KingFRANKHOOD
+
+### How Code Ownership Works
+
+1. **Branch Protection**: PRs touching owned paths require approval from the designated code owner
+2. **Automatic Checks**: GitHub branch protection rules enforce this requirement
+3. **Exceptions**: Code owners can approve exceptions for urgent fixes or emergency patches
+
+## Contribution Workflow
+
+### 1. Create a Feature Branch
+
+```bash
+git checkout -b <type>/<issue-number>-<description>
+```
+
+**Branch naming conventions**:
+- `feat/` - New features
+- `fix/` - Bug fixes
+- `hardening/` - Security or reliability improvements
+- `observability/` - Logging, monitoring, tracing
+- `governance/` - Policy, documentation, ownership
+- `refactor/` - Code improvements without behavior changes
+
+**Example**:
+```bash
+git checkout -b hardening/e2e-critical-path-tests
+git checkout -b observability/request-correlation-audit-logs
+git checkout -b governance/codeowners-required-review
+```
+
+### 2. Make Your Changes
+
+- Follow the existing code style and patterns
+- Write tests for new functionality
+- Update documentation as needed
+- Ensure all checks pass locally
+
+### 3. Commit Your Changes
+
+Use clear, descriptive commit messages:
+
+```bash
+git commit -m "feat: add E2E tests for critical trade path"
+git commit -m "observability: add correlation ID and audit logging"
+git commit -m "governance: add CODEOWNERS and review policy"
+```
+
+### 4. Push and Create a PR
+
+```bash
+git push origin <your-branch>
+```
+
+Then create a PR on GitHub with:
+- Clear title describing the change
+- Description of what changed and why
+- Reference to related issues (e.g., `Closes #177`)
+- Screenshots or test results if applicable
+
+### 5. Code Review
+
+- Address feedback from code owners
+- Ensure all CI checks pass
+- Request re-review after making changes
+
+## Testing Requirements
+
+### Unit Tests
+- Required for all new services and utilities
+- Run: `npm run test`
+
+### E2E Tests
+- Required for critical path changes (trade, dispute, auth)
+- Run: `npm run test:e2e`
+
+### Integration Tests
+- Required for blockchain and database interactions
+- Run: `npm run test:integration`
+
+## Commit Message Format
+
+We follow conventional commits for clear history:
+
+```
+<type>(<scope>): <subject>
+
+<body>
+
+<footer>
+```
+
+**Types**:
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation
+- `style`: Code style (formatting, missing semicolons, etc.)
+- `refactor`: Code refactoring
+- `perf`: Performance improvement
+- `test`: Adding or updating tests
+- `chore`: Build, dependencies, tooling
+
+**Scopes**:
+- `auth`: Authentication module
+- `blockchain`: Blockchain integration
+- `claims`: Claims module
+- `disputes`: Disputes module
+- `observability`: Logging and tracing
+- `governance`: Code ownership and policy
+
+**Examples**:
+```
+feat(claims): add E2E tests for critical trade path
+observability(audit): add request correlation IDs and structured logs
+governance: add CODEOWNERS and required review rules
+```
+
+## Incident Tracing with Correlation IDs
+
+When debugging production issues, use correlation IDs to trace requests:
+
+```bash
+# Find all logs for a specific request
+grep "correlation-id-uuid" logs/*.log
+
+# Trace through database mutations
+SELECT * FROM audit_logs WHERE correlation_id = 'uuid' ORDER BY timestamp;
+
+# Check contract events
+grep "correlation-id-uuid" contract-events.log
+```
+
+See `OBSERVABILITY.md` for detailed runbook.
+
+## Security Considerations
+
+- Never commit secrets or private keys
+- Use environment variables for sensitive configuration
+- Follow OWASP guidelines for web security
+- Report security issues privately to maintainers
+
+## Questions?
+
+- Check existing issues and PRs
+- Review the README and documentation
+- Ask in discussions or contact maintainers
+
+Thank you for contributing to Amana!
diff --git a/OBSERVABILITY.md b/OBSERVABILITY.md
new file mode 100644
index 000000000..09bff1f46
--- /dev/null
+++ b/OBSERVABILITY.md
@@ -0,0 +1,399 @@
+# Observability & Incident Tracing Runbook
+
+This document explains how to use correlation IDs and audit logs to trace incidents across the Amana system.
+
+## Overview
+
+Every API request generates a unique correlation ID that flows through:
+1. HTTP request headers
+2. Database mutations (audit logs)
+3. Background jobs and listeners
+4. Smart contract events
+
+This enables end-to-end tracing for debugging and forensic analysis.
+
+## Correlation ID Format
+
+- **Header**: `X-Correlation-ID`
+- **Format**: UUID v4 (e.g., `550e8400-e29b-41d4-a716-446655440000`)
+- **Lifetime**: Entire request lifecycle from API → DB → contract
+
+## Tracing a Request
+
+### 1. Find the Correlation ID
+
+From HTTP response headers:
+```bash
+curl -i https://api.amana.io/claims \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"patientName": "John Doe", ...}'
+
+# Response includes:
+# X-Correlation-ID: 550e8400-e29b-41d4-a716-446655440000
+```
+
+Or from error response:
+```json
+{
+  "statusCode": 500,
+  "message": "Internal server error",
+  "correlationId": "550e8400-e29b-41d4-a716-446655440000"
+}
+```
+
+### 2. Query Audit Logs
+
+Find all mutations for a request:
+
+```sql
+-- Find all audit entries for a correlation ID
+SELECT 
+  correlation_id,
+  timestamp,
+  action,
+  actor,
+  resource_type,
+  resource_id,
+  status_code,
+  duration_ms,
+  success,
+  error_message
+FROM audit_logs
+WHERE correlation_id = '550e8400-e29b-41d4-a716-446655440000'
+ORDER BY timestamp ASC;
+```
+
+### 3. Trace Specific Resource
+
+Find all mutations affecting a trade or dispute:
+
+```sql
+-- Find all changes to a specific claim
+SELECT 
+  correlation_id,
+  timestamp,
+  action,
+  actor,
+  status_code,
+  duration_ms,
+  error_message
+FROM audit_logs
+WHERE resource_id = 'claim-uuid-here'
+  AND resource_type = 'CLAIM'
+ORDER BY timestamp DESC;
+
+-- Find all disputes for a claim
+SELECT 
+  correlation_id,
+  timestamp,
+  action,
+  actor,
+  status_code
+FROM audit_logs
+WHERE resource_id = 'claim-uuid-here'
+  AND resource_type = 'DISPUTE'
+ORDER BY timestamp DESC;
+```
+
+### 4. Find Actions by Actor
+
+Identify all mutations by a specific user:
+
+```sql
+-- Find all actions by a user
+SELECT 
+  correlation_id,
+  timestamp,
+  action,
+  resource_type,
+  resource_id,
+  status_code,
+  success
+FROM audit_logs
+WHERE actor = 'user@example.com'
+  AND timestamp > NOW() - INTERVAL '24 hours'
+ORDER BY timestamp DESC;
+```
+
+### 5. Identify Failed Operations
+
+Find errors and failures:
+
+```sql
+-- Find all failed mutations in last hour
+SELECT 
+  correlation_id,
+  timestamp,
+  action,
+  actor,
+  resource_type,
+  status_code,
+  error_message
+FROM audit_logs
+WHERE success = false
+  AND timestamp > NOW() - INTERVAL '1 hour'
+ORDER BY timestamp DESC;
+
+-- Find specific error patterns
+SELECT 
+  error_message,
+  COUNT(*) as count,
+  MAX(timestamp) as last_occurrence
+FROM audit_logs
+WHERE success = false
+  AND timestamp > NOW() - INTERVAL '24 hours'
+GROUP BY error_message
+ORDER BY count DESC;
+```
+
+## Common Incident Scenarios
+
+### Scenario 1: Claim Status Changed Unexpectedly
+
+**Problem**: A claim status changed without authorization
+
+**Investigation**:
+```sql
+-- Find who changed the claim and when
+SELECT 
+  correlation_id,
+  timestamp,
+  actor,
+  action,
+  status_code
+FROM audit_logs
+WHERE resource_id = 'claim-uuid'
+  AND resource_type = 'CLAIM'
+  AND action = 'UPDATE'
+ORDER BY timestamp DESC
+LIMIT 10;
+
+-- Check if actor was authorized
+SELECT * FROM users WHERE email = 'actor@example.com';
+
+-- Verify the change in claims table
+SELECT id, status, updated_at FROM medical_claims WHERE id = 'claim-uuid';
+```
+
+### Scenario 2: Dispute Not Resolving
+
+**Problem**: A dispute is stuck in UNDER_REVIEW status
+
+**Investigation**:
+```sql
+-- Find all mutations for the dispute
+SELECT 
+  correlation_id,
+  timestamp,
+  action,
+  actor,
+  status_code,
+  error_message
+FROM audit_logs
+WHERE resource_id = 'dispute-uuid'
+  AND resource_type = 'DISPUTE'
+ORDER BY timestamp DESC;
+
+-- Check current dispute state
+SELECT id, status, created_at, updated_at FROM disputes WHERE id = 'dispute-uuid';
+
+-- Find related claim
+SELECT c.id, c.status FROM medical_claims c
+WHERE c.id = (SELECT claim_id FROM disputes WHERE id = 'dispute-uuid');
+```
+
+### Scenario 3: Performance Degradation
+
+**Problem**: API requests are slow
+
+**Investigation**:
+```sql
+-- Find slow requests
+SELECT 
+  correlation_id,
+  timestamp,
+  endpoint,
+  method,
+  duration_ms,
+  status_code
+FROM audit_logs
+WHERE duration_ms > 5000  -- Requests taking > 5 seconds
+  AND timestamp > NOW() - INTERVAL '1 hour'
+ORDER BY duration_ms DESC
+LIMIT 20;
+
+-- Identify slow endpoints
+SELECT 
+  endpoint,
+  AVG(duration_ms) as avg_duration,
+  MAX(duration_ms) as max_duration,
+  COUNT(*) as request_count
+FROM audit_logs
+WHERE timestamp > NOW() - INTERVAL '1 hour'
+GROUP BY endpoint
+ORDER BY avg_duration DESC;
+```
+
+### Scenario 4: Unauthorized Access Attempt
+
+**Problem**: Someone tried to access a resource they shouldn't
+
+**Investigation**:
+```sql
+-- Find failed authorization attempts
+SELECT 
+  correlation_id,
+  timestamp,
+  actor,
+  endpoint,
+  status_code,
+  error_message
+FROM audit_logs
+WHERE status_code IN (401, 403)  -- Unauthorized or Forbidden
+  AND timestamp > NOW() - INTERVAL '24 hours'
+ORDER BY timestamp DESC;
+
+-- Check if actor has legitimate access
+SELECT * FROM users WHERE email = 'actor@example.com';
+```
+
+## Logging Best Practices
+
+### In Application Code
+
+Always include correlation ID in logs:
+
+```typescript
+// Automatically included via CorrelationIdInterceptor
+this.logger.log(`Processing claim ${claimId}`, 'ClaimsService');
+
+// Logs will include correlation ID in structured format
+// [550e8400-e29b-41d4-a716-446655440000] Processing claim abc-123
+```
+
+### In Background Jobs
+
+Propagate correlation ID to async operations:
+
+```typescript
+// Pass correlation ID to background job
+await this.queue.add('process-claim', {
+  claimId,
+  correlationId: request.correlationId,
+});
+
+// In job handler
+async handle(job: Job) {
+  const { claimId, correlationId } = job.data;
+  this.logger.log(
+    `[${correlationId}] Processing claim ${claimId}`,
+    'ClaimProcessor'
+  );
+}
+```
+
+### In Contract Events
+
+Include correlation ID in event metadata:
+
+```typescript
+// When emitting contract events
+const event = {
+  type: 'CLAIM_APPROVED',
+  claimId,
+  correlationId: request.correlationId,
+  timestamp: new Date(),
+};
+```
+
+## Querying Patterns
+
+### Time-Range Queries
+
+```sql
+-- Last hour
+WHERE timestamp > NOW() - INTERVAL '1 hour'
+
+-- Last 24 hours
+WHERE timestamp > NOW() - INTERVAL '24 hours'
+
+-- Specific date range
+WHERE timestamp BETWEEN '2024-01-01' AND '2024-01-31'
+```
+
+### Performance Analysis
+
+```sql
+-- Percentile response times
+SELECT 
+  endpoint,
+  PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY duration_ms) as p50,
+  PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY duration_ms) as p95,
+  PERCENTILE_CONT(0.99) WITHIN GROUP (ORDER BY duration_ms) as p99
+FROM audit_logs
+WHERE timestamp > NOW() - INTERVAL '24 hours'
+GROUP BY endpoint;
+```
+
+### Error Rate Analysis
+
+```sql
+-- Error rate by endpoint
+SELECT 
+  endpoint,
+  COUNT(*) as total_requests,
+  SUM(CASE WHEN success = false THEN 1 ELSE 0 END) as failed_requests,
+  ROUND(100.0 * SUM(CASE WHEN success = false THEN 1 ELSE 0 END) / COUNT(*), 2) as error_rate_percent
+FROM audit_logs
+WHERE timestamp > NOW() - INTERVAL '1 hour'
+GROUP BY endpoint
+ORDER BY error_rate_percent DESC;
+```
+
+## Alerts & Monitoring
+
+### Recommended Alerts
+
+1. **High Error Rate**: Alert if error rate > 5% in 5-minute window
+2. **Slow Requests**: Alert if p95 response time > 5 seconds
+3. **Unauthorized Access**: Alert on multiple 401/403 errors from same actor
+4. **Failed Disputes**: Alert if dispute resolution fails
+
+### Example Alert Query
+
+```sql
+-- Alert: Multiple failed dispute resolutions
+SELECT 
+  actor,
+  COUNT(*) as failure_count,
+  MAX(timestamp) as last_failure
+FROM audit_logs
+WHERE resource_type = 'DISPUTE'
+  AND action = 'UPDATE'
+  AND success = false
+  AND timestamp > NOW() - INTERVAL '1 hour'
+GROUP BY actor
+HAVING COUNT(*) > 3;
+```
+
+## Retention Policy
+
+- **Audit Logs**: Retained for 90 days (configurable)
+- **Application Logs**: Retained for 30 days
+- **Contract Events**: Retained indefinitely (immutable on blockchain)
+
+## Privacy Considerations
+
+- Audit logs contain actor email/wallet addresses
+- Restrict access to audit logs to authorized personnel
+- Implement row-level security for sensitive data
+- Comply with GDPR/privacy regulations for data retention
+
+## Support
+
+For questions about tracing or incident investigation:
+1. Check this runbook
+2. Review application logs
+3. Query audit logs for correlation ID
+4. Contact the observability team
diff --git a/backend/src/app.module.ts b/backend/src/app.module.ts
index 5f5b83b8e..2ed7fd65b 100644
--- a/backend/src/app.module.ts
+++ b/backend/src/app.module.ts
@@ -1,7 +1,9 @@
 import { Module } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { ThrottlerGuard, ThrottlerModule } from '@nestjs/throttler';
-import { APP_GUARD } from '@nestjs/core';
+import { APP_GUARD, APP_INTERCEPTOR } from '@nestjs/core';
+import { CorrelationIdInterceptor } from './common/interceptors/correlation-id.interceptor';
+import { AuditLogInterceptor } from './common/interceptors/audit-log.interceptor';
 import { EventEmitterModule } from '@nestjs/event-emitter';
 import { LoggerModule } from 'nestjs-pino';
 import * as Joi from 'joi';
@@ -188,6 +190,14 @@ const envValidationSchema = Joi.object({
       provide: APP_GUARD,
       useClass: ThrottlerGuard,
     },
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: CorrelationIdInterceptor,
+    },
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: AuditLogInterceptor,
+    },
   ],
 })
-export class AppModule {}
+export class AppModule { }
diff --git a/backend/src/common/entities/audit-log.entity.ts b/backend/src/common/entities/audit-log.entity.ts
new file mode 100644
index 000000000..00f4cf66f
--- /dev/null
+++ b/backend/src/common/entities/audit-log.entity.ts
@@ -0,0 +1,67 @@
+import {
+    Entity,
+    Column,
+    PrimaryGeneratedColumn,
+    CreateDateColumn,
+    Index,
+} from 'typeorm';
+
+/**
+ * AuditLog Entity
+ * 
+ * Stores structured audit entries for all trade and dispute mutations.
+ * Enables forensic traceability and incident debugging.
+ * 
+ * Indexed by:
+ * - correlation_id: Trace full request lifecycle
+ * - resource_id: Find all mutations for a specific trade/dispute
+ * - actor: Find all actions by a user
+ * - timestamp: Time-range queries
+ * - action: Filter by mutation type
+ */
+@Entity('audit_logs')
+@Index('idx_audit_logs_correlation_id', ['correlationId'])
+@Index('idx_audit_logs_resource_id', ['resourceId'])
+@Index('idx_audit_logs_actor', ['actor'])
+@Index('idx_audit_logs_timestamp', ['timestamp'])
+@Index('idx_audit_logs_action', ['action'])
+export class AuditLog {
+    @PrimaryGeneratedColumn('uuid')
+    id: string;
+
+    @Column()
+    correlationId: string;
+
+    @CreateDateColumn()
+    timestamp: Date;
+
+    @Column()
+    endpoint: string;
+
+    @Column()
+    method: string;
+
+    @Column()
+    action: string; // CREATE, UPDATE, DELETE
+
+    @Column()
+    actor: string; // wallet or email
+
+    @Column({ nullable: true, type: 'uuid' })
+    resourceId: string | null;
+
+    @Column()
+    resourceType: string; // TRADE, DISPUTE, CLAIM
+
+    @Column()
+    statusCode: number;
+
+    @Column()
+    durationMs: number;
+
+    @Column({ default: true })
+    success: boolean;
+
+    @Column({ nullable: true, type: 'text' })
+    errorMessage: string | null;
+}
diff --git a/backend/src/common/interceptors/audit-log.interceptor.ts b/backend/src/common/interceptors/audit-log.interceptor.ts
new file mode 100644
index 000000000..89e0970e9
--- /dev/null
+++ b/backend/src/common/interceptors/audit-log.interceptor.ts
@@ -0,0 +1,142 @@
+import {
+    Injectable,
+    NestInterceptor,
+    ExecutionContext,
+    CallHandler,
+    Logger,
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { tap, catchError } from 'rxjs/operators';
+import { Request, Response } from 'express';
+import { throwError } from 'rxjs';
+
+/**
+ * Audit Log Interceptor
+ * 
+ * Logs structured audit entries for trade and dispute mutations.
+ * Captures:
+ * - Request ID (correlation ID)
+ * - Endpoint and HTTP method
+ * - Actor wallet/user
+ * - Trade/Dispute ID from params or body
+ * - Request/response status
+ * - Timestamp
+ * 
+ * Enables forensic traceability for incident debugging.
+ */
+@Injectable()
+export class AuditLogInterceptor implements NestInterceptor {
+    private readonly logger = new Logger(AuditLogInterceptor.name);
+
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+        const request = context.switchToHttp().getRequest<Request>();
+        const response = context.switchToHttp().getResponse<Response>();
+
+        // Extract correlation ID from request
+        const correlationId = (request as any).correlationId || 'unknown';
+
+        // Determine if this is a mutation endpoint (POST, PATCH, PUT, DELETE)
+        const isMutation = ['POST', 'PATCH', 'PUT', 'DELETE'].includes(
+            request.method,
+        );
+
+        // Extract audit-relevant paths
+        const isMutationEndpoint =
+            isMutation &&
+            (request.url.includes('/claims') ||
+                request.url.includes('/disputes') ||
+                request.url.includes('/trades'));
+
+        if (!isMutationEndpoint) {
+            return next.handle();
+        }
+
+        const startTime = Date.now();
+        const auditEntry = this.buildAuditEntry(request, correlationId);
+
+        return next.handle().pipe(
+            tap((data) => {
+                const duration = Date.now() - startTime;
+                this.logAuditEntry({
+                    ...auditEntry,
+                    status: response.statusCode,
+                    duration,
+                    success: true,
+                });
+            }),
+            catchError((error) => {
+                const duration = Date.now() - startTime;
+                this.logAuditEntry({
+                    ...auditEntry,
+                    status: error.status || 500,
+                    duration,
+                    success: false,
+                    error: error.message,
+                });
+                return throwError(() => error);
+            }),
+        );
+    }
+
+    private buildAuditEntry(request: Request, correlationId: string) {
+        const body = request.body || {};
+        const params = request.params || {};
+
+        // Extract resource IDs
+        const tradeId = params.id || body.tradeId || body.claimId || null;
+        const disputeId = params.id || body.disputeId || null;
+        const resourceId = tradeId || disputeId;
+
+        // Extract actor (wallet or user email)
+        const actor =
+            body.actor ||
+            body.wallet ||
+            body.email ||
+            (request.user as any)?.email ||
+            'anonymous';
+
+        // Determine action type
+        const action = this.getActionType(request.method, request.url);
+
+        return {
+            correlationId,
+            timestamp: new Date().toISOString(),
+            endpoint: request.url,
+            method: request.method,
+            action,
+            actor,
+            resourceId,
+            resourceType: this.getResourceType(request.url),
+        };
+    }
+
+    private getActionType(method: string, url: string): string {
+        if (method === 'POST') return 'CREATE';
+        if (method === 'PATCH' || method === 'PUT') return 'UPDATE';
+        if (method === 'DELETE') return 'DELETE';
+        return 'UNKNOWN';
+    }
+
+    private getResourceType(url: string): string {
+        if (url.includes('/claims')) return 'CLAIM';
+        if (url.includes('/disputes')) return 'DISPUTE';
+        if (url.includes('/trades')) return 'TRADE';
+        return 'UNKNOWN';
+    }
+
+    private logAuditEntry(entry: any) {
+        const logMessage = `[AUDIT] ${entry.correlationId} | ${entry.action} ${entry.resourceType} | Actor: ${entry.actor} | Resource: ${entry.resourceId} | Status: ${entry.status} | Duration: ${entry.duration}ms`;
+
+        if (entry.success) {
+            this.logger.log(logMessage);
+        } else {
+            this.logger.error(
+                `${logMessage} | Error: ${entry.error}`,
+                'AuditLog',
+            );
+        }
+
+        // Structured logging for log aggregation systems
+        this.logger.debug(JSON.stringify(entry), 'AuditLogStructured');
+    }
+}
diff --git a/backend/src/common/interceptors/correlation-id.interceptor.ts b/backend/src/common/interceptors/correlation-id.interceptor.ts
new file mode 100644
index 000000000..c9d233196
--- /dev/null
+++ b/backend/src/common/interceptors/correlation-id.interceptor.ts
@@ -0,0 +1,50 @@
+import {
+    Injectable,
+    NestInterceptor,
+    ExecutionContext,
+    CallHandler,
+    Logger,
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { v4 as uuidv4 } from 'uuid';
+import { Request, Response } from 'express';
+
+/**
+ * Correlation ID Interceptor
+ * 
+ * Generates or forwards request correlation IDs for tracing requests
+ * through the entire system (API → DB → listeners → contracts).
+ * 
+ * - Checks for X-Correlation-ID header
+ * - Generates UUID if not present
+ * - Attaches to request object for downstream use
+ * - Includes in response headers
+ * - Logs correlation ID for debugging
+ */
+@Injectable()
+export class CorrelationIdInterceptor implements NestInterceptor {
+    private readonly logger = new Logger(CorrelationIdInterceptor.name);
+
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+        const request = context.switchToHttp().getRequest<Request>();
+        const response = context.switchToHttp().getResponse<Response>();
+
+        // Check for existing correlation ID or generate new one
+        const correlationId =
+            (request.headers['x-correlation-id'] as string) || uuidv4();
+
+        // Attach to request for downstream use
+        (request as any).correlationId = correlationId;
+
+        // Add to response headers
+        response.setHeader('X-Correlation-ID', correlationId);
+
+        // Log request with correlation ID
+        this.logger.debug(
+            `[${correlationId}] ${request.method} ${request.url}`,
+            'CorrelationId',
+        );
+
+        return next.handle();
+    }
+}
diff --git a/backend/src/migrations/1775300000000-CreateAuditLogsTable.ts b/backend/src/migrations/1775300000000-CreateAuditLogsTable.ts
new file mode 100644
index 000000000..bd1728583
--- /dev/null
+++ b/backend/src/migrations/1775300000000-CreateAuditLogsTable.ts
@@ -0,0 +1,118 @@
+import { MigrationInterface, QueryRunner, Table } from 'typeorm';
+
+export class CreateAuditLogsTable1775300000000 implements MigrationInterface {
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.createTable(
+            new Table({
+                name: 'audit_logs',
+                columns: [
+                    {
+                        name: 'id',
+                        type: 'uuid',
+                        isPrimary: true,
+                        generationStrategy: 'uuid',
+                        default: 'gen_random_uuid()',
+                    },
+                    {
+                        name: 'correlation_id',
+                        type: 'varchar',
+                        isNullable: false,
+                        comment: 'Request correlation ID for tracing',
+                    },
+                    {
+                        name: 'timestamp',
+                        type: 'timestamp',
+                        isNullable: false,
+                        default: 'CURRENT_TIMESTAMP',
+                    },
+                    {
+                        name: 'endpoint',
+                        type: 'varchar',
+                        isNullable: false,
+                        comment: 'API endpoint path',
+                    },
+                    {
+                        name: 'method',
+                        type: 'varchar',
+                        isNullable: false,
+                        comment: 'HTTP method (POST, PATCH, PUT, DELETE)',
+                    },
+                    {
+                        name: 'action',
+                        type: 'varchar',
+                        isNullable: false,
+                        comment: 'Action type (CREATE, UPDATE, DELETE)',
+                    },
+                    {
+                        name: 'actor',
+                        type: 'varchar',
+                        isNullable: false,
+                        comment: 'User wallet or email performing action',
+                    },
+                    {
+                        name: 'resource_id',
+                        type: 'uuid',
+                        isNullable: true,
+                        comment: 'ID of affected resource (trade, dispute, claim)',
+                    },
+                    {
+                        name: 'resource_type',
+                        type: 'varchar',
+                        isNullable: false,
+                        comment: 'Type of resource (TRADE, DISPUTE, CLAIM)',
+                    },
+                    {
+                        name: 'status_code',
+                        type: 'int',
+                        isNullable: false,
+                        comment: 'HTTP response status code',
+                    },
+                    {
+                        name: 'duration_ms',
+                        type: 'int',
+                        isNullable: false,
+                        comment: 'Request duration in milliseconds',
+                    },
+                    {
+                        name: 'success',
+                        type: 'boolean',
+                        isNullable: false,
+                        default: true,
+                    },
+                    {
+                        name: 'error_message',
+                        type: 'text',
+                        isNullable: true,
+                        comment: 'Error message if request failed',
+                    },
+                ],
+                indices: [
+                    {
+                        name: 'idx_audit_logs_correlation_id',
+                        columnNames: ['correlation_id'],
+                    },
+                    {
+                        name: 'idx_audit_logs_resource_id',
+                        columnNames: ['resource_id'],
+                    },
+                    {
+                        name: 'idx_audit_logs_actor',
+                        columnNames: ['actor'],
+                    },
+                    {
+                        name: 'idx_audit_logs_timestamp',
+                        columnNames: ['timestamp'],
+                    },
+                    {
+                        name: 'idx_audit_logs_action',
+                        columnNames: ['action'],
+                    },
+                ],
+            }),
+        );
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.dropTable('audit_logs');
+    }
+}
diff --git a/backend/test/critical-path.e2e-spec.ts b/backend/test/critical-path.e2e-spec.ts
new file mode 100644
index 000000000..ce277f54c
--- /dev/null
+++ b/backend/test/critical-path.e2e-spec.ts
@@ -0,0 +1,347 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication, ValidationPipe } from '@nestjs/common';
+import * as request from 'supertest';
+import { AppModule } from '../src/app.module';
+import { DataSource } from 'typeorm';
+import { MedicalClaim, ClaimStatus } from '../src/modules/claims/entities/medical-claim.entity';
+import { Dispute, DisputeStatus } from '../src/modules/disputes/entities/dispute.entity';
+
+/**
+ * E2E Critical Path Tests
+ * 
+ * Tests the full escrow lifecycle:
+ * - Create trade (claim submission)
+ * - Deposit (claim approval)
+ * - Confirm delivery (claim processing)
+ * - Release funds (claim resolution)
+ * - Initiate dispute and resolve
+ * 
+ * Validates API, DB, and business logic integration.
+ */
+describe('Critical Path E2E Tests', () => {
+    let app: INestApplication;
+    let dataSource: DataSource;
+    let claimRepository;
+    let disputeRepository;
+
+    beforeAll(async () => {
+        const moduleFixture: TestingModule = await Test.createTestingModule({
+            imports: [AppModule],
+        }).compile();
+
+        app = moduleFixture.createNestApplication();
+        app.useGlobalPipes(
+            new ValidationPipe({
+                whitelist: true,
+                forbidNonWhitelisted: true,
+                transform: true,
+            }),
+        );
+        await app.init();
+
+        dataSource = moduleFixture.get<DataSource>(DataSource);
+        claimRepository = dataSource.getRepository(MedicalClaim);
+        disputeRepository = dataSource.getRepository(Dispute);
+
+        // Clean up before tests
+        await cleanupDatabase();
+    });
+
+    afterAll(async () => {
+        await cleanupDatabase();
+        await app.close();
+    });
+
+    async function cleanupDatabase() {
+        if (!dataSource.isInitialized) return;
+
+        const entities = dataSource.entityMetadatas;
+        for (const entity of entities) {
+            const repository = dataSource.getRepository(entity.name);
+            await repository.query(`TRUNCATE TABLE "${entity.tableName}" CASCADE`);
+        }
+    }
+
+    describe('Happy Path: Create → Deposit → Confirm → Release', () => {
+        let claimId: string;
+
+        it('should create a trade (submit medical claim)', async () => {
+            const createClaimDto = {
+                patientName: 'John Doe',
+                patientId: 'P123456',
+                patientDateOfBirth: '1990-01-15',
+                hospitalName: 'City Hospital',
+                hospitalId: 'H001',
+                diagnosisCodes: ['J45.9', 'E11.9'],
+                claimAmount: 5000.00,
+                notes: 'Asthma and diabetes treatment',
+            };
+
+            const response = await request(app.getHttpServer())
+                .post('/claims')
+                .send(createClaimDto)
+                .expect(201);
+
+            expect(response.body).toHaveProperty('id');
+            expect(response.body.status).toBe(ClaimStatus.PENDING);
+            expect(response.body.claimAmount).toBe('5000.00');
+
+            claimId = response.body.id;
+
+            // Verify in database
+            const claim = await claimRepository.findOne({ where: { id: claimId } });
+            expect(claim).toBeDefined();
+            expect(claim.status).toBe(ClaimStatus.PENDING);
+        });
+
+        it('should deposit (approve claim)', async () => {
+            const response = await request(app.getHttpServer())
+                .patch(`/claims/${claimId}`)
+                .send({ status: ClaimStatus.APPROVED })
+                .expect(200);
+
+            expect(response.body.status).toBe(ClaimStatus.APPROVED);
+
+            // Verify in database
+            const claim = await claimRepository.findOne({ where: { id: claimId } });
+            expect(claim.status).toBe(ClaimStatus.APPROVED);
+        });
+
+        it('should confirm delivery (process claim)', async () => {
+            const response = await request(app.getHttpServer())
+                .patch(`/claims/${claimId}`)
+                .send({ status: ClaimStatus.PROCESSING })
+                .expect(200);
+
+            expect(response.body.status).toBe(ClaimStatus.PROCESSING);
+
+            const claim = await claimRepository.findOne({ where: { id: claimId } });
+            expect(claim.status).toBe(ClaimStatus.PROCESSING);
+        });
+
+        it('should release funds (resolve claim)', async () => {
+            const response = await request(app.getHttpServer())
+                .patch(`/claims/${claimId}`)
+                .send({ status: ClaimStatus.APPROVED })
+                .expect(200);
+
+            expect(response.body.status).toBe(ClaimStatus.APPROVED);
+
+            const claim = await claimRepository.findOne({ where: { id: claimId } });
+            expect(claim.status).toBe(ClaimStatus.APPROVED);
+        });
+
+        it('should retrieve claim with full history', async () => {
+            const response = await request(app.getHttpServer())
+                .get(`/claims/${claimId}`)
+                .expect(200);
+
+            expect(response.body.id).toBe(claimId);
+            expect(response.body.status).toBe(ClaimStatus.APPROVED);
+            expect(response.body.patientName).toBe('John Doe');
+            expect(response.body.claimAmount).toBe('5000.00');
+        });
+    });
+
+    describe('Dispute Path: Initiate → Review → Resolve', () => {
+        let claimId: string;
+        let disputeId: string;
+
+        beforeAll(async () => {
+            // Create a claim to dispute
+            const claim = claimRepository.create({
+                patientName: 'Jane Smith',
+                patientId: 'P789012',
+                patientDateOfBirth: new Date('1985-06-20'),
+                hospitalName: 'General Hospital',
+                hospitalId: 'H002',
+                diagnosisCodes: ['M79.3'],
+                claimAmount: 3500.00,
+                status: ClaimStatus.APPROVED,
+                notes: 'Muscle strain treatment',
+            });
+            const savedClaim = await claimRepository.save(claim);
+            claimId = savedClaim.id;
+        });
+
+        it('should initiate dispute on approved claim', async () => {
+            const createDisputeDto = {
+                claimId,
+                disputedBy: 'hospital-admin@example.com',
+                reason: 'Claim amount exceeds approved treatment cost',
+            };
+
+            const response = await request(app.getHttpServer())
+                .post('/disputes')
+                .send(createDisputeDto)
+                .expect(201);
+
+            expect(response.body).toHaveProperty('id');
+            expect(response.body.status).toBe(DisputeStatus.OPEN);
+            expect(response.body.claimId).toBe(claimId);
+            expect(response.body.reason).toBe(createDisputeDto.reason);
+
+            disputeId = response.body.id;
+
+            // Verify in database
+            const dispute = await disputeRepository.findOne({ where: { id: disputeId } });
+            expect(dispute).toBeDefined();
+            expect(dispute.status).toBe(DisputeStatus.OPEN);
+        });
+
+        it('should add message to dispute (evidence)', async () => {
+            const addMessageDto = {
+                author: 'hospital-admin@example.com',
+                message: 'Attached hospital invoice showing actual cost',
+                evidenceUrl: 'https://example.com/invoice-123.pdf',
+            };
+
+            const response = await request(app.getHttpServer())
+                .post(`/disputes/${disputeId}/messages`)
+                .send(addMessageDto)
+                .expect(201);
+
+            expect(response.body).toHaveProperty('id');
+            expect(response.body.author).toBe(addMessageDto.author);
+            expect(response.body.evidenceUrl).toBe(addMessageDto.evidenceUrl);
+        });
+
+        it('should transition dispute to under review', async () => {
+            const response = await request(app.getHttpServer())
+                .patch(`/disputes/${disputeId}`)
+                .send({ status: DisputeStatus.UNDER_REVIEW })
+                .expect(200);
+
+            expect(response.body.status).toBe(DisputeStatus.UNDER_REVIEW);
+
+            const dispute = await disputeRepository.findOne({ where: { id: disputeId } });
+            expect(dispute.status).toBe(DisputeStatus.UNDER_REVIEW);
+        });
+
+        it('should resolve dispute', async () => {
+            const response = await request(app.getHttpServer())
+                .patch(`/disputes/${disputeId}`)
+                .send({ status: DisputeStatus.RESOLVED })
+                .expect(200);
+
+            expect(response.body.status).toBe(DisputeStatus.RESOLVED);
+
+            const dispute = await disputeRepository.findOne({
+                where: { id: disputeId },
+                relations: ['messages'],
+            });
+            expect(dispute.status).toBe(DisputeStatus.RESOLVED);
+            expect(dispute.messages.length).toBeGreaterThan(0);
+        });
+
+        it('should retrieve dispute with full message history', async () => {
+            const response = await request(app.getHttpServer())
+                .get(`/disputes/${disputeId}`)
+                .expect(200);
+
+            expect(response.body.id).toBe(disputeId);
+            expect(response.body.status).toBe(DisputeStatus.RESOLVED);
+            expect(Array.isArray(response.body.messages)).toBe(true);
+            expect(response.body.messages.length).toBeGreaterThan(0);
+        });
+    });
+
+    describe('Negative Flows', () => {
+        it('should reject invalid status transition', async () => {
+            const claim = claimRepository.create({
+                patientName: 'Test User',
+                patientId: 'P999999',
+                patientDateOfBirth: new Date('1995-03-10'),
+                hospitalName: 'Test Hospital',
+                hospitalId: 'H999',
+                diagnosisCodes: ['Z00.00'],
+                claimAmount: 1000.00,
+                status: ClaimStatus.PENDING,
+            });
+            const savedClaim = await claimRepository.save(claim);
+
+            // Try invalid status
+            const response = await request(app.getHttpServer())
+                .patch(`/claims/${savedClaim.id}`)
+                .send({ status: 'INVALID_STATUS' })
+                .expect(400);
+
+            expect(response.body.message).toBeDefined();
+        });
+
+        it('should prevent unauthorized dispute creation', async () => {
+            const response = await request(app.getHttpServer())
+                .post('/disputes')
+                .send({
+                    claimId: 'non-existent-id',
+                    disputedBy: 'unauthorized@example.com',
+                    reason: 'Invalid claim',
+                })
+                .expect(400);
+
+            expect(response.body.message).toBeDefined();
+        });
+
+        it('should return 404 for non-existent claim', async () => {
+            await request(app.getHttpServer())
+                .get('/claims/00000000-0000-0000-0000-000000000000')
+                .expect(404);
+        });
+
+        it('should return 404 for non-existent dispute', async () => {
+            await request(app.getHttpServer())
+                .get('/disputes/00000000-0000-0000-0000-000000000000')
+                .expect(404);
+        });
+    });
+
+    describe('Data Integrity & Cross-Layer Validation', () => {
+        it('should maintain referential integrity between claims and disputes', async () => {
+            const claim = claimRepository.create({
+                patientName: 'Integrity Test',
+                patientId: 'P111111',
+                patientDateOfBirth: new Date('1992-07-25'),
+                hospitalName: 'Integrity Hospital',
+                hospitalId: 'H111',
+                diagnosisCodes: ['A00.0'],
+                claimAmount: 2000.00,
+                status: ClaimStatus.APPROVED,
+            });
+            const savedClaim = await claimRepository.save(claim);
+
+            const dispute = disputeRepository.create({
+                claimId: savedClaim.id,
+                disputedBy: 'test@example.com',
+                reason: 'Test dispute',
+                status: DisputeStatus.OPEN,
+            });
+            const savedDispute = await disputeRepository.save(dispute);
+
+            // Verify relationship
+            const retrievedDispute = await disputeRepository.findOne({
+                where: { id: savedDispute.id },
+                relations: ['claim'],
+            });
+
+            expect(retrievedDispute.claim.id).toBe(savedClaim.id);
+            expect(retrievedDispute.claim.patientName).toBe('Integrity Test');
+        });
+
+        it('should list all claims with pagination', async () => {
+            const response = await request(app.getHttpServer())
+                .get('/claims')
+                .expect(200);
+
+            expect(Array.isArray(response.body)).toBe(true);
+            expect(response.body.length).toBeGreaterThan(0);
+        });
+
+        it('should list all disputes with pagination', async () => {
+            const response = await request(app.getHttpServer())
+                .get('/disputes')
+                .expect(200);
+
+            expect(Array.isArray(response.body)).toBe(true);
+        });
+    });
+});
diff --git a/frontend/app/components/dashboard/ContractDetailsCard.tsx b/frontend/app/components/dashboard/ContractDetailsCard.tsx
new file mode 100644
index 000000000..896713d4a
--- /dev/null
+++ b/frontend/app/components/dashboard/ContractDetailsCard.tsx
@@ -0,0 +1,245 @@
+"use client";
+
+import React from "react";
+import { Copy, FileCode, Calendar } from "lucide-react";
+
+export type RiskLevel = "Low Risk" | "Medium Risk" | "High Risk";
+
+export interface ContractDetails {
+  contractId: string;
+  buyerAddress: string;
+  sellerAddress: string;
+  mediatorAddress?: string;
+  lossRatio: {
+    buyer: number;
+    seller: number;
+  };
+  createdAt: Date | string;
+  tvl?: string;
+  riskLevel?: RiskLevel;
+}
+
+interface ContractDetailsCardProps {
+  contract: ContractDetails;
+  onCopyContractId?: (contractId: string) => void;
+}
+
+/**
+ * ContractDetailsCard
+ * 
+ * Displays Soroban smart contract details for the active escrow.
+ * Shows contract ID, parties, loss ratio, and creation date.
+ * 
+ * Features:
+ * - Truncated contract ID with copy button
+ * - Party addresses (buyer, seller, mediator)
+ * - Visual loss ratio split bar
+ * - Creation timestamp
+ * - Risk level indicator
+ */
+const ContractDetailsCard: React.FC<ContractDetailsCardProps> = ({
+  contract,
+  onCopyContractId,
+}) => {
+  const [copied, setCopied] = React.useState(false);
+
+  const handleCopyContractId = () => {
+    navigator.clipboard.writeText(contract.contractId);
+    setCopied(true);
+    onCopyContractId?.(contract.contractId);
+    setTimeout(() => setCopied(false), 2000);
+  };
+
+  const truncateAddress = (address: string, chars = 6) => {
+    return `${address.slice(0, chars)}...${address.slice(-chars)}`;
+  };
+
+  const formatDate = (date: Date | string) => {
+    const d = typeof date === "string" ? new Date(date) : date;
+    return d.toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+    });
+  };
+
+  const getRiskColor = (risk?: RiskLevel) => {
+    switch (risk) {
+      case "Low Risk":
+        return "text-emerald-400";
+      case "Medium Risk":
+        return "text-amber-400";
+      case "High Risk":
+        return "text-rose-400";
+      default:
+        return "text-gray-400";
+    }
+  };
+
+  const getRiskDotColor = (risk?: RiskLevel) => {
+    switch (risk) {
+      case "Low Risk":
+        return "bg-emerald-400";
+      case "Medium Risk":
+        return "bg-amber-400";
+      case "High Risk":
+        return "bg-rose-400";
+      default:
+        return "bg-gray-400";
+    }
+  };
+
+  return (
+    <div className="bg-gradient-to-br from-[#0a1f1f] to-[#061515] rounded-2xl border border-white/5 p-6 hover:border-cyan-500/20 transition-all duration-300 hover:shadow-[0_8px_30px_rgba(6,182,212,0.1)]">
+      {/* Header */}
+      <div className="flex items-center gap-3 mb-6">
+        <FileCode className="w-5 h-5 text-cyan-400" />
+        <h2 className="text-white font-bold text-lg m-0">Agreement Protocol</h2>
+      </div>
+
+      {/* Contract ID Section */}
+      <div className="mb-6 pb-6 border-b border-white/5">
+        <div className="text-[#5e8c96] text-xs uppercase tracking-wide mb-2">
+          Contract ID
+        </div>
+        <div className="flex items-center gap-2">
+          <code className="text-cyan-400 font-mono text-sm flex-1 truncate">
+            {truncateAddress(contract.contractId, 8)}
+          </code>
+          <button
+            onClick={handleCopyContractId}
+            className="p-2 hover:bg-white/5 rounded-lg transition-colors duration-200"
+            title="Copy contract ID"
+          >
+            <Copy
+              className={`w-4 h-4 transition-colors duration-200 ${
+                copied ? "text-emerald-400" : "text-[#7a9fa9]"
+              }`}
+            />
+          </button>
+        </div>
+        {copied && (
+          <p className="text-emerald-400 text-xs mt-2">Copied to clipboard</p>
+        )}
+      </div>
+
+      {/* Parties Section */}
+      <div className="mb-6 pb-6 border-b border-white/5">
+        <div className="text-[#5e8c96] text-xs uppercase tracking-wide mb-3">
+          Parties
+        </div>
+        <div className="space-y-3">
+          {/* Buyer */}
+          <div className="flex items-center justify-between py-2">
+            <span className="text-[#7a9fa9] text-sm">Buyer</span>
+            <code className="text-white font-mono text-sm">
+              {truncateAddress(contract.buyerAddress)}
+            </code>
+          </div>
+
+          {/* Seller */}
+          <div className="flex items-center justify-between py-2 border-b border-white/5">
+            <span className="text-[#7a9fa9] text-sm">Seller</span>
+            <code className="text-white font-mono text-sm">
+              {truncateAddress(contract.sellerAddress)}
+            </code>
+          </div>
+
+          {/* Mediator (if present) */}
+          {contract.mediatorAddress && (
+            <div className="flex items-center justify-between py-2">
+              <span className="text-[#7a9fa9] text-sm">Mediator</span>
+              <code className="text-white font-mono text-sm">
+                {truncateAddress(contract.mediatorAddress)}
+              </code>
+            </div>
+          )}
+        </div>
+      </div>
+
+      {/* Loss Ratio Section */}
+      <div className="mb-6 pb-6 border-b border-white/5">
+        <div className="text-[#5e8c96] text-xs uppercase tracking-wide mb-3">
+          Loss Ratio
+        </div>
+        <div className="space-y-2">
+          {/* Ratio Display */}
+          <div className="flex items-center justify-between mb-2">
+            <span className="text-white text-sm font-semibold">
+              {contract.lossRatio.buyer}% / {contract.lossRatio.seller}%
+            </span>
+          </div>
+
+          {/* Visual Split Bar */}
+          <div className="flex h-2 rounded-full overflow-hidden bg-white/5">
+            {/* Buyer portion */}
+            <div
+              className="bg-gradient-to-r from-cyan-500 to-cyan-400 transition-all duration-300"
+              style={{ width: `${contract.lossRatio.buyer}%` }}
+              title={`Buyer: ${contract.lossRatio.buyer}%`}
+            />
+            {/* Seller portion */}
+            <div
+              className="bg-gradient-to-r from-amber-500 to-amber-400 transition-all duration-300"
+              style={{ width: `${contract.lossRatio.seller}%` }}
+              title={`Seller: ${contract.lossRatio.seller}%`}
+            />
+          </div>
+
+          {/* Legend */}
+          <div className="flex items-center justify-between text-xs mt-2">
+            <div className="flex items-center gap-2">
+              <div className="w-2 h-2 rounded-full bg-cyan-400" />
+              <span className="text-[#7a9fa9]">Buyer Risk</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <div className="w-2 h-2 rounded-full bg-amber-400" />
+              <span className="text-[#7a9fa9]">Seller Risk</span>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      {/* Metadata Section */}
+      <div className="space-y-3">
+        {/* Created At */}
+        <div className="flex items-center justify-between py-2">
+          <div className="flex items-center gap-2">
+            <Calendar className="w-4 h-4 text-[#7a9fa9]" />
+            <span className="text-[#7a9fa9] text-sm">Created</span>
+          </div>
+          <span className="text-white text-sm">{formatDate(contract.createdAt)}</span>
+        </div>
+
+        {/* TVL (if present) */}
+        {contract.tvl && (
+          <div className="flex items-center justify-between py-2 border-t border-white/5 pt-3">
+            <span className="text-[#7a9fa9] text-sm">Total Value Locked</span>
+            <span className="text-cyan-400 font-semibold">{contract.tvl}</span>
+          </div>
+        )}
+
+        {/* Risk Level (if present) */}
+        {contract.riskLevel && (
+          <div className="flex items-center justify-between py-2">
+            <span className="text-[#7a9fa9] text-sm">Risk Level</span>
+            <div className="flex items-center gap-2">
+              <div
+                className={`w-2 h-2 rounded-full ${getRiskDotColor(
+                  contract.riskLevel
+                )}`}
+              />
+              <span className={`text-sm font-medium ${getRiskColor(contract.riskLevel)}`}>
+                {contract.riskLevel}
+              </span>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+};
+
+export default ContractDetailsCard;