nonce calculations

**"Is there a way to:**
1. Randomly select a starting nonce (uint64_t range),
2. Randomly choose search direction (increment/decrement),
3. Perform a random number of iterations in this direction,
4. Then repeat the process with a new random starting point and direction,
**until the target nonce is found?**

Example flow:
- Start at i0 = 73, decrement for r0 = [random steps] (e.g., 15 steps to 58),
- Jump to new random i1 = 19, increment for r1 = [random steps] (e.g., 5 steps to 24),
- Continue until solution is found."

---

### Pure C++ implementation (PseudoCode):
```cpp
#include <cstdint>
#include <random>

bool validate_nonce(uint64_t nonce); // Your check function

uint64_t randomized_nonce_search() {
    std::random_device rd;
    std::mt19937_64 gen(rd());
    std::uniform_int_distribution<uint64_t> start_dist(0, UINT64_MAX);
    std::uniform_int_distribution<uint64_t> step_dist(1, UINT64_MAX); // Random number of steps
    std::bernoulli_distribution dir_dist(0.5); // Direction

    while (true) {
        uint64_t current = start_dist(gen); // Random start
        bool direction = dir_dist(gen);     // Random direction
        uint64_t steps = step_dist(gen);    // Random number of iterations

        for (uint64_t i = 0; i < steps; ++i) {
            if (validate_nonce(current)) {
                return current;
            }
            direction ? ++current : --current;
        }
    }
}
```

### Key features:
1. **Random number of steps**: `step_dist(1, UINT64_MAX)` - from 1 to the maximum uint64_t
2. **Full space coverage**: Each new cycle starts from a random point
3. **Automatic overflow**: For uint64_t, --0 → MAX and MAX+1 → 0 are correctly handled
4. **Uniform distribution**: All parameters (start, direction, steps) are chosen randomly

### Optimization for multithreading:
```cpp
// Add thread_local for generators in a multithreaded environment:
thread_local std::mt19937_64 gen(std::random_device{}());
```