diff --git a/frontend/src/app/stellar-consensus-protocol/page.tsx b/frontend/src/app/stellar-consensus-protocol/page.tsx new file mode 100644 index 00000000..039a614f --- /dev/null +++ b/frontend/src/app/stellar-consensus-protocol/page.tsx @@ -0,0 +1,201 @@ +'use client'; + +import { SCPVisualizer } from '@/components/stellar-scp'; + +export default function SCPPage() { + return ( +
+ {/* Background decoration */} +
+
+
+
+ + {/* Content */} +
+ {/* Breadcrumb */} + + + {/* Hero Section */} +
+

+ Stellar Consensus Protocol (SCP) +

+

+ Explore how Stellar validators reach consensus through a decentralized Byzantine fault-tolerant + protocol. This interactive visualizer demonstrates the Nomination and Ballot phases. +

+
+ + {/* Visualizer */} +
+ +
+ + {/* Info Section */} +
+ {/* Phase Explanation */} +
+

🎯 How It Works

+
+
+

Nomination Phase

+

+ Validators broadcast their candidate values. Each validator collects nominations from its + quorum set and votes to confirm a composite candidate value that represents the set of all + proposed values. +

+
+
+

Ballot Phase

+

+ Validators attempt to reach agreement on a specific value. Each ballot progresses through + VOTE → ACCEPT → CONFIRM stages. A value is confirmed when the validator's entire quorum set + accepts it. +

+
+
+
+ + {/* Features & Controls */} +
+

⚙️ Features

+
    +
  • + ▶ + Start/Pause - Control simulation flow +
    • +
  • + ⏭ + Step - Advance one step for learning +
    • +
  • + ↺ + Reset - Return to initial state +
    • +
  • + ⚡ + Speed Control - Adjust simulation tempo +
    • +
  • + ✗ + Click Node - Simulate validator failure +
    • +
+
+ + {/* Consensus States */} +
+

🎨 Node States

+
+
+
+ Idle +
+
+
+ Nominating +
+
+
+ Voting +
+
+
+ Accepted +
+
+
+ Confirmed +
+
+
+ Failed +
+
+
+ + {/* Key Concepts */} +
+

📚 Key Concepts

+
+
+ Quorum Set +

A set of validators each validator trusts to reach agreement

+
+
+ Byzantine Fault Tolerance +

System tolerates some validators being faulty or malicious

+
+
+ Consensus +

All valid validators eventually confirm the same value

+
+
+
+
+ + {/* Learning Resources */} +
+

📖 Learn More

+ +
+ + {/* Footer */} +
+

+ 🌐 Stellar Consensus Protocol Visualizer | Part of the Web3 Student Lab +

+
+
+
+ ); +} diff --git a/frontend/src/components/stellar-scp/README.md b/frontend/src/components/stellar-scp/README.md new file mode 100644 index 00000000..8daa5967 --- /dev/null +++ b/frontend/src/components/stellar-scp/README.md @@ -0,0 +1,223 @@ +# Stellar Consensus Protocol (SCP) Visualizer + +An interactive, educational visualization of the Stellar Consensus Protocol's Nomination and Ballot phases, demonstrating how validators reach consensus in a distributed network. + +## Overview + +The SCP Visualizer demonstrates: +- **Nomination Phase**: Validators broadcast candidate values and collect nominations +- **Ballot Phase**: Validators move through VOTE → ACCEPT → CONFIRM stages +- **Node Failures**: Simulates validator failures and consensus resilience +- **Real-time Visualization**: D3.js-powered SVG rendering with smooth animations + +## Features + +### Interactive Controls +- **Start/Pause**: Run or pause the simulation +- **Step**: Advance one step at a time for detailed learning +- **Reset**: Return to initial state +- **Speed Control**: Adjust simulation speed (200ms - 2000ms per step) +- **Node Failure Toggle**: Click any validator node to simulate failure + +### Visual Feedback +- **Node States**: Color-coded by consensus phase + - Idle (gray) + - Nominating (amber) + - Voting (blue) + - Accepted (purple) + - Confirmed (green) + - Failed (red) +- **Active Edges**: Animated dashed lines showing message passing +- **Real-time Metrics**: Round counter and phase indicator + +### Educational Content +- **Phase Descriptions**: Contextual explanations of each phase +- **Node State Display**: Track individual validator states +- **Legend**: Color reference for all states +- **Consensus Status**: Visual indicator when consensus is reached or fails + +## Installation + +The component uses **D3.js v7.9.0**, which is already installed in the project. + +### Basic Usage + +```tsx +import { SCPVisualizer } from '@/components/stellar-scp'; + +export default function Page() { + return ; +} +``` + +### Type Definitions + +```tsx +import type { SCPNode, SCPEdge, SCPState, NodeState, Phase } from '@/components/stellar-scp'; + +type NodeState = 'idle' | 'nominating' | 'voting' | 'accepted' | 'confirmed' | 'failed'; +type Phase = 'nomination' | 'ballot'; + +interface SCPNode { + id: string; + label: string; + x: number; + y: number; + state: NodeState; + isValidator: boolean; + quorumSet: string[]; + failed: boolean; +} + +interface SCPEdge { + source: string; + target: string; + active: boolean; + messageType: 'nominate' | 'vote' | 'accept' | 'confirm'; +} + +interface SCPState { + phase: Phase; + round: number; + nodes: SCPNode[]; + edges: SCPEdge[]; + isRunning: boolean; + speed: number; + step: number; +} +``` + +## Component Structure + +``` +stellar-scp/ +├── SCPVisualizer.tsx # Main component +├── SCPVisualizer.test.tsx # Unit tests +├── index.ts # Exports +└── README.md # This file +``` + +## How It Works + +### Network Layout +- 7 validator nodes arranged in a circle +- Each validator has a quorum set of 3 nodes (adjacent validators) +- Edges represent communication paths between validators + +### Simulation Steps + +#### Nomination Phase (Steps 0-2) +1. **Step 0**: All non-failed nodes enter "nominating" state + - Message type: `nominate` + - Edges activate showing nomination broadcast +2. **Step 1**: Nodes collect nominations from quorum + - Nodes transition to "voting" state +3. **Step 2**: Nomination complete + - Phase transitions to Ballot + +#### Ballot Phase (Steps 0-3) +4. **Step 0**: Nodes broadcast votes + - Message type: `vote` +5. **Step 1**: Nodes receive votes and accept + - Message type: `accept` + - Nodes transition to "accepted" state +6. **Step 2**: Quorum consensus on value + - Message type: `confirm` + - Nodes transition to "confirmed" state +7. **Step 3**: Consensus reached + - Simulation stops + - Status shows "✓ Consensus Reached" + +### Failure Handling +- Failed nodes remain in "failed" state throughout +- Failed nodes' edges become inactive +- Consensus still reaches if ≥66% of validators are alive +- If <66% remain: "✗ Consensus Failed" state + +## Styling + +The component uses **Tailwind CSS** with a dark theme: +- Background: `bg-slate-950` (#0f172a) +- Primary accent: `text-blue-400` (sky blue) +- Text: `text-slate-100` (light gray) +- State colors match node state colors + +## Accessibility + +### ARIA Labels +- SVG elements have proper `role` and `aria-label` attributes +- Screen reader descriptions for graph content +- Semantic HTML structure + +### Keyboard Navigation +- All buttons are keyboard accessible +- Click-to-fail nodes support keyboard interaction +- Proper focus management + +### Visual +- High contrast colors +- Clear state indicators +- Status messages for screen readers +- Tooltips for interactive elements + +## Browser Compatibility + +- Modern browsers supporting: + - ES2022 + - SVG + - CSS Grid/Flexbox + - D3.js v7 + +## Testing + +Unit tests cover: +- Component rendering +- Initial state +- Button interactions (Start, Pause, Step, Reset) +- Node state display +- Phase transitions +- Speed control +- Legend and descriptions +- Accessibility features + +Run tests with: +```bash +pnpm test src/components/stellar-scp/SCPVisualizer.test.tsx +``` + +## Performance Considerations + +- **Virtualized Rendering**: D3 efficiently updates only changed elements +- **Debounced Resize**: Window resize events are debounced +- **Smooth Transitions**: CSS transitions (300ms) for visual feedback +- **Efficient State Updates**: React reconciliation optimized with data keys + +## Future Enhancements + +Potential improvements for future iterations: + +1. **Custom Quorum Sets**: Allow users to define custom quorum configurations +2. **Multiple Rounds**: Support multiple consensus rounds +3. **Network Statistics**: Display quorum slice information and voting patterns +4. **Byzantine Failures**: Simulate different failure types +5. **Performance Metrics**: Show consensus time and message counts +6. **Export Simulation**: Save/load simulation states +7. **Interactive Tooltips**: Hover information on nodes and edges +8. **Theme Support**: Light/dark theme toggle + +## References + +- [Stellar Consensus Protocol Whitepaper](https://stellar.org/papers/stellar-consensus-protocol) +- [Stellar Developer Guide](https://developers.stellar.org/) +- [D3.js Documentation](https://d3js.org/) + +## License + +Same as the Web3-Student-Lab project. + +## Support + +For issues or questions about the SCP Visualizer: +1. Check the existing tests for usage examples +2. Review the type definitions for component API +3. Consult the Stellar documentation for protocol details diff --git a/frontend/src/components/stellar-scp/SCPVisualizer.test.tsx b/frontend/src/components/stellar-scp/SCPVisualizer.test.tsx new file mode 100644 index 00000000..a750a15d --- /dev/null +++ b/frontend/src/components/stellar-scp/SCPVisualizer.test.tsx @@ -0,0 +1,151 @@ +import { render, screen, fireEvent } from '@testing-library/react'; +import { SCPVisualizer } from './index'; +import { describe, it, expect, vi } from 'vitest'; + +describe('SCPVisualizer', () => { + it('renders without crashing', () => { + render(); + expect( + screen.getByText(/Stellar Consensus Protocol \(SCP\) Visualizer/i) + ).toBeInTheDocument(); + }); + + it('shows Nomination phase initially', () => { + render(); + expect(screen.getByText(/📋 Nomination/i)).toBeInTheDocument(); + }); + + it('shows Round 1 initially', () => { + render(); + expect(screen.getByText(/Round 1/i)).toBeInTheDocument(); + }); + + it('displays all 7 validator nodes', () => { + render(); + for (let i = 1; i <= 7; i++) { + expect(screen.getByText(`V${i}`)).toBeInTheDocument(); + } + }); + + it('renders control buttons', () => { + render(); + expect(screen.getByRole('button', { name: /Start/i })).toBeInTheDocument(); + expect(screen.getByRole('button', { name: /Pause/i })).toBeInTheDocument(); + expect(screen.getByRole('button', { name: /Step/i })).toBeInTheDocument(); + expect(screen.getByRole('button', { name: /Reset/i })).toBeInTheDocument(); + }); + + it('disables Start button when simulation is running', async () => { + render(); + const startButton = screen.getByRole('button', { name: /Start/i }); + + fireEvent.click(startButton); + + // Give React time to update + await new Promise((resolve) => setTimeout(resolve, 100)); + + expect(startButton).toBeDisabled(); + }); + + it('disables Pause button when simulation is not running', () => { + render(); + const pauseButton = screen.getByRole('button', { name: /Pause/i }); + + expect(pauseButton).toBeDisabled(); + }); + + it('shows legend with all node states', () => { + render(); + + expect(screen.getByText(/idle/i)).toBeInTheDocument(); + expect(screen.getByText(/nominating/i)).toBeInTheDocument(); + expect(screen.getByText(/voting/i)).toBeInTheDocument(); + expect(screen.getByText(/accepted/i)).toBeInTheDocument(); + expect(screen.getByText(/confirmed/i)).toBeInTheDocument(); + expect(screen.getByText(/failed/i)).toBeInTheDocument(); + }); + + it('shows phase description', () => { + render(); + expect( + screen.getByText(/Nomination Phase: Each validator broadcasts its candidate values/i) + ).toBeInTheDocument(); + }); + + it('displays speed control slider', () => { + render(); + const slider = screen.getByRole('slider'); + expect(slider).toBeInTheDocument(); + expect(slider).toHaveAttribute('min', '200'); + expect(slider).toHaveAttribute('max', '2000'); + }); + + it('shows help text', () => { + render(); + expect(screen.getByText(/Click any node to toggle its failure state/i)).toBeInTheDocument(); + }); + + it('advances one step on Step button click', async () => { + render(); + const stepButton = screen.getByRole('button', { name: /Step/i }); + + fireEvent.click(stepButton); + + // Give React time to process + await new Promise((resolve) => setTimeout(resolve, 100)); + + expect(stepButton).toBeInTheDocument(); + }); + + it('resets to initial state on Reset button click', async () => { + render(); + const resetButton = screen.getByRole('button', { name: /Reset/i }); + + fireEvent.click(resetButton); + + // Give React time to process + await new Promise((resolve) => setTimeout(resolve, 100)); + + expect(screen.getByText(/📋 Nomination/i)).toBeInTheDocument(); + expect(screen.getByText(/Round 1/i)).toBeInTheDocument(); + }); + + it('renders SVG visualization container', () => { + render(); + const svg = screen.getByRole('img', { + name: /Stellar Consensus Protocol Network Visualization/i, + }); + expect(svg).toBeInTheDocument(); + }); + + it('provides accessibility features', () => { + render(); + + // Check for title element + const title = screen.getByText('Stellar Consensus Protocol Network Visualization'); + expect(title).toBeInTheDocument(); + + // Check for description + const desc = screen.getByText( + /An interactive visualization showing validator nodes and their consensus process/i + ); + expect(desc).toBeInTheDocument(); + }); + + it('displays all node state indicators', () => { + render(); + + // All 7 nodes should be displayed with their labels + for (let i = 1; i <= 7; i++) { + const nodeLabel = screen.getByText(`V${i}`); + expect(nodeLabel).toBeInTheDocument(); + } + }); + + it('renders speed control with correct value display', () => { + render(); + + // Speed control should show multiplier + expect(screen.getByText(/x/)).toBeInTheDocument(); + }); +}); diff --git a/frontend/src/components/stellar-scp/SCPVisualizer.tsx b/frontend/src/components/stellar-scp/SCPVisualizer.tsx new file mode 100644 index 00000000..f589b583 --- /dev/null +++ b/frontend/src/components/stellar-scp/SCPVisualizer.tsx @@ -0,0 +1,551 @@ +'use client'; + +import React, { useEffect, useRef, useState } from 'react'; +import * as d3 from 'd3'; + +// ============================================================================ +// Type Definitions +// ============================================================================ + +export type NodeState = 'idle' | 'nominating' | 'voting' | 'accepted' | 'confirmed' | 'failed'; +export type Phase = 'nomination' | 'ballot'; +type MessageType = 'nominate' | 'vote' | 'accept' | 'confirm'; + +export interface SCPNode { + id: string; + label: string; + x: number; + y: number; + state: NodeState; + isValidator: boolean; + quorumSet: string[]; + failed: boolean; +} + +export interface SCPEdge { + source: string; + target: string; + active: boolean; + messageType: MessageType; +} + +export interface SCPState { + phase: Phase; + round: number; + nodes: SCPNode[]; + edges: SCPEdge[]; + isRunning: boolean; + speed: number; + step: number; +} + +// ============================================================================ +// Color Configuration +// ============================================================================ + +const NODE_COLORS: Record = { + idle: '#64748b', + nominating: '#f59e0b', + voting: '#3b82f6', + accepted: '#8b5cf6', + confirmed: '#10b981', + failed: '#ef4444', +}; + +const EDGE_COLORS: Record = { + nominate: '#f59e0b', + vote: '#3b82f6', + accept: '#8b5cf6', + confirm: '#10b981', +}; + +const PHASE_DESCRIPTIONS: Record = { + nomination: `🎯 Nomination Phase: Each validator broadcasts its candidate values. Nodes collect nominations from their quorum set and vote to confirm a composite candidate value.`, + ballot: `🗳️ Ballot Phase: Validators attempt to reach agreement on a specific value. Each ballot round progresses through VOTE → ACCEPT → CONFIRM stages until consensus is reached.`, +}; + +// ============================================================================ +// Utility Functions +// ============================================================================ + +const createInitialNodes = (): SCPNode[] => { + const count = 7; + const radius = 200; + const cx = 400; + const cy = 300; + + return Array.from({ length: count }, (_, i) => ({ + id: `node-${i}`, + label: `V${i + 1}`, + x: cx + radius * Math.cos((2 * Math.PI * i) / count), + y: cy + radius * Math.sin((2 * Math.PI * i) / count), + state: 'idle' as NodeState, + isValidator: true, + quorumSet: [ + `node-${(i + 1) % count}`, + `node-${(i + 2) % count}`, + `node-${(i + count - 1) % count}`, + ], + failed: false, + })); +}; + +const createInitialEdges = (nodes: SCPNode[]): SCPEdge[] => { + const edges: SCPEdge[] = []; + nodes.forEach((node) => { + node.quorumSet.forEach((targetId) => { + edges.push({ + source: node.id, + target: targetId, + active: false, + messageType: 'nominate', + }); + }); + }); + return edges; +}; + +// ============================================================================ +// Simulation Step Logic +// ============================================================================ + +const simulationStep = (state: SCPState): SCPState => { + const { phase, round, nodes, step, isRunning } = state; + + if (!isRunning) return state; + + let newNodes = JSON.parse(JSON.stringify(nodes)) as SCPNode[]; + let newEdges = JSON.parse(JSON.stringify(state.edges)) as SCPEdge[]; + + if (phase === 'nomination') { + if (step === 0) { + // Step 0: All non-failed nodes enter nominating state + newNodes = newNodes.map((n) => ({ + ...n, + state: n.failed ? 'failed' : ('nominating' as NodeState), + })); + newEdges = newEdges.map((e) => ({ + ...e, + active: true, + messageType: 'nominate', + })); + } else if (step === 1) { + // Step 1: Nodes collect nominations, move to voting + newEdges = newEdges.map((e) => ({ ...e, active: false })); + newNodes = newNodes.map((n) => ({ + ...n, + state: n.failed ? 'failed' : ('voting' as NodeState), + })); + } else if (step === 2) { + // Step 2: Nomination complete, prepare for ballot phase + return { + ...state, + phase: 'ballot', + step: 0, + }; + } + } else if (phase === 'ballot') { + if (step === 0) { + // Step 0: Nodes broadcast votes + newEdges = newEdges.map((e) => ({ + ...e, + active: true, + messageType: 'vote', + })); + } else if (step === 1) { + // Step 1: Nodes receive votes and move to accepted + newEdges = newEdges.map((e) => ({ + ...e, + active: true, + messageType: 'accept', + })); + newNodes = newNodes.map((n) => ({ + ...n, + state: n.failed ? 'failed' : n.state === 'voting' ? ('accepted' as NodeState) : n.state, + })); + } else if (step === 2) { + // Step 2: Quorum accepts, move to confirmed + newEdges = newEdges.map((e) => ({ + ...e, + active: true, + messageType: 'confirm', + })); + newNodes = newNodes.map((n) => ({ + ...n, + state: n.failed ? 'failed' : ('confirmed' as NodeState), + })); + } else if (step === 3) { + // Step 3: Consensus reached + newEdges = newEdges.map((e) => ({ ...e, active: false })); + return { + ...state, + isRunning: false, + step: state.step + 1, + }; + } + } + + return { + ...state, + nodes: newNodes, + edges: newEdges, + step: state.step + 1, + }; +}; + +// ============================================================================ +// Main Component +// ============================================================================ + +export const SCPVisualizer: React.FC = () => { + const svgRef = useRef(null); + const containerRef = useRef(null); + const [scpState, setScpState] = useState({ + phase: 'nomination', + round: 1, + nodes: createInitialNodes(), + edges: createInitialEdges(createInitialNodes()), + isRunning: false, + speed: 1000, + step: 0, + }); + + const [dimensions, setDimensions] = useState({ width: 800, height: 600 }); + + // Setup container dimensions + useEffect(() => { + if (containerRef.current) { + const rect = containerRef.current.getBoundingClientRect(); + setDimensions({ + width: rect.width, + height: Math.max(600, rect.height), + }); + } + }, []); + + // Simulation loop + useEffect(() => { + if (!scpState.isRunning) return; + + const timer = setTimeout(() => { + setScpState((prev) => simulationStep(prev)); + }, scpState.speed); + + return () => clearTimeout(timer); + }, [scpState.isRunning, scpState.speed, scpState.step]); + + // D3 Visualization + useEffect(() => { + if (!svgRef.current || dimensions.width === 0) return; + + const svg = d3.select(svgRef.current); + + // Bind edges + const edgeSelection = svg + .selectAll('.edge') + .data(scpState.edges, (d: SCPEdge) => `${d.source}-${d.target}-${d.messageType}`); + + edgeSelection + .enter() + .append('line') + .attr('class', 'edge') + .attr('x1', (d) => scpState.nodes.find((n) => n.id === d.source)?.x || 0) + .attr('y1', (d) => scpState.nodes.find((n) => n.id === d.source)?.y || 0) + .attr('x2', (d) => scpState.nodes.find((n) => n.id === d.target)?.x || 0) + .attr('y2', (d) => scpState.nodes.find((n) => n.id === d.target)?.y || 0) + .attr('stroke', (d) => (d.active ? EDGE_COLORS[d.messageType] : '#334155')) + .attr('stroke-width', (d) => (d.active ? 2 : 1)) + .attr('stroke-dasharray', (d) => (d.active ? '5,5' : 'none')) + .attr('opacity', (d) => (d.active ? 0.8 : 0.2)) + .merge(edgeSelection) + .transition() + .duration(300) + .attr('stroke', (d) => (d.active ? EDGE_COLORS[d.messageType] : '#334155')) + .attr('stroke-width', (d) => (d.active ? 2 : 1)) + .attr('stroke-dasharray', (d) => (d.active ? '5,5' : 'none')) + .attr('opacity', (d) => (d.active ? 0.8 : 0.2)); + + edgeSelection.exit().remove(); + + // Bind nodes + const nodeSelection = svg + .selectAll('.node') + .data(scpState.nodes, (d: SCPNode) => d.id); + + nodeSelection + .enter() + .append('circle') + .attr('class', 'node') + .attr('cx', (d) => d.x) + .attr('cy', (d) => d.y) + .attr('r', 30) + .attr('fill', (d) => NODE_COLORS[d.state]) + .attr('stroke', (d) => (d.failed ? '#ef4444' : '#1e293b')) + .attr('stroke-width', (d) => (d.failed ? 3 : 2)) + .style('cursor', 'pointer') + .on('click', (_, d) => handleNodeClick(d)) + .merge(nodeSelection) + .transition() + .duration(300) + .attr('fill', (d) => NODE_COLORS[d.state]) + .attr('stroke', (d) => (d.failed ? '#ef4444' : '#1e293b')) + .attr('stroke-width', (d) => (d.failed ? 3 : 2)); + + nodeSelection.exit().remove(); + + // Bind labels + const labelSelection = svg + .selectAll('.node-label') + .data(scpState.nodes, (d: SCPNode) => d.id); + + labelSelection + .enter() + .append('text') + .attr('class', 'node-label') + .attr('x', (d) => d.x) + .attr('y', (d) => d.y) + .attr('text-anchor', 'middle') + .attr('dominant-baseline', 'middle') + .attr('fill', '#f1f5f9') + .attr('font-size', '12px') + .attr('font-weight', 'bold') + .attr('pointer-events', 'none') + .text((d) => d.label) + .merge(labelSelection) + .transition() + .duration(300) + .attr('x', (d) => d.x) + .attr('y', (d) => d.y); + + labelSelection.exit().remove(); + }, [scpState.nodes, scpState.edges, dimensions]); + + // Handlers + const handleStart = () => { + setScpState((prev) => ({ ...prev, isRunning: true })); + }; + + const handlePause = () => { + setScpState((prev) => ({ ...prev, isRunning: false })); + }; + + const handleStep = () => { + setScpState((prev) => simulationStep({ ...prev, isRunning: false })); + }; + + const handleReset = () => { + const initialNodes = createInitialNodes(); + setScpState({ + phase: 'nomination', + round: 1, + nodes: initialNodes, + edges: createInitialEdges(initialNodes), + isRunning: false, + speed: 1000, + step: 0, + }); + }; + + const handleToggleNodeFailure = (nodeId: string) => { + setScpState((prev) => ({ + ...prev, + nodes: prev.nodes.map((n) => (n.id === nodeId ? { ...n, failed: !n.failed } : n)), + })); + }; + + const handleSpeedChange = (e: React.ChangeEvent) => { + setScpState((prev) => ({ + ...prev, + speed: Number(e.target.value), + })); + }; + + const consensusReached = + scpState.nodes.filter((n) => !n.failed).every((n) => n.state === 'confirmed'); + const consensusFailed = + scpState.nodes.filter((n) => !n.failed).length < + Math.ceil(scpState.nodes.length * 0.66); + + return ( +
+ {/* Header */} +
+

+ 🌐 Stellar Consensus Protocol (SCP) Visualizer +

+

+ Interactive demonstration of the Nomination and Ballot phases of the Stellar Consensus + Protocol +

+
+ + {/* Main Layout */} +
+ {/* SVG Container */} +
+
+ + Stellar Consensus Protocol Network Visualization + + An interactive visualization showing validator nodes and their consensus process + through nomination and ballot phases. + + +
+
+ + {/* Sidebar Controls */} +
+ {/* Phase Badge */} +
+
+ Current Phase +
+
+ {scpState.phase === 'nomination' ? '📋 Nomination' : '🗳️ Ballot'} +
+
Round {scpState.round}
+
+ + {/* Controls */} +
+
+ Simulation Controls +
+ + + + + + + + +
+ + {/* Speed Control */} +
+ + +
{(3000 - scpState.speed) / 500}x
+
+ + {/* Node Status */} +
+
+ Node States +
+
+ {scpState.nodes.map((node) => ( +
handleToggleNodeFailure(node.id)} + title={`Click to toggle failure state. Currently: ${node.failed ? 'FAILED' : node.state.toUpperCase()}`} + > +
+ {node.label} + {node.failed && ✗} +
+ ))} +
+
+ + {/* Legend */} +
+
+ Legend +
+
+ {Object.entries(NODE_COLORS).map(([state, color]) => ( +
+
+ {state} +
+ ))} +
+
+ + {/* Phase Description */} +
+
+ Phase Info +
+

+ {PHASE_DESCRIPTIONS[scpState.phase]} +

+
+ + {/* Status */} + {consensusReached && ( +
+
✓ Consensus Reached
+
+ )} + + {consensusFailed && !scpState.isRunning && scpState.step > 0 && ( +
+
✗ Consensus Failed
+
+ )} +
+
+ + {/* Help Text */} +
+ 💡 Tips: Click any node to toggle its failure state. Use the Step button to advance the + simulation one step at a time. The simulation demonstrates how validators reach consensus + even with some failures. +
+
+ ); +}; + +export default SCPVisualizer; diff --git a/frontend/src/components/stellar-scp/index.ts b/frontend/src/components/stellar-scp/index.ts new file mode 100644 index 00000000..f9c4c05f --- /dev/null +++ b/frontend/src/components/stellar-scp/index.ts @@ -0,0 +1,2 @@ +export { default as SCPVisualizer, SCPVisualizer as default } from './SCPVisualizer'; +export type { SCPNode, SCPEdge, SCPState, NodeState, Phase } from './SCPVisualizer';