Add cpu-burner executable

cmd/cpu-burner/main.go

@@ -0,0 +1,111 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"runtime"
+	"time"
+
+	"hash-of-wisdom/internal/pow/challenge"
+	"hash-of-wisdom/internal/pow/solver"
+)
+
+func main() {
+	fmt.Println("🔥 Hash of Wisdom - CPU Burner Challenge 🔥")
+	fmt.Printf("Available CPU cores: %d\n", runtime.NumCPU())
+
+	// Create config with brutal difficulty
+	config, err := challenge.NewConfig(
+		challenge.WithDefaultDifficulty(30), // This will require ~1 BILLION hash attempts on average
+		challenge.WithMinDifficulty(25),
+		challenge.WithMaxDifficulty(32),
+		challenge.WithRandomBytes(8),
+	)
+	if err != nil {
+		log.Fatalf("Failed to create config: %v", err)
+	}
+
+	// Generate the brutal challenge
+	generator := challenge.NewGenerator(config)
+	ch, err := generator.GenerateChallenge()
+	if err != nil {
+		log.Fatalf("Failed to generate challenge: %v", err)
+	}
+
+	fmt.Printf("\n💀 Generated BRUTAL challenge with difficulty %d bits\n", ch.Difficulty)
+	fmt.Printf("Expected attempts: ~%.0f\n", float64(uint64(1)<<uint(ch.Difficulty)))
+	fmt.Printf("Random: %x\n", ch.Random)
+	fmt.Printf("Resource: %s\n", ch.Resource)
+
+	// Create solver with all available CPU cores
+	s := solver.NewSolver(solver.WithWorkers(runtime.NumCPU()))
+
+	fmt.Printf("\n🚀 Starting solve with %d workers...\n", runtime.NumCPU())
+	fmt.Println("Press Ctrl+C to cancel if it takes too long!")
+
+	// Start timing
+	start := time.Now()
+
+	// Set a longer timeout for the brutal difficulty (15 minutes max)
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Minute)
+	defer cancel()
+
+	// Track progress with goroutine
+	done := make(chan bool, 1)
+	go func() {
+		ticker := time.NewTicker(5 * time.Second)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ticker.C:
+				elapsed := time.Since(start)
+				fmt.Printf("⏰ Still working... elapsed: %v\n", elapsed.Truncate(time.Second))
+			case <-done:
+				return
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+
+	// SOLVE IT!
+	solution, err := s.Solve(ctx, ch)
+	done <- true
+
+	elapsed := time.Since(start)
+
+	if err != nil {
+		if err == context.DeadlineExceeded {
+			fmt.Printf("\n⏰ Timeout after %v - difficulty %d was too brutal!\n", elapsed, ch.Difficulty)
+			fmt.Println("Try reducing difficulty in the code if you want to see a solution.")
+		} else {
+			log.Fatalf("Solve failed: %v", err)
+		}
+		return
+	}
+
+	// SUCCESS!
+	fmt.Printf("\n🎉 SOLVED! Found nonce: %d\n", solution.Nonce)
+	fmt.Printf("⚡ Time taken: %v\n", elapsed)
+	fmt.Printf("🔥 Hash rate: %.2f attempts/sec\n", float64(solution.Nonce)/elapsed.Seconds())
+
+	// Verify the solution
+	if solution.Verify() {
+		fmt.Printf("✅ Solution verified successfully!\n")
+	} else {
+		fmt.Printf("❌ Solution verification failed!\n")
+	}
+
+	// Show the winning hash
+	solutionStr := ch.BuildSolutionString(solution.Nonce)
+	fmt.Printf("🏆 Winning solution string: %s\n", solutionStr)
+
+	// Show CPU usage info
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+	fmt.Printf("💾 Memory used: %d KB\n", m.Alloc/1024)
+
+	fmt.Printf("\n🔥 Your CPU should be nice and toasty now! 🔥\n")
+}