Reading A Smart Contract Audit Report Before Depositing Into A Protocol
The badge versus the document
Almost every protocol that wants deposits puts the word “audited” somewhere on its site. There’s a logo in the footer, a line in the docs, sometimes a green shield next to the deposit button. For a lot of farmers, that’s where the research stops. Audited means someone checked it. Someone checked it means it’s fine.
That reading is wrong in a specific way. An audit is a document written by a team who spent a limited amount of time reviewing a specific version of specific code, and then wrote down what they found. It tells you what was looked at, what was wrong with it at the time, and what the protocol did about it. It doesn’t tell you the protocol is safe, and good auditors say so on the first page.
The useful move is to open the document. Audit reports follow a fairly standard structure, and you don’t need to read Solidity to get real information out of one. You need to know where to look: what code was in scope, which exact version was reviewed, how serious the findings were, whether they were fixed, and whether the thing you’re about to deposit into is actually the thing that was audited.
For farmers this matters more than for most users. Points programs and pre-token protocols often ask you to deposit early, when the code is newest and least battle-tested. Deposits tend to sit for weeks or months to qualify. And farmers spread capital across many protocols, which means many sets of contracts, each a separate chance for something to go wrong.
This piece walks through an audit report section by section, explains what each part tells a depositor, and covers the gaps an audit can’t fill. It focuses on contract risk to deposited funds. Tokenomics, team questions and general due diligence are covered in separate pieces on this site.
Find the real report first
Before you read anything, make sure you’re reading the right document.
Protocols link to audits from their docs or a security page. That link might go to a PDF hosted by the protocol, a page on the auditor’s own site or a public repository where the auditor publishes reports. The last two are better. A PDF hosted only by the protocol could, in principle, be edited or could be a report for a different version of the code.
Check that the auditor lists the report. Most established audit firms publish their reports, or at least a list of clients and engagements, on their own site or in a public repository. If the protocol claims an audit by a well-known firm and that firm has no record of it, treat the claim as unverified. Fake audit badges exist, and so do reports that were real but covered an earlier, unrelated codebase.
Note the date. The cover page or introduction will say when the review took place. A report from a long time ago may have little to do with what’s deployed now, especially if the protocol has shipped new versions since.
Count the audits. Many protocols have several reports from different auditors covering different versions or components. That’s normal and usually a good sign. It also means you need to work out which report covers which contract you’re depositing into.
And look for the absence. If a protocol asking for significant deposits has no audit at all, or only says “audit in progress”, you’ve learned something important before reading a single page.
The scope section is the most important page
If you only read one part of an audit report, read the scope.
The scope lists exactly what the auditors reviewed. Usually that’s a repository, a set of files within it and sometimes a list of contracts by name. Anything not on that list wasn’t reviewed in this engagement, no matter how prominently the protocol’s site displays the auditor’s logo.
Compare the scope with what you’re actually using. If you’re depositing into a vault contract, is that vault in scope? If the vault relies on a strategy contract, an oracle adapter or a router, are those in scope? It’s common for a protocol’s core contracts to be audited while newer additions, such as a fresh vault type, a points module or a cross-chain component, were deployed later and either audited separately or not at all.
Scope sections also list what was explicitly excluded. Typical exclusions include external dependencies, the frontend, off-chain services, deployment scripts, economic or game-theoretic design and anything behind admin keys. These exclusions are honest. They tell you which risks the audit didn’t try to address.
Pay attention to scope language like “the following changes” or “the diff between version A and version B”. Some audits review only the changes made since a previous audit, which means the report covers a small part of the system on its own and needs to be read alongside the earlier one.
A useful exercise is to write down, in one line each, the contracts your deposit actually touches, and then tick off which ones appear in some report’s scope. Any unticked contract is unaudited as far as you can tell.
The commit hash ties the report to real code
Somewhere near the scope, a good audit report states the exact version of the code that was reviewed. That’s usually a commit hash from a git repository: a long string that uniquely identifies one snapshot of the code.
The commit hash matters because code changes. Protocols fix bugs, add features and refactor between the audit and deployment, and often after deployment too. An audit of one commit tells you about that commit. It doesn’t automatically tell you about the code a week later.
Many reports list two commits: the one initially reviewed and a later one containing the fixes, which the auditors checked in a follow-up. The later commit is the one you want to compare against deployed code, because it’s the version the auditors signed off on after fixes.
Checking this link fully means comparing the deployed contract’s verified source code on a block explorer against the code at that commit. For most farmers, a full comparison isn’t practical. But there are lighter checks worth doing.
Is the deployed contract’s source verified on the explorer at all? Unverified contracts can’t be compared to anything, and that’s a red flag on its own.
Does the protocol publish a list of deployed addresses along with the commits or versions they correspond to? Some mature protocols do, and it’s a sign they take this link seriously.
Did the protocol deploy long after the audit’s fix review? A big gap raises the chance that code changed without review.
A report with no commit hash at all is much weaker evidence, because there’s no way to know which code it describes.
Reading the severity table
Most reports summarise findings in a table near the front: a count of issues by severity, and often a list with each finding’s title, severity and status.
Severity scales vary by auditor but are broadly similar. Critical and high findings usually mean funds could be stolen or permanently locked under realistic conditions. Medium findings often involve losses under specific conditions, or serious problems that require unlikely circumstances. Low findings are minor issues or edge cases. Informational or “note” findings are code quality, gas usage or best-practice suggestions.
Read the definitions. Each report should explain what its severities mean, usually as a combination of impact and likelihood. A high-impact bug with low likelihood might be rated medium by one firm and high by another. The definitions let you interpret the table on its own terms.
Don’t judge a protocol by the raw count. A report with many findings isn’t necessarily worse than one with few. Thorough auditors often find more, and early codebases are expected to have issues. What matters more is the nature of the serious findings and what happened to them.
A report with zero findings of any kind is worth a second look rather than a sigh of relief. It can mean the code was excellent. It can also mean the scope was tiny, the time was short or the review was shallow.
Look at the titles of high and critical findings even if you can’t follow the technical detail. Titles like “attacker can drain vault via reentrancy” or “incorrect share calculation allows theft of deposits” tell you what kind of failure the code was prone to, and whether that failure would have affected the contract you’re about to use.
Resolved, acknowledged and the ones that stayed
Each finding usually has a status, and this is where many readers skim when they should slow down.
Resolved or fixed means the protocol changed the code, and the auditors reviewed the fix and agreed it addressed the issue. That’s the best outcome. It’s worth checking the fix was reviewed, not just claimed. Reports often note “fix verified in commit” with a hash.
Partially resolved means the fix addressed some of the issue, not all of it. Read the auditor’s comment to understand what’s left.
Acknowledged means the protocol accepted the finding but chose not to change the code. Sometimes that’s reasonable: the team may argue the scenario can’t happen in practice, or that fixing it would break something more important. Sometimes it’s a risk they’ve decided you’ll carry. The report usually includes the protocol’s response, and it’s worth reading in their own words.
Unresolved, open or disputed means the issue was reported and not fixed as of the report. For a high or critical finding, that’s a serious problem. It means that at the time of writing, the auditors believed there was a way to lose funds, and the protocol didn’t change it.
Centralisation findings deserve special attention. These are findings along the lines of “the owner can change parameters that affect user funds” or “admin can upgrade the contract without delay”. They’re often marked acknowledged, because the protocol intends to keep those powers. For a depositor, they’re among the most important lines in the report, because they describe what the team itself could do to your funds, whether deliberately, by mistake or because an admin key was stolen.
Anatomy of a single finding
The summary table tells you how many issues there were. The individual finding tells you what they meant. Most reports lay each one out in the same order, and once you know the order, even a technical finding becomes readable.
It starts with a title and severity. The title is usually a one-line description of the problem, and it’s often the most useful line for a non-developer.
Then comes a description. This explains where in the code the issue is, often naming the contract and function, and what goes wrong. You don’t need to follow every line of code quoted here. Look for plain statements like “a user can withdraw more than they deposited” or “rewards can be claimed twice”.
Next is the impact. This is the part to read closely. It says who loses what, under which conditions. “All depositors can lose funds” is very different from “the last user to withdraw may receive slightly less than expected due to rounding”.
Many findings include a proof of concept: a test or a step-by-step scenario showing the issue actually works. Its presence means the auditors didn’t just suspect a problem. They demonstrated it.
Then there’s a recommendation, the auditor’s suggested fix, and finally the protocol’s response and the auditor’s follow-up. The response is where you learn how the team thinks. “Fixed in commit” followed by “verified” is the ideal. A long argument about why the issue doesn’t matter, followed by “acknowledged”, is worth weighing against the impact described above it.
If you read nothing else in detail, read the full text of every high and critical finding, including the response. That’s usually a handful of pages, and it tells you more about the protocol’s risk than the rest of the document combined.
Oracles, price feeds and other things the code trusts
Many DeFi losses start with bad prices. A lending market that values collateral wrongly can be drained without any bug in the lending logic itself. So it’s worth checking what the report says about the data the contracts rely on.
Look for findings or notes about oracles. Common issues include using a price that can be moved within a single transaction, not checking whether a price is stale, not handling a feed that stops updating, and assuming a stablecoin is always worth exactly one dollar. Each of these has caused real losses across the industry.
Check whether the oracle itself was in scope. Often the audit covers the protocol’s use of an external price feed, but not the feed. That’s normal, and it means you’re also trusting the feed’s operator and design.
Look at how the protocol values its own vault shares or receipt tokens. If other protocols accept your deposit receipt as collateral, and that receipt’s price can be manipulated, the risk spreads beyond the protocol you deposited into.
The same thinking applies to anything else external the contracts trust: a bridge’s message, a keeper that triggers liquidations, a signer who posts off-chain data on-chain. If the report treats any of these as trusted and out of scope, write that down as a dependency.
You won’t be able to judge oracle designs in depth, and that’s fine. The aim is to know which external inputs could hurt your deposit, so that when you see news about one of them, you recognise it as relevant.
Upgradeable contracts and admin keys
Many protocols deploy their contracts behind a proxy, which allows the underlying code to be replaced later. This is common and has legitimate uses: fixing bugs, adding features, responding to emergencies. It also changes what an audit means.
With an upgradeable contract, the address you deposit into stays the same, but the code running behind it can change. An audit of the original implementation tells you about that implementation. If the protocol upgrades to a new implementation, the audit may no longer describe what’s running, unless the new version was also reviewed.
So for any upgradeable protocol, ask who can upgrade, and how. The answer usually appears in the audit’s centralisation findings, the protocol’s docs or the explorer, which often shows whether a contract is a proxy and what its current implementation is.
The arrangements vary widely. An upgrade might be controlled by a single key, which is the weakest setup. It might be controlled by a multisig, which is better, especially if the signers are known and independent. It might sit behind a timelock, which delays upgrades by a set period so users can see them coming and withdraw if they disagree. Or it might go through a governance vote.
A timelock is especially valuable for depositors, because it turns a surprise into a warning. If upgrades take effect only after a delay, you have a window to leave.
The same applies to other admin powers: pausing deposits or withdrawals, changing fees, changing oracles, whitelisting strategies or moving funds between vaults. Each is a lever someone can pull. The audit should list them. Your job is to decide whether you’re comfortable with who holds them.
What an audit doesn’t cover
Audits are narrow by design. Knowing what’s outside them helps you avoid treating the report as a promise.
Economic attacks are often out of scope or only partly covered. An attacker who manipulates an oracle price, uses a flash loan to distort a pool, or exploits an incentive design may not need a code bug at all. The code does exactly what it was written to do, and the design is what fails.
Integrations and dependencies are often excluded. If a vault deposits into an external lending market or uses an external bridge, the audit of the vault may not cover what happens if that external protocol fails.
Frontends are rarely in scope. A compromised website can ask you to sign something malicious even if every contract behind it is perfect. This is how many losses happen in practice, and no contract audit addresses it.
Deployment and configuration are frequently excluded. Contracts can be audited correctly and then deployed with wrong parameters, wrong admin addresses or missing initialisation.
New chains add their own risks. A contract audited for one environment may behave differently on another with different fee mechanics, opcodes or tooling.
And time is outside every scope. The audit covers the code as it was. It can’t cover bugs introduced later, or new attack techniques discovered after the review.
Good reports list their limitations in a disclaimer section. It’s worth reading once, carefully, because it states in the auditor’s own words what the report doesn’t promise.
Audit contests and bug bounties
Beyond traditional audits, many protocols also run competitive audits or bug bounties. These appear in reports and security pages, and they’re read a little differently.
A competitive audit, often called an audit contest, opens the code to many independent reviewers for a fixed period, with rewards for valid findings. The result is usually a public report listing all valid findings and their severity. These reports can be long, because many reviewers look at the same code from different angles. The same principles apply: check the scope and commit, read the serious findings and check what was fixed.
A bug bounty is an ongoing offer to pay for vulnerabilities found in deployed code. Its size and terms say something about the protocol. A bounty scaled to the value held in the contracts suggests the team takes post-deployment security seriously. A token bounty, or one with vague terms, suggests less.
Neither replaces an audit, and neither guarantees anything. But a protocol with a well-scoped audit, a fix review, a contest and a live bounty has done more to find problems than one with a single old report.
It’s also worth checking whether any bounty or contest findings are disclosed. Some protocols publish post-mortems of bugs found and fixed after deployment. That kind of openness is a better signal than a clean record that nobody can verify.
A worked example
Here’s how a read might go, using a made-up protocol.
A new points program offers boosted points for depositing a stablecoin into a yield vault. The site says “audited by two firms”. You open the docs and find links to two reports.
Report one, from an established firm, covers the protocol’s core lending contracts. Its scope lists six contracts and a commit hash. The review took place eight months ago. There were two high findings, both marked resolved with a fix commit verified. There’s one acknowledged medium: the admin can change the interest rate model without delay.
Report two, from a smaller firm, covers “the vault module”, dated three months ago. It lists a commit hash. It has one high finding marked acknowledged, with the team’s response that the scenario requires an admin error. It also notes that the vault’s strategy contracts were out of scope.
On the explorer, the vault you’d deposit into is a proxy. Its implementation was last upgraded two weeks ago. The upgrade is controlled by a multisig with no timelock. The strategy contract the vault currently uses doesn’t appear in either report’s scope.
What does that add up to? The core contracts look reasonably reviewed. The vault you’d actually use had a high finding left unfixed, relies on an unaudited strategy, was upgraded after its audit, and can be upgraded again at any moment by a small group of signers.
None of that proves anything will go wrong. It does tell you what you’re exposed to, and it might change how much you deposit, how long you leave it or whether you deposit at all.
Questions the report should help you answer
After reading, you should be able to answer a short set of questions. If you can’t, the report or the protocol’s documentation is missing something.
Which contracts will my deposit touch, and which of them were audited?
Which exact version of each contract was reviewed, and does that match what’s deployed now?
Were the serious findings fixed, and was the fix reviewed?
What findings were acknowledged rather than fixed, and do any of them affect the contract I’m using?
Who can upgrade, pause or change the contracts, and is there a delay before changes take effect?
What does the protocol depend on that the audit didn’t cover: oracles, bridges, external protocols, off-chain services?
How long ago was the review, and what has changed since?
Keep your answers somewhere. If you farm many protocols, a short note per protocol with these answers is far more useful than trying to remember which one had the acknowledged high finding. It also makes it easier to revisit when a protocol announces an upgrade.
What the audit badge gets wrong
A few common interpretations of audits cause real harm.
“Audited means safe.” It means reviewed, for a period, at a version, within a scope. Many protocols that were later exploited had audits, sometimes several. That’s not an argument against audits. It’s an argument for reading them.
“More audits means safer.” Multiple audits of the same code by different teams do add confidence. Multiple audits of different parts, or of old versions, add less. Count the audits that cover what you’re using.
“A famous auditor means it’s fine.” Reputation matters, and established firms have track records. But even excellent auditors work within time and scope limits. A famous name on a narrow scope is still a narrow scope.
“No findings is perfect.” It can be. It can also mean the review didn’t go deep.
“The audit covers the whole protocol.” It almost never does. Read the scope.
Keeping track after you deposit
An audit is a snapshot. Your deposit is a position that lasts. So the reading doesn’t end on the day you deposit.
Watch for upgrades. If the contract you’re in is upgradeable, the protocol will usually announce upgrades, and explorers show when a proxy’s implementation changes. When it does, check whether the new version has a published audit or fix review. If it doesn’t, you’re now in unaudited code, whatever the old report said.
Watch for new audits. Protocols often publish fresh reports when they add features. A new report may reveal findings in code you’re already exposed to, sometimes with a note that they were fixed after deployment. That’s useful to know, both about the risk and about how the team handles it.
Watch for incidents involving dependencies. If a price feed, bridge or external protocol listed in your notes has a problem, check whether your deposit is affected. You’ll find out faster if you wrote the dependencies down.
Watch for changes to admin powers. A protocol that moves upgrade rights from a multisig to a timelock is reducing your risk. One that shortens a timelock or adds new admin functions is increasing it.
For a farm with deposits across many protocols, this can be a short monthly routine: open your notes, check each protocol’s announcements and each contract’s implementation address, and flag anything that changed. It takes minutes per protocol, and it catches the most common way an old audit becomes irrelevant.
Using the report to size a deposit
An audit report doesn’t give you a yes or no. It helps you decide how much exposure to take and for how long.
If the contracts you’ll use were audited recently, at a version that matches deployment, with serious findings fixed and reviewed, admin powers limited or delayed and dependencies reasonable, you’ve done what a farmer can reasonably do. The remaining risk is real, but it’s the ordinary risk of using DeFi.
If some of those conditions aren’t met, you can still decide to participate. But it’s sensible to size your deposit so that losing it wouldn’t hurt badly, to withdraw sooner rather than parking indefinitely, and to watch for upgrades or announcements more closely.
If the contracts you’d use weren’t audited at all, or had unresolved critical findings, or can be changed instantly by one key, that’s a reasonable point to decide the points aren’t worth it. There will be other programs.
This is a risk judgement, not investment advice, and it makes no prediction about whether any protocol will pay out or keep its value. The goal is knowing what you’re exposed to before your funds are inside someone else’s contract.
Where this approach has limits
Reading audits well makes you better informed. It doesn’t make you an auditor, and it can’t find bugs the auditors missed.
Some reports are written in dense technical language that’s hard to interpret without a coding background. Even then, the scope, commit, severity table, statuses and centralisation findings are readable by anyone willing to spend twenty minutes.
Some protocols make this harder than it should be, with audits buried, unlinked or only summarised. That difficulty is information too.
And I haven’t audited any of the protocols discussed on this site, so nothing here is a verdict on a specific project. What reading the report gives you is a clear picture of what was checked and what wasn’t, which is the honest basis for deciding how much to trust a contract with your funds.
For more on protocol risk, deposit decisions and the research we do before putting a farm’s capital anywhere, head back to the Airdrop Farming homepage.
Get new guides and videos first — join the Telegram channel.