1000 BTC CHALLENGE
READY
SELECT PUZZLE  (click to load range · green = still open)
0
Keys/sec
0
Checked
0%
Progress
0
Found
SEARCH RANGE & MODE
Start (hex)
End (hex)
Target Address
Address Type
Search Mode
Speed (batch size per tick)
Threads (workers)
Idle
LIVE LOG
FOUND KEYS
— no matches yet —
VANITY ADDRESS SEARCH

Generate random keypairs until the derived address starts with your chosen prefix. The result is a brand-new keypair you control — keep the private key safe.

Desired Prefix
Address Type
🎯 VANITY SEARCH — RANGE BOUND

Same vanity engine as above, but every candidate private key is drawn only from a range you choose. Any match found is mathematically guaranteed to fall inside Lo → Hi. Same hot-path functions are reused, so speed matches the unbounded search.

Desired Prefix
Address Type
Search Range (hex)
Ξ ETH VANITY ADDRESS SEARCH

Generate random keypairs until the derived Ethereum address (Keccak-256 of the uncompressed public key) starts with your chosen hex prefix. The result is a brand-new keypair you control — keep the private key safe.

Desired Prefix (hex)
Case Sensitivity
# SHA-256 HASH TOOL

Hash any UTF-8 string with SHA-256, computed locally in-browser. Updates as you type.

Input String
SHA-256 (hex)
🔑 VERIFY PRIVATE KEY → ADDRESS

Enter a private key (hex or decimal) to derive all address formats. Use this to validate solver results or test known keys.

Private Key (hex or decimal integer)
QUICK TEST — KEYS 1 TO 80

Instantly derive and display all addresses for private keys 1 → 80. Use to verify your browser's secp256k1 implementation is correct against known puzzle answers.

🦘 POLLARD'S KANGAROO — SPEED TEST & SOLVER

Solves in O(2n/2) EC ops instead of O(2n). Requires the public key — only puzzles with exposed pubkeys are eligible. Select one below or enter manually.

Select Puzzle with Known Public Key
Target Public Key (compressed 66-char hex)
Range Lo (hex)
Range Hi (hex)
0
Steps
0
DPs stored
0
Steps/sec
IDLE
Status
LOG
🗝 MASTER SOLVE  (one continuous hunt across the entire #1 → #160 keyspace)

This is the same search engine as the Solver tab, but pointed at a single combined range — from puzzle #1's start key to puzzle #160's end key — checked against all 160 target addresses at once. Nothing is pre-revealed: it's a genuine brute-force walk that happens to turn up a match whenever it naturally reaches a puzzle's real private key, and it keeps going afterward. Given how astronomically large the range gets past roughly 70 bits, don't expect it to ever finish — treat matches beyond the easy end as a very long shot.

Search Mode
Sequential walks the combined range in order from puzzle #1's start key upward — it's what naturally turns up the low-numbered puzzles first, since it passes right through them within seconds. Random instead jumps each thread to scattered, uniformly-random points across its assigned slice — good for broad coverage, but because the low-numbered puzzle keys are a vanishingly small sliver of the full 160-bit range, Random mode is extremely unlikely to stumble onto them; it's better suited to probing broadly rather than to relying on it for the easy end. Random mode also has no finish line — like on the Solver tab, it runs until you stop it.

Godzilla draws keys the same random way, but the value is capped ("padded with zeros") at the bit-width of the lowest-numbered puzzle not yet solved this run — so instead of a uniform draw across the full 160-bit space, every key generated is forced below that ceiling, which is what actually lets the still-open low-end puzzles get hit fast. As soon as that puzzle is solved the ceiling steps up to the next unsolved one — never further, so no cycles are wasted jumping toward the hopeless high end while easier puzzles remain. Like Random, it has no finish line.

Goku always stays up at the full 160-bit end (puzzle #160's range) — it doesn't track which puzzles are solved and never narrows down like Godzilla. Instead, each random candidate is decimal zero-padded before it's tested: its base-10 digits get a random number of trailing digits (currently 0 or 2) forced to zero, so the numbers actually checked are a mix of raw random draws and "rounded" values — e.g. a full ~49-digit draw, or the same draw truncated to 47 significant digits with the rest zeroed. This is a pattern-hunting heuristic (some keys in the wild have turned out to be suspiciously round), not a solving-progress-aware strategy — it has no finish line either.
0
Keys solved
Idle
LIVE LOG
SOLVED KEYS (appear here as the hunt naturally reaches them)
— no keys found yet —
ABOUT THE BITCOIN PUZZLE TRANSACTION

In 2015 an unknown creator sent BTC to 256 addresses derived from sequential private keys in growing bit-length ranges. Each puzzle's private key lies within a specific bit range — puzzle #n's key is between 2^(n-1) and 2^n-1.


As of 2024, puzzles up to #66 and several higher ones have been solved. The remaining puzzles represent real on-chain BTC — anyone who finds the correct private key within the range can claim the funds.


This tool implements pure-JS secp256k1 elliptic curve math (no libraries) to brute-force keys within any range and compare derived addresses to puzzle targets.

TECHNICAL NOTES

• All cryptography runs 100% in-browser — no data is ever sent anywhere.

• SHA-256 and RIPEMD-160 are pure JS with pre-allocated fixed buffers (no GC pressure).

• secp256k1 uses Jacobian coordinates (one modinv/key) + precomputed G table (additions only, no doubling per bit).

• Pubkey written directly from BigInt to Uint8Array — no hex string round-trip.

• Unbiased rejection-sampling RNG sized to the actual range bit-width.

• Worker runs a continuous loop; UI updates via requestAnimationFrame only.

• For GPU-scale searching, use BitCrack or Kangaroo.