4 files changed, 107 insertions, 7 deletions

diff --git a/docs/TESTING.md b/docs/TESTING.md
index fbd510b..141ea75 100644
--- a/docs/TESTING.md
+++ b/docs/TESTING.md
@@ -225,6 +225,8 @@ terminal client; a saved login from one signs in the other.
    and `sha256(seed) == commit`; recompute the crash point from the seed.
 8. Confirm `CRASH_BUSTED` is an `EVT`, not a `RES`, and that a second poll
    produces no repeated settlement.
+9. The board's fairness line shows the short commit while running, then the
+   short seed and `verified` after the reveal (TUI and GUI).
 
 ## Manual restart check
 
diff --git a/gui/src/crash.rs b/gui/src/crash.rs
index 08113a8..a73c3bd 100644
--- a/gui/src/crash.rs
+++ b/gui/src/crash.rs
@@ -2,9 +2,18 @@
 
 use eframe::egui::{Align2, Color32, Pos2, Rect, Sense, Shape, Stroke, StrokeKind, Ui, pos2, vec2};
 use zagan_bet::client::view::{Command, CrashView};
+use zagan_bet::crash::{crash_point_from_seed, seed_from_hex, verify_seed};
 
 use crate::{theme, widgets};
 
+fn short_hash(hash: &str) -> String {
+    hash.char_indices()
+        .nth(12)
+        .map(|(index, _)| &hash[..index])
+        .unwrap_or(hash)
+        .to_string()
+}
+
 /// One sample of the running curve.
 struct Sample {
     seconds: f32,
@@ -136,6 +145,31 @@ fn sidebar(ui: &mut Ui, view: &CrashView, fx: &mut Fx) -> Option<Command> {
                         theme::GOLD,
                     );
 
+                    if let Some(commit) = &view.commit {
+                        widgets::row(ui, "Commit", &short_hash(commit), theme::TEXT_FAINT);
+                    }
+                    if let Some(seed) = &view.seed {
+                        let commit_ok = view
+                            .commit
+                            .as_deref()
+                            .map(|commit| verify_seed(seed, commit))
+                            .unwrap_or(false);
+                        let point_ok = seed_from_hex(seed)
+                            .map(|bytes| {
+                                view.crash_point
+                                    .map(|point| {
+                                        (crash_point_from_seed(&bytes) - point).abs() < 1e-9
+                                    })
+                                    .unwrap_or(false)
+                            })
+                            .unwrap_or(false);
+                        if commit_ok && point_ok {
+                            widgets::row(ui, "Seed ✓", &short_hash(seed), theme::WIN);
+                        } else {
+                            widgets::row(ui, "Seed ✗", &short_hash(seed), theme::LOSS);
+                        }
+                    }
+
                     ui.add_space(theme::SPACE_3);
                     status(ui, view);
 
diff --git a/src/client/games/crash.rs b/src/client/games/crash.rs
index affb642..c6dbbd5 100644
--- a/src/client/games/crash.rs
+++ b/src/client/games/crash.rs
@@ -1,7 +1,8 @@
 use super::traits::{Game, GameState};
 use crate::client::view::CrashView;
+use crate::crash::{crash_point_from_seed, seed_from_hex, verify_seed};
 
-pub const CRASH_BOARD_LINES: usize = 6;
+pub const CRASH_BOARD_LINES: usize = 7;
 
 pub struct CrashGame;
 
@@ -29,6 +30,38 @@ impl CrashGame {
         }
     }
 
+    /// Commitment line. The seed is shown only after the round ends, and the
+    /// client recomputes both the hash and the crash point.
+    fn fairness_text(view: &CrashView) -> String {
+        let short = |hash: &str| {
+            hash.char_indices()
+                .nth(12)
+                .map(|(index, _)| &hash[..index])
+                .unwrap_or(hash)
+                .to_string()
+        };
+        let Some(commit) = view.commit.as_deref() else {
+            return "Commit: —".to_string();
+        };
+        let Some(seed) = view.seed.as_deref() else {
+            return format!("Commit {}   Seed hidden until the round ends", short(commit));
+        };
+        let commit_ok = verify_seed(seed, commit);
+        let point_ok = seed_from_hex(seed)
+            .map(|bytes| {
+                let expected = crash_point_from_seed(&bytes);
+                view.crash_point
+                    .map(|point| (expected - point).abs() < 1e-9)
+                    .unwrap_or(false)
+            })
+            .unwrap_or(false);
+        if commit_ok && point_ok {
+            format!("Commit {}   Seed {} verified", short(commit), short(seed))
+        } else {
+            format!("Commit {}   Seed {} VERIFICATION FAILED", short(commit), short(seed))
+        }
+    }
+
     fn controls(view: &CrashView) -> &'static str {
         if view.status == "running" {
             "[C] Cash out   [Q] Forfeit"
@@ -46,19 +79,21 @@ impl CrashGame {
 
         if let Some(error) = &view.error {
             return format!(
-                "=== CRASH ===\r\nBalance: {balance} Kr   Bet: {} Kr\r\n\r\nERROR: {error}\r\n\r\n[SPACE] Play   [+/=/-] Bet   [Q] Quit",
-                view.bet
+                "=== CRASH ===\r\nBalance: {balance} Kr   Bet: {} Kr\r\n\r\nERROR: {error}\r\n\r\n{}\r\n[SPACE] Play   [+/=/-] Bet   [Q] Quit",
+                view.bet,
+                Self::fairness_text(view)
             );
         }
 
         format!(
-            "=== CRASH ===\r\nBalance: {} Kr   Bet: {} Kr\r\nMultiplier: {:.2}x\r\nPotential: {} Kr\r\n{}\r\n{}",
+            "=== CRASH ===\r\nBalance: {} Kr   Bet: {} Kr\r\nMultiplier: {:.2}x\r\nPotential: {} Kr\r\n{}\r\n{}\r\n{}",
             balance,
             view.bet,
             view.multiplier,
             view.potential,
             Self::status_text(view),
-            Self::controls(view)
+            Self::controls(view),
+            Self::fairness_text(view)
         )
     }
 }
diff --git a/tests/client_core.rs b/tests/client_core.rs
index 3a2fb27..65fd1e6 100644
--- a/tests/client_core.rs
+++ b/tests/client_core.rs
@@ -987,9 +987,10 @@ fn crash_starts_a_round_and_draws_the_multiplier_locally() {
     let mut h = Harness::new();
     h.enter_crash();
 
-    assert_eq!(h.board().len(), 6);
+    assert_eq!(h.board().len(), 7);
     assert!(h.board()[4].contains("Press [SPACE] to start."));
     assert!(h.board()[5].contains("[SPACE] Play"));
+    assert!(h.board()[6].contains("Commit: —"));
 
     h.key(Key::Char(' '));
     assert!(h.sent.iter().any(|line| line == "PLAY_START crash 10"));
@@ -997,7 +998,7 @@ fn crash_starts_a_round_and_draws_the_multiplier_locally() {
     let running = crash_state("running", 1.0, None, 0, 990);
     h.reply(&crash_line("CRASH_START", &running));
 
-    assert_eq!(h.board().len(), 6);
+    assert_eq!(h.board().len(), 7);
     assert!(h.board()[2].contains("Multiplier: 1.00x"));
     assert!(h.board()[3].contains("Potential: 10 Kr"));
     assert!(h.board()[4].contains("Rising"));
@@ -1709,3 +1710,31 @@ fn a_crash_tick_updates_the_board_for_its_own_session() {
     h.push("crash.tick session=other t=1700000000200 m=9.0");
     assert!(h.board()[2].contains("Multiplier: 1.50x"));
 }
+
+#[test]
+fn the_crash_board_verifies_the_revealed_seed() {
+    use zagan_bet::crash::{commit_seed, crash_point_from_seed};
+
+    let mut h = Harness::new();
+    h.enter_crash();
+    h.key(Key::Char(' '));
+    let mut seed = [0u8; 32];
+    seed[..8].copy_from_slice(&(0.67_f64 * 18_446_744_073_709_551_616.0).to_be_bytes());
+    let commit = commit_seed(&seed);
+    let point = crash_point_from_seed(&seed);
+    let hex = seed
+        .iter()
+        .map(|byte| format!("{byte:02x}"))
+        .collect::<String>();
+
+    let mut cashed = crash_state("cashed", 2.0, Some(point), 20, 1010);
+    cashed.commit = Some(commit);
+    cashed.seed = Some(hex);
+    h.reply(&crash_line("CRASH_STATE", &cashed));
+
+    assert!(
+        h.board()[6].contains("verified"),
+        "fairness line: {}",
+        h.board()[6]
+    );
+}