Every price on Edge Option is generated, not taken from a market feed. A single seed per day produces the whole path for every asset.
That design only means anything if you can check it. So: the platform publishes SHA256(seed) before the day starts and the seed itself after it ends. This tool takes those two public values, rebuilds the price path on your machine, and tells you whether the numbers you were shown follow from the seed they committed to.
You do not have to trust the platform. You do not need an account. Run it and read the output.
git clone https://github.com/ahmedsedeheee/edgeoption-verifier && cd edgeoption-verifier
npm install
npm run verifyExit code is 0 only if every check passed.
1 · Commitments. For every day whose seed has been revealed: is SHA256(seed) equal to the fingerprint that was published before that day began? If the operator had swapped a seed after watching how trades went, the old fingerprint would no longer match. This is one hash per day, and it is the check that makes the rest meaningful.
2 · Leakage. Is a seed that has not been revealed yet exposed anywhere in the public feed? This matters more than it sounds. The price is a pure function of time, so anyone holding today's seed can compute any future moment, not just past ones — that is a guaranteed-profit hole, not a privacy nit. It has happened on this platform before: the seed was being sent in a socket message and shown on a public endpoint, and both were closed on 2026-08-03. The check runs every time so a regression cannot go unnoticed.
3 · Reproduction. Rebuild a full day — 1,440 samples, one per minute — from the revealed seed and print a digest over the whole path. Run it on another machine and you must get the same digest, character for character.
4 · Your own quote. The question that actually matters when you lose a trade:
node dist/src/verify.js --quote EURUSD_otc 1754697600000 1.04711Take any settled trade from your history — asset, timestamp, price — and this recomputes what the price must have been at that instant from the committed seed. If they differ, you have a reproducible complaint, not a suspicion.
This is the part most "provably fair" pages leave out.
- It does not prove the prices track any real market. They do not, and the platform does not claim they do. The assets are named
SYNTH-EUR,SYNTH-BTCand so on for exactly this reason. Success here says nothing about trading real markets. - It does not prove the seed was chosen innocently. Commit–reveal proves the path was not changed after the fact. It cannot prove the operator did not generate many candidate seeds and publish a commitment to a flattering one. What limits that is the second check plus the fact that every participant trades the same path — an operator tilting the day tilts it for everyone, winners included.
- It does not audit the settlement engine, the ledger, or the wallet. It verifies prices. Nothing else.
If a verifier tells you it proves more than this, read its code.
seed(day) = HMAC-SHA256(master_secret, "day:" + day)
commitment(day) = SHA256(seed(day))
Commitments for the next several days are published in advance; seeds are released only once a day is finished. The master secret never leaves the server — if it did, every future price would be computable by anyone, which is the failure mode check 2 exists to catch.
Prices come from a hierarchical Brownian bridge: a daily level with damped memory across a 64-day window, then recursive bisection within the day. The property that makes verification cheap is that the price at any instant t is computed directly, with no accumulated state — so checking one moment costs the same as checking the first moment of the day, and a sample at 23:59 is as easy to verify as one at 00:00.
All arithmetic is done in 32-bit integers (Math.imul, >>>) so that a browser and a server produce bit-identical results. Floating-point drift between platforms would have made "reproducible" a word rather than a fact.
fixture/fairness.json is a pinned snapshot of the public feed. It lets the tool run with no network, and lets the test suite defend a fixed digest:
npm run verify:offline
npm testThe pinned digests in test/reproducible.test.ts fail if any future change to the pricing maths alters a single sample. Reproducibility is a property that has to keep holding, not a claim made once.
src/pricing/ the price generator, copied verbatim from the platform.
Pure functions, zero dependencies, no I/O — read it.
src/verify.ts the checks above
fixture/ pinned public snapshot
test/ reproducibility, pinned against the fixture
Zero runtime dependencies. TypeScript and @types/node are the only devDependencies.
An implementation written independently from the description above, arriving at the same digests, would be stronger evidence than this repo. The scheme is documented here so that is possible.
edgeoption.web.app — where the prices described above are generated.
It runs a free weekly tournament, and you do not need an account to see it:
edgeoption.web.app/tournaments
Currently: a 300 USDT pool split across the top three places, free entry, no deposit. Every participant is set to the same starting balance and trades the same price path — which is the part this repo lets you check rather than take on trust. Ranking is by net profit, single-trade size is capped so the result is not one coin flip, and prizes are settled manually after the standings are reviewed, within 72 hours of the end. Full terms are on that page in seven languages.
Same caveat as everywhere else here: the prices are generated and do not track any real market. Doing well in a tournament says nothing about trading real ones.
MIT.