Two thousand computers searching for the same key, each starting from wherever it pleases, are worth much less than two thousand. They are worth something close to one. This is the most expensive and avoidable problem in this entire area, and solving it doesn't require new math — it requires coordination before starting.
The cause is simple arithmetic. If each machine randomly chooses where to start within a seventy-bit range, the chance of two of them covering different sections is high at the beginning and plummets as the work progresses. The total effort increases, the distinct effort barely grows, and the result is a tired crowd that has swept over the same thing many times.
The solution is to divide the space beforehand. The range is cut into pieces — say a million of them — and each participant receives a piece that no one else has received. When finished, they request another. It's the same logic as a search party for a missing person: the field is gridded on the map, and each team gets a square.
A central server that distributes pieces solves the coordination and creates a new problem: whoever distributes knows everything. They know who searched where, know what has already been swept, and are in a privileged position if the key appears. This leads us to the difficult part.
How does a participant prove they really swept the piece they received? They can't simply say they swept it, because lying is free and rewarding: those who lie receive new pieces without spending energy, and the collective effort ends up with gaps that no one knows exist.
There are partial answers, and it's worth knowing them. The most used is proof by sampling: besides the true target, the server inserts some false targets in the piece, whose responses it already knows. Those who truly swept find these planted targets and return them; those who didn't sweep have no way to guess them. It's not a complete proof — it's a test that's costly to cheat.
The second answer comes from the kangaroo method itself. There, each participant returns the distinguished points they found, and these points are genuine results of work: there's no way to fabricate them without jumping. A collective effort based on kangaroos is naturally easier to audit than one based on sequential sweeping.
And there's the question that precedes all others: what if the key appears? Whoever finds it has, alone and at that moment, the power to take everything. No agreement, contract, or reputation prevents this, because the key is the money. Serious groups solve this with cryptography instead of trust — by dividing the spending authorization in advance among several parties, with the multisig that the intermediate track explained, so that finding alone is not the same as taking alone.
It's worth a note about legality and limits, because it belongs to this subject. Searching for the key to an address someone published as a challenge is a consented exercise: those who funded those addresses put them there to be searched. Sweeping the blockchain for poorly generated foreign wallets is something entirely different, and in practically every place in the world, it's a crime. The technique is the same; the difference lies entirely in the consent of whoever put the money there.
Notice that the whole problem is one of design, not code. Dividing the range is easy. Proving the sweep is difficult. Distributing the find without trusting anyone is a custody problem, and it's exactly the same problem this course has been addressing since the first track, now from the other side of the counter.
You have reached the end of the tools. You know what a range is, how much it costs to sweep it, two algorithms that cut the exponent in half, which hardware executes each task, and how a group organizes itself without self-sabotage. What's missing is the object of study: the challenges that truly exist on the blockchain, who created them, which have already been solved, how they were solved — and how this platform sets up its own. It's the last module of the course.