Learn how to evaluate an audit report before you trust a protocol with funds. This guide covers four checks: verifying the audited code matches the deployed contract, decoding resolved vs. acknowledged findings, spotting scope gaps, and catching admin privilege risks like weak multisig thresholds, with examples from Drift, Compound, and Euler and a quick checklist.

Learn how to evaluate an audit report before you trust a protocol with funds. This guide covers four checks: verifying the audited code matches the deployed contract, decoding resolved vs. acknowledged findings, spotting scope gaps, and catching admin privilege risks like weak multisig thresholds, with examples from Drift, Compound, and Euler and a quick checklist.
Learning how to evaluate an audit report is a different skill from reading one. Most readers skim the summary, see a green "passed" badge, and move on. That habit has cost investors real money. You need to treat the report like a legal document to be cross-examined, not a badge to be trusted, and that means checking four specific things: whether the code matches, what each finding's status actually means, where the scope quietly ends, and who still holds the keys after the audit closes.
This guide walks through all four checks with the exact sections of a report to open first.
An audit report tells you that a group of security researchers reviewed a specific version of the code for a bounded set of risks, within a limited time window, and documented what they found. It doesn't tell you the protocol is safe to use with unlimited funds.
Secureum's Rajeev put it plainly: "Audit is not a security guarantee of 'bug-free' code by any stretch of imagination but a best-effort endeavour by trained security experts operating within reasonable constraints of time, understanding, expertise and of course, decidability." That sentence belongs on the first page of every audit report, even though it rarely is.
The data backs this up. Halborn's Top 100 DeFi Hacks Report found that only 20% of the DeFi protocols hacked in the period it studied had been audited at all, yet those audited protocols still accounted for 10.8% of total value lost. An audit shrinks your odds of getting hacked, but it does not zero them out.
Two well-documented cases show why. Compound Finance was audited and still suffered a 2021 bug that caused over $90 million in unintended token distribution. Euler Finance had passed audits and still lost $197 million in 2023 to a previously unseen attack vector. In both cases, "audited" was true on the day the report was signed and stopped being the full picture the moment conditions changed.
This matters because an audit is a snapshot, not a subscription. As QuillAudits has pointed out when comparing bug bounties against audits, once meaningful changes land in the code after the review, the parts of the report covering the old logic are no longer current and may need a fresh look. Treat every "audited" badge as dated the moment you see it, and check what date it actually carries.
Start here, because it's the check most readers skip entirely: does the audited code match what's actually live on-chain? A report can be flawless and still be irrelevant if it covers a contract that isn't the one you're interacting with. QuillAudits has written a full structural primer on what's inside a smart contract audit report if you need the section-by-section rundown first; what follows here is how to judge the section once you're looking at it.
Every credible report states a specific commit hash and, for EVM chains, a Solidity compiler version with its settings. Open a block explorer, pull the deployed contract's verified source and bytecode, and compare both against what the report cites.
Hacken's deployment audit methodology for EVM contracts lays out the baseline check: verify that deployed bytecode matches source code and build artifacts, and confirm that the contract is verified on a block explorer like Etherscan or Blockscout. A matching function signature or a similar-looking source file is not proof on its own; the deployed bytecode itself has to match what the audit covered.
Proxy architectures add a step most readers miss. The proxy address staying the same on a block explorer means nothing if the logic behind it has changed through an upgrade. One practical guide to reading a smart contract audit report frames this partly as a governance question, pointing readers to check "whether upgrade authority sits behind a timelock and multisig" rather than trusting that an unchanged proxy address means unchanged logic.
Pull the current implementation address from the proxy contract yourself and compare it against the implementation that was live when the audit was performed. If a report doesn't name an implementation address, or the implementation address on-chain today doesn't match the one the audit covered, you are not looking at audited code. You're looking at a document about a different contract.
Every finding in a report carries a status, and that status word is doing more work than most readers give it credit for. "Resolved" and "acknowledged" look similarly reassuring at a glance. They are not the same thing, and the gap between them is where a lot of readers stop paying attention right when they should start.
None of these except "resolved" removes the underlying risk from the live contract. A report with a long list of acknowledged findings isn't a clean report, it's a report with an attached list of accepted risks.
A low or informational finding marked "acknowledged" is usually fine; teams reasonably triage minor issues against ship dates. A high or critical finding marked "acknowledged" is a different story, and it deserves your full attention before you treat the protocol as safe.
Ask three questions when you see this combination: what specific condition triggers the vulnerability, what would it cost an attacker to trigger that condition, and has the team published a concrete mitigation such as a monitoring system, a circuit breaker, or an admin pause function that offsets the risk they chose not to fix in code. If the report gives you a vague justification and no compensating control, treat the finding as present-tense, not past-tense.
An audit only covers what it was asked to cover. Scope gaps are not dishonest by default, every audit has boundaries, but an undisclosed or poorly explained gap is where a lot of real-world losses have hidden.
A report scoped to a single token or vault contract typically does not cover the multisig that controls it, the timelock (or absence of one) gating upgrades, the oracle feeding it price data, the bridge moving assets in or out, or the frontend and backend infrastructure serving users. Each of those is a separate attack surface with its own history of exploits, and none of them shows up in a report that only lists Solidity files.
The Drift Protocol case is a clear example of this gap in practice. Two separate audit firms had issued passing reports on Drift's contracts, yet the protocol was still breached through a 2-of-5 multisig threshold with zero timelock protecting it, a governance and operational-security weakness that sat entirely outside the code each audit firm had scoped. Multiple clean code audits said nothing about whether the keys controlling that code were safely distributed.
Before you even get to the findings, read the scope section for what it admits and what it leaves unstated:
The Security Alliance's broader point is worth internalizing: "As of today, the best way to evaluate security reviewers is their historical performance." It recommends checking a platform like Solodit to read a firm's published findings history before trusting a single report from them in isolation. A sloppy or templated report from a given firm is a pattern, not a one-off.
This is the gap that code review structurally cannot close on its own, because admin privileges are a governance and operational question layered on top of code that may be flawless in isolation. A contract can have zero exploitable bugs and still hand an attacker everything they need through a poorly configured admin key.
A low signature threshold on the multisig controlling a protocol's admin functions means an attacker only needs to compromise a minority of signers, not all of them. QuillAudits' own research into admin-layer risk cites Radiant's 3-of-11 multisig threshold as an example of exactly this exposure: with eleven signers but only three required to approve an action, compromising any three gives an attacker full control, regardless of how clean the audited contract logic is.
A timelock, or the lack of one, compounds this. Without a timelock, an admin action executes the moment it's signed, giving users zero warning and zero window to react to a malicious or compromised upgrade. The Drift Protocol breach mentioned earlier combined both weaknesses: a 2-of-5 multisig and no timelock at all, on contracts that had already cleared two separate code audits.
When you read a report, check whether it discusses the multisig threshold and timelock duration protecting the contracts it reviewed. Many reports simply don't, because that configuration lives outside the audited files.
Search the audited contract, not just the report, for any function an admin key can call that changes user funds or contract behavior: unrestricted mint functions, pause functions that can freeze withdrawals indefinitely, blacklist functions that can lock specific addresses out of their own funds, and upgrade functions that can swap the entire implementation. A report that lists these functions as findings but marks them "acknowledged by design" is telling you the centralization risk is real and intentional, not a theoretical edge case. QuillAudits' research hub publishes standard-specific audit checklists if you want a reference for what a thorough review of these functions should look like before you compare it against the report in front of you.
None of this makes a project malicious. Plenty of legitimate protocols run upgradeable, pausable contracts during their early life for good reasons. But you, as the reader, need to know these powers exist and who holds them, because the audit report alone won't flag that risk for you unless it explicitly says so.
Run through this before treating any audit report as a reason to trust a protocol with funds:
| Check | What to look for | Where to find it |
|---|---|---|
| Code match | Commit hash and compiler settings in the report match deployed bytecode | Block explorer verified source vs. report appendix |
| Proxy logic | Current implementation address matches the audited commit, not just the proxy address | Block explorer, proxy admin contract |
| Finding status | No high or critical findings left "acknowledged" without a stated compensating control | Findings table, status column |
| Scope boundaries | Admin contracts, multisig, oracle, and bridge either covered or explicitly explained as out of scope | Scope section |
| Admin privileges | Multisig threshold, timelock duration, and mint/pause/upgrade functions documented | Scope section, contract source, project docs |
| Firm track record | Published findings history and consistent reporting format across past engagements | Solodit or the firm's own report archive |
| Report date vs. code | No material code changes since the report's commit hash without a follow-up review | Git history, deployment transaction |
If you're assessing the auditor rather than just the report in front of you, the guide on red flags when choosing a smart contract auditor covers vendor-level signals like fixed pricing without scoping and anonymous teams that complement the checks above.
A clean audit report is a strong signal, not a final answer. The four checks that separate a credible report from a rubber stamp are the same ones a careful lawyer would apply to any signed document: confirm it describes the thing actually in front of you, read every qualifying word in the findings rather than skimming for green checkmarks, map what the document deliberately leaves out, and ask who still holds unilateral power after the ink dries.
Protocols change code after an audit closes, which is exactly why a one-time review has a shelf life; QuillAudits has written separately about why continuous security needs to extend beyond a single audit. The same logic applies to governance: admin keys, multisig composition, and timelocks can all change after launch, so the admin-layer checks in this guide are worth repeating periodically, not just once before you invest. For a deeper look at the kind of scope gap that let two passing audits miss a critical governance flaw, see QuillAudits' analysis of the Drift Protocol case, and for examples of audited protocols that were still hacked, the Compound and Euler breakdown is worth reading in full.
Contents

From day-zero risk mapping to exchange-ready audits, QuillAudits helps projects grow with confidence. Smart contracts, dApps, infrastructure, compliance: secured end to end.