The only Bitcoin lottery that uses genuine elliptic curve cryptography. Every address generated is a real, valid Bitcoin address with a real private key. 100% client-side. Nothing leaves your browser.
₿ START MINING Learn How It WorksBitcoin addresses are derived from private keys through a one-way cryptographic pipeline. There are approximately 2160 possible Bitcoin addresses — a number so large it exceeds the number of atoms on Earth. This lottery generates real private keys and derives real Bitcoin addresses, checking each one against known funded addresses.
A cryptographically secure 256-bit random number is generated using crypto.getRandomValues() — the same entropy source used by real Bitcoin wallets. Each key is a number between 1 and the secp256k1 curve order N ≈ 1.158 × 1077.
The private key is multiplied against the secp256k1 generator point G using double-and-add scalar multiplication over the finite field Fp where p = 2256 - 232 - 977. This produces a public key point (x, y) on the curve. This is the most computationally expensive step — and it's implemented from scratch in pure JavaScript. No libraries.
The full public key (65 bytes) is compressed to 33 bytes using the x-coordinate and a parity byte (0x02 or 0x03). This is the standard compressed public key format used by modern Bitcoin software.
The compressed public key is hashed with SHA-256, then the result is hashed with RIPEMD-160 (implemented from scratch — 80 rounds of bitwise operations). This produces a 20-byte hash called the "public key hash" — the core of a Bitcoin address.
Two addresses are derived from the same key:
Bech32 (bc1...) — Native SegWit format using Bech32 encoding with BCH error detection.
Legacy (1...) — Base58Check encoding with version byte 0x00 and double-SHA256 checksum.
Both derived addresses are checked against a curated list of known funded Bitcoin addresses. If either matches — JACKPOT. Mining stops instantly, a full-screen alert appears, and the private key is displayed, copied, and saved to localStorage.
Probability of finding a specific address:
= 1 in 1,461,501,637,330,902,918,203,684,832,716,283,019,655,932,542,976
That's more possibilities than atoms on Earth (≈ 1050).
To put this in perspective: if every computer on Earth (≈ 5 billion) ran this program at 1 million keys per second, running 24/7 for the entire age of the universe (13.8 billion years), you would still have explored less than 0.000000000000000000001% of the address space.
And yet — someone has to be the one. The math doesn't say it's impossible. It says it's astronomically unlikely. But every key checked is a real, valid attempt. Every address generated is genuine. The cryptography doesn't lie.
Most "bitcoin lottery" programs are simulated — they generate random strings and pretend they're Bitcoin addresses. This one is real. Every private key undergoes genuine secp256k1 elliptic curve point multiplication. Every address passes the same mathematical pipeline used by Bitcoin Core, Electrum, and every real Bitcoin wallet.
If this program finds a match, the private key it gives you will actually work. You can import it into any Bitcoin wallet and access the funds. That's not a simulation — that's mathematics.
The moment a matching address is found, the mining loop halts. No more keys are generated. Your winning key is preserved.
A golden overlay appears showing both addresses (Bech32 + Legacy) and the complete WIF private key. Victory fanfare plays.
The private key is immediately saved to your browser's localStorage — a permanent backup in case you accidentally close the tab.
One-click copy to clipboard AND download as a text file. The tab also shows a "don't leave" warning if you try to navigate away before saving.
Import the WIF key into Electrum, BlueWallet, or any Bitcoin wallet. Transfer the funds to your own address immediately.
secp256k1 elliptic curve point multiplication, SHA-256, RIPEMD-160, Bech32, Base58Check — all implemented from scratch.
Everything runs in your browser. No server communication. No data exfiltration. Your keys never leave your machine.
No npm packages. No external libraries. No CDN calls. Pure vanilla JavaScript. One self-contained HTML file.
Real-time rate graph, address feed with scrolling cards, total keys checked counter, matches found counter, elapsed time.
Paste any 256-bit hex key and verify the full derivation pipeline — see the exact addresses that key produces.
Auto-save to localStorage, clipboard copy, file download, tab-close prevention. Your winning key is protected from every angle.
For the technically curious, here's the exact mathematical pipeline:
All arithmetic operates over Fp where p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F. This is a 256-bit prime. Addition, multiplication, and modular inverse (via Fermat's little theorem: a-1 = ap-2 mod p) are implemented using JavaScript's native BigInt.
Elliptic curve point addition follows the standard formulas: λ = (y₂-y₁)/(x₂-x₁), then x₃ = λ²-x₁-x₂, y₃ = λ(x₁-x₃)-y₁. Point doubling uses: λ = (3x₁²+a)/(2y₁) where a=0 for secp256k1.
Q = k·G is computed via the double-and-add algorithm: scan bits of k from MSB to LSB, doubling at each step and adding G when the bit is 1. For a 256-bit key, this requires at most 256 doublings and ~128 additions.
Implemented from scratch: message padding, 80 rounds of nonlinear functions (f, g, h, i, j) applied in two parallel streams with different rotation constants, producing a 160-bit digest. This is the algorithm that gives Bitcoin addresses their length.
Yes. Generating Bitcoin private keys is not illegal. Bitcoin is open-source software and anyone can generate keys. Whether you can spend from an address depends on whether you have the correct private key — which is exactly what this program attempts to find.
Mathematically, the odds are astronomically against it. The Bitcoin address space is 2160 — larger than the number of atoms on Earth. However, every attempt is a genuine, valid attempt. The program doesn't simulate anything. If it finds a match, it's real.
On modern hardware, about 2-10 keys per second. The bottleneck is the elliptic curve point multiplication — each key requires ~384 modular multiplications over 256-bit numbers. This is genuine cryptographic work, not string matching.
Yes, with WebAssembly or GPU compute shaders. But even at 1 billion keys per second, the expected time to find a specific address is longer than the age of the universe. The beauty is in the attempt, not the expectation.
Absolutely. Everything runs in your browser. No data is sent to any server. You can verify this by viewing the source code or monitoring network requests. The program works completely offline once loaded.
A curated list of known high-value Bitcoin addresses embedded in the source code. You can modify this list to target any address you want.
Because at 1 in 2160, finding a match would be, by any reasonable definition, a miracle. We built this with respect for both the mathematics and the faith that anything is possible.