A bug bounty is not a security programme. It is an incentive structure, and like any incentive structure it pays for exactly what it rewards. Programmes that reward volume get noise; programmes that reward severity and pay quickly get the bugs that would otherwise have been sold on a dark market.
Understanding how those incentives actually work is the difference between a programme that reduces risk and one that produces a queue of low-severity reports nobody will fix.
What the researcher actually does
Three activities pay, and only the first is the one most people picture.
Discovery is off-chain analysis and on-chain forensics: reading bytecode and decompiled source, tracing fund flows across bridges, and probing live contracts for the assumptions their authors made without noticing. The useful mental trick is to ask what the code assumes about the world — that a callback will not re-enter, that an oracle price cannot move within a block, that an initialiser has already run — and then go looking for the case where the assumption is false.
Responsible disclosure is the protocol of reporting to the affected party before the public. In practice it means a scope document that says what is in bounds, a severity rubric, a response-time commitment, and a payout table. Where those are missing, researchers guess, and guessing is how you get either a public exploit or an unpaid report.
Fund rescue is the rare third mode. When an exploit is already in progress, a researcher who understands the mechanism can sometimes front-run the attacker and return the funds. This is where the line between security researcher and white hat becomes genuinely blurry, and where legal risk concentrates.
Where the bugs live
The classes that pay most have been stable for years, because they are properties of the architecture rather than of any particular codebase.
In contracts: reentrancy (the classic, still live whenever a contract makes an external call before updating its own state), access control gaps (missing modifiers, wrong role checks, a onlyOwner that is the deployer's EOA), oracle manipulation (spot prices read from a thin pool), and proxy and initialisation flaws, where an upgradeable contract can be re-initialised or its implementation switched by the wrong address.
In infrastructure: bridge signature verification (the single highest-value target class, given the history), validator-key compromise, weak randomness, and off-chain components — APIs, relays, and the operational layer that nobody audits because it is not Solidity.
Economic attacks are their own category, and the hardest to score. Flash-loan governance votes, liquidation cascades engineered by manipulating a feed, and peg pressure are all correct code used incorrectly. A bounty rubric built around memory-safety and access-control bugs has no severity rating for "this protocol is solvent only under assumptions that a funded attacker can break."
The legal line is not hypothetical
Researchers operate under real legal exposure, and pretending otherwise is how people get indicted.
Computer-fraud statutes — the US Computer Fraud and Abuse Act and its equivalents — can criminalise unauthorised access even with good intent and no theft. Jurisdiction is unclear: you may be reporting to a DAO with no legal entity while sitting in a country whose courts claim reach. And there are convictions in the adjacent space: the Bitcoin Fog operator was convicted of money laundering, the Helix operator pleaded guilty to money laundering conspiracy, and the Samourai Wallet founders were charged over a mixing service — none of them bounty researchers, but all of them reminders that "the code is open" is not a defence.
The norms that have emerged are narrow and worth respecting. Never move funds you did not lose. Confirm scope in writing before you start poking. Give a private window to fix before publishing. Do not extort, and do not accept a payment that is conditional on staying silent about a live bug.
What the money looks like
The payout curve is steep and severity is the whole story. A critical find — funds at risk, reachable by an unprivileged actor — is where the large rewards sit, often in the low-to-mid six figures for a major protocol. High severity (funds at risk under specific conditions, or governance takeover) is an order of magnitude below that. Medium and low findings are typically paid in the hundreds to low thousands, and informational reports are frequently unpaid by design.
Platforms shape the process. Immunefi dominates Web3 bug bounties and sets many of the industry's severity definitions. Code4rena and Sherlock run competitive audit contests where many researchers review the same codebase and findings are scored against each other, which suits protocols that want broad coverage before launch rather than an ongoing programme. Legacy platforms like HackerOne and Bugcrowd handle Web2 surfaces — the API, the marketing site, the admin panel — which are routinely the weakest link and routinely out of scope.
Two failure modes recur. Programmes that set a maximum payout far below what an exploit is worth get one of two outcomes: the bug is reported and the researcher resents it, or it is not reported. And programmes with no triage capacity accumulate reports until researchers stop submitting, because the reward for a good find becomes uncertainty.
Notable operations
Three incidents are worth knowing because they define the range of outcomes.
The 2016 DAO drain showed what happens when a vulnerability is not disclosed before it is exploited: roughly $60 million in ETH moved through a reentrancy bug, and the response — a contentious hard fork — split the network.
Poly Network in 2021 was the other pole. An attacker moved around $611 million across chains, and after negotiation returned essentially all of it. The case is cited as a white-hat success and as evidence of how ambiguous the category is.
Ronin in 2022 is the cautionary one. Roughly $625 million was taken by compromising validator keys rather than by exploiting contract logic — no amount of Solidity review would have caught it, because the bug was operational.
If you want to do this
The skill set is unglamorous: read and reason about Solidity and Rust, understand DeFi mechanics well enough to know what "correct" means, think adversarially, and be able to trace transactions. The tooling is public — static analyzers, symbolic execution, fuzzing frameworks, and a block explorer used carefully.
The paths run through independent bounty hunting, audit firms such as OpenZeppelin and Trail of Bits, in-house security at a protocol, or building the tooling itself. The economics favour depth over breadth: the routine reviewer who understands one primitive deeply usually outperforms the generalist skimming twenty codebases.
The honest limit
Bounties do not replace audits, and audits do not replace monitoring. A programme's real value is measured in what it pays relative to what the bug is worth to someone else, and in how fast it triages. If the maximum bounty is smaller than a liquidation bonus, the market has already told you where the bug will be reported.
References
Next, read Smart Contract Audits 101. More in Security & Privacy.