Make a demo application of real-world ZKP application

Susmita-Chakrabarty · Susmita-Chakrabarty · commit 10ed4f07892c · 2025-04-15T14:23:59.000-06:00
diff --git a/ZKP_Demo_Tool/ui/level_card.py b/ZKP_Demo_Tool/ui/level_card.py
@@ -0,0 +1,54 @@
+from PyQt5.QtWidgets import QFrame, QVBoxLayout, QLabel, QPushButton
+
+def create_level_card(parent, title, description, button_label, unlock_condition_met, launch_function):
+    card = QFrame(parent)
+    card.setFrameShape(QFrame.StyledPanel)
+    card.setStyleSheet("""
+        QFrame {
+            background-color: #ffffff;
+            border-radius: 10px;
+            padding: 20px;
+            border: 1px solid #ccc;
+        }
+    """)
+
+    layout = QVBoxLayout(card)
+
+    title_label = QLabel(title)
+    title_label.setStyleSheet("font-size: 18px; font-weight: bold;")
+    layout.addWidget(title_label)
+
+    desc_label = QLabel(description)
+    desc_label.setWordWrap(True)
+    desc_label.setStyleSheet("color: #555; font-size: 13px;")
+    layout.addWidget(desc_label)
+
+    play_button = QPushButton(button_label)
+    play_button.setFixedHeight(40)
+
+    if unlock_condition_met:
+        play_button.setStyleSheet("""
+            QPushButton {
+                background-color: #3498db;
+                color: white;
+                font-weight: bold;
+                border-radius: 8px;
+            }
+            QPushButton:hover {
+                background-color: #2980b9;
+            }
+        """)
+        play_button.clicked.connect(launch_function)
+    else:
+        play_button.setEnabled(False)
+        play_button.setStyleSheet("""
+            QPushButton {
+                background-color: #bbb;
+                color: #666;
+                border-radius: 8px;
+            }
+        """)
+        play_button.setToolTip("Earn more trust points to unlock this level.")
+
+    layout.addWidget(play_button)
+    return card
diff --git a/ZKP_Demo_Tool/ui/level_selector.py b/ZKP_Demo_Tool/ui/level_selector.py
@@ -1,13 +1,8 @@
-# ui/level_selector.py
-import os
-from PyQt5.QtWidgets import (
-    QWidget, QVBoxLayout, QLabel, QPushButton, QMessageBox, QGridLayout
-)
+from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QPushButton, QMessageBox, QGridLayout, QComboBox, QHBoxLayout
 from PyQt5.QtGui import QFont
 from PyQt5.QtCore import Qt
-
-from levels.level1_triangle import Level1Triangle
-# We'll import level2_ring etc. later as they're written
+from levels.level2_bank_graph import Level2BankGraph
+from ui.level_card import create_level_card
 
 class LevelSelector(QWidget):
     def __init__(self):
@@ -18,47 +13,116 @@ def __init__(self):
         self.layout = QVBoxLayout()
         self.setLayout(self.layout)
 
-        title = QLabel("🔐 Zero-Knowledge Proof Puzzle Book")
-        title.setAlignment(Qt.AlignCenter)
-        title.setFont(QFont("Arial", 18, QFont.Bold))
-        self.layout.addWidget(title)
+        title_label = QLabel("🔒 The ZKP Puzzle Book")
+        title_label.setFont(QFont("Cochin", 24, QFont.Bold))
+        title_label.setStyleSheet("color: gold;")
+        title_label.setAlignment(Qt.AlignCenter)
 
         self.instructions = QLabel("Earn Trust Points by completing levels to unlock the next!")
         self.instructions.setAlignment(Qt.AlignCenter)
         self.layout.addWidget(self.instructions)
 
+        self.round_mode_dropdown = QComboBox()
+        self.round_mode_dropdown.addItems([
+            "Manual Mode",
+            "Auto Mode - 5 Rounds",
+            "Auto Mode - 10 Rounds",
+            "Auto Mode - 20 Rounds"
+        ])
+        self.layout.addWidget(self.round_mode_dropdown)
+
         self.trust_points = 0
         self.level_buttons = []
         self.build_level_grid()
 
     def build_level_grid(self):
+        # Horizontal layout or grid for cards
+        card_layout = QHBoxLayout()
+
+        
+
+        # Level 2: Unlocks after 3 trust points
+        level2_card = create_level_card(
+            parent=self,
+            title="Level 2: 5-Node Ring",
+            description="Demonstrate your skill on a cyclic 5-node graph with non-repeating color constraints.",
+            button_label="Play Now",
+            unlock_condition_met=(self.trust_points >= 3),
+            launch_function=self.load_level2
+        )
+
+        # Add cards to layout
+        
+        card_layout.addWidget(level2_card)
+
+        # Then add to main layout in your init or builder method:
+        self.layout.addLayout(card_layout)
+        bottom_layout = QHBoxLayout()
+        bottom_layout.setSpacing(20)
+        bottom_layout.setContentsMargins(20, 20, 20, 20)
+        self.mode_selector = QComboBox()
+        self.mode_selector.addItems(["⌨️ Manual Mode", "🤖 Auto Mode"])
+        self.mode_selector.setFixedHeight(40)
+        self.mode_selector.setStyleSheet("""
+            QComboBox {
+                background-color: #2c3e50;
+                color: white;
+                font-weight: bold;
+                font-size: 14px;
+                padding: 5px 10px;
+                border-radius: 8px;
+            }
+            QComboBox::drop-down {
+                border: none;
+            }
+        """)
+        bottom_layout.addWidget(self.mode_selector)
+
         grid = QGridLayout()
         levels = [
-            {"name": "Level 1: Triangle", "required_points": 0, "function": self.load_level1},
-            {"name": "Level 2: 5-Node Ring", "required_points": 3, "function": self.coming_soon},
-            {"name": "Level 3: Bipartite Graph", "required_points": 6, "function": self.coming_soon},
-            {"name": "Level 4: Social Network", "required_points": 9, "function": self.coming_soon}
+            {"name": "💠 Level 2.5: Multi-Path Challenge", "required_points": 0, "function": self.load_level2, "color": "#27ae60"}
         ]
 
         for i, level in enumerate(levels):
-            btn = QPushButton(level["name"])
-            if self.trust_points < level["required_points"]:
-                btn.setEnabled(False)
-                btn.setText(f"🔒 {level['name']} (Locked)")
-            else:
-                btn.clicked.connect(level["function"])
-            self.level_buttons.append(btn)
-            grid.addWidget(btn, i // 2, i % 2)
+            button = QPushButton(level["name"])
 
-        self.layout.addLayout(grid)
+            if self.trust_points >= level["required_points"]:
+                button.setEnabled(True)
+                button.setStyleSheet(f"""
+                    QPushButton {{
+                        background-color: {level['color']};
+                        color: white;
+                        font-weight: bold;
+                        font-size: 16px;
+                        padding: 15px;
+                        border-radius: 10px;
+                        border: 2px solid white;
+                    }}
+                    QPushButton:hover {{
+                        background-color: #2c3e50;
+                        border: 2px solid gold;
+                    }}
+                """)
+                button.clicked.connect(level["function"])
+            else:
+                button.setEnabled(False)
+                button.setStyleSheet("""
+                    QPushButton {
+                        background-color: #444;
+                        color: #aaa;
+                        font-weight: bold;
+                        font-size: 16px;
+                        padding: 15px;
+                        border-radius: 10px;
+                        border: 2px dashed gray;
+                    }
+                """)
+                button.setToolTip(f"🔒 Requires {level['required_points']} Trust Points to unlock.")
 
-    def load_level1(self):
-        self.hide()
-        self.level_window = Level1Triangle(parent_selector=self)
-        self.level_window.show()
+            grid.addWidget(button, 0, i)
 
-    def coming_soon(self):
-        QMessageBox.information(self, "Locked Level", "Complete earlier levels to unlock this level!")
+        
+        self.layout.addLayout(grid)
 
     def update_trust_points(self, points_earned):
         self.trust_points += points_earned
@@ -70,3 +134,22 @@ def rebuild(self):
             btn.setParent(None)
         self.level_buttons = []
         self.build_level_grid()
+
+    def get_round_mode(self):
+        mode_text = self.round_mode_dropdown.currentText()
+        if "Manual" in mode_text:
+            return False, 3
+        elif "5" in mode_text:
+            return True, 5
+        elif "10" in mode_text:
+            return True, 10
+        else:
+            return True, 20
+
+    def load_level2(self):
+        self.hide()
+        auto_mode, auto_rounds = self.get_round_mode()
+        self.level_window = Level2BankGraph(parent_selector=self, auto_mode=auto_mode, auto_rounds=auto_rounds)
+
+        self.level_window.show()
+    
diff --git a/ZKP_Demo_Tool/ui/node_item.py b/ZKP_Demo_Tool/ui/node_item.py
@@ -1,64 +1,110 @@
-from PyQt5.QtWidgets import (
-    QGraphicsEllipseItem, QGraphicsTextItem, QToolTip,
-    QDialog, QVBoxLayout, QPushButton, QHBoxLayout
-)
-from PyQt5.QtGui import QBrush, QColor, QFont
-from PyQt5.QtCore import Qt
+# node_item.py
+from PyQt5.QtWidgets import QGraphicsEllipseItem, QGraphicsTextItem
+from PyQt5.QtGui import QBrush, QColor, QFont, QPen
+from PyQt5.QtCore import Qt, QPointF, QPropertyAnimation
 
 class NodeItem(QGraphicsEllipseItem):
-    def __init__(self, node_id, pos, parent_level):
+    def __init__(self, node_id, pos, parent, label=None):
         super().__init__(-20, -20, 40, 40)
         self.node_id = node_id
-        self.parent_level = parent_level
+        self.parent = parent
         self.setBrush(QBrush(Qt.gray))
+        self.setPen(QPen(Qt.black, 2))
+        self.setZValue(1)
+
         self.setFlag(QGraphicsEllipseItem.ItemIsSelectable)
         self.setAcceptHoverEvents(True)
         self.setPos(pos)
+
         self.locked = False
+        self.role = None
+        self.label = label if label else f"Node {node_id}"
+        self.hash_display = None
+
+        # Label below node
+        self.text_item = QGraphicsTextItem(self.label, self)
+        self.text_item.setFont(QFont("Arial", 9))
+        self.text_item.setDefaultTextColor(Qt.white)
+        self.text_item.setPos(-self.text_item.boundingRect().width() / 2, 22)
 
-        self.text = QGraphicsTextItem(str(node_id))
-        self.text.setDefaultTextColor(Qt.white)
-        self.text.setFont(QFont("Arial", 10, QFont.Bold))
-        self.text.setParentItem(self)
-        self.text.setPos(-8, -10)
+        # Lock visual indicator
+        self.lock_icon = QGraphicsTextItem("🔒", self)
+        self.lock_icon.setFont(QFont("Arial", 12))
+        self.lock_icon.setDefaultTextColor(Qt.darkGray)
+        self.lock_icon.setPos(-10, -35)
+        self.lock_icon.setVisible(False)
+    def set_label(self, label_text):
+        if hasattr(self, 'label'):
+            self.scene().removeItem(self.label)
 
-        # Define the allowed color palette
-        self.allowed_colors = {
-            "Red": "#E74C3C",
-            "Green": "#2ECC71",
-            " Blue": "#3498DB",
-            "Yellow": "#F1C40F"
-        }
+        from PyQt5.QtWidgets import QGraphicsTextItem
+        from PyQt5.QtCore import Qt
 
+        self.label = QGraphicsTextItem(label_text)
+        self.label.setDefaultTextColor(Qt.white)
+        self.label.setParentItem(self)
+        self.label.setPos(-20, -35)
+
+    def set_color(self, color):
+        if not self.locked:
+            self.setBrush(QBrush(QColor(color)))
+    def change_color(self):
+        current_color = self.brush().color()
+        next_color = self.get_next_color(current_color)
+        self.setBrush(QBrush(next_color))
+        self.parent.node_colors[self.node_id] = next_color
     def mousePressEvent(self, event):
-        if not self.locked and not self.parent_level.committed:
-            self.show_color_selection_dialog()
-        super().mousePressEvent(event)
+        self.change_color()
+    def get_next_color(self, current_color):
+        color_cycle = [Qt.red, Qt.green, Qt.blue]  # Or your fixed palette
+        try:
+            i = color_cycle.index(current_color)
+            return color_cycle[(i + 1) % len(color_cycle)]
+        except ValueError:
+            return color_cycle[0]
+    def lock(self):
+        self.locked = True
+        self.setBrush(QBrush(Qt.gray))
+        self.setPen(QPen(Qt.darkGray, 2))
+        self.lock_icon.setVisible(True)
+        self.update()
 
-    def show_color_selection_dialog(self):
-        dialog = QDialog()
-        dialog.setWindowTitle(f"Select a color for Node {self.node_id}")
-        layout = QVBoxLayout()
+    def unlock(self):
+        self.locked = False
+        self.setPen(QPen(Qt.black, 2))
+        self.setBrush(QBrush(Qt.gray))
+        self.lock_icon.setVisible(False)
+        self.update()
 
-        button_row = QHBoxLayout()
-        for label, hex_code in self.allowed_colors.items():
-            btn = QPushButton(label)
-            btn.setStyleSheet(f"background-color: {hex_code}; color: black; font-weight: bold;")
-            btn.clicked.connect(lambda _, c=hex_code: self.select_color(dialog, c))
-            button_row.addWidget(btn)
+    def show_hash(self, short_hash):
+        if not self.hash_display:
+            self.hash_display = QGraphicsTextItem(short_hash, self)
+            self.hash_display.setFont(QFont("Courier", 7))
+            self.hash_display.setDefaultTextColor(Qt.lightGray)
+            self.hash_display.setPos(-self.hash_display.boundingRect().width() / 2, 35)
+        else:
+            self.hash_display.setPlainText(short_hash)
 
-        layout.addLayout(button_row)
-        dialog.setLayout(layout)
-        dialog.exec_()
+    def hide_hash(self):
+        if self.hash_display:
+            self.scene().removeItem(self.hash_display)
+            self.hash_display = None
 
-    def select_color(self, dialog, color_hex):
-        self.setBrush(QBrush(QColor(color_hex)))
-        self.parent_level.node_colors[self.node_id] = color_hex
-        self.parent_level.update_narration(f"🎨 Prover colored node {self.node_id} with color.")
-        dialog.accept()
+    def set_label(self, label):
+        self.label = label
+        self.text_item.setPlainText(label)
 
-    def hoverEnterEvent(self, event):
-        if self.locked:
-            QToolTip.showText(event.screenPos(), "🔒 This node is committed", self.parent_level)
-        else:
-            QToolTip.showText(event.screenPos(), f" Node {self.node_id}: Click to choose a color", self.parent_level)
+    def pulse_red(self):
+        # Animate node glow red for non-repudiation breach
+        animation = QPropertyAnimation(self, b"opacity")
+        animation.setDuration(800)
+        animation.setKeyValueAt(0, 1.0)
+        animation.setKeyValueAt(0.5, 0.3)
+        animation.setKeyValueAt(1, 1.0)
+        animation.start()
+        self.setBrush(QBrush(QColor("red")))
+    def set_label(self, text):
+        label = QGraphicsTextItem(text, self)
+        label.setDefaultTextColor(Qt.black)
+        label.setFont(QFont("Arial", 10))
+        label.setPos(-10, -10)  # Adjust position if needed
