
A smart contract audit reviews code and design for security weaknesses, but cannot guarantee safety. Learn what auditors test and how to read their findings.
In brief
- An audit is a structured review of selected code and assumptions, not a guarantee against every exploit.
- Audit reports describe scope, findings and fixes; unreviewed components and later changes remain important.
- Security also depends on operations, permissions and monitoring after deployment.
What an audit actually reviews
A smart contract is code that runs according to rules enforced by a blockchain.
An audit examines whether a particular implementation behaves as intended and whether an attacker might make it behave differently.
Auditors review code, test assumptions, and look for paths that could put funds or permissions at risk.
The review concerns a defined version of a project, not every possible component of its ecosystem.
A completed audit therefore provides evidence of scrutiny rather than proof that a contract is safe.
Audit scope matters because a DeFi application rarely consists of just one contract.
It may depend on price oracles, upgrade controls, external protocols, user interfaces, and privileged operators.
A report might cover the core lending contract while leaving the website, bridge integration, or deployment configuration outside its boundaries.
A weakness in an excluded component can still harm users.
Readers should distinguish the exact files and contract versions examined from the broader product that uses them.
Auditors typically work from a specification explaining how the system should function.
They compare intended behavior with actual code and assess economic assumptions such as collateral ratios or withdrawal limits.
Tests can reproduce suspicious sequences of transactions, while manual reasoning can uncover mistakes that automated tools miss.
Different teams use different methods and time budgets.
Even careful reviewers cannot exhaust every possible interaction among users, markets, and outside services.
Vulnerabilities an audit can uncover
An audit can identify access-control errors that let the wrong account move funds, change configuration, or mint assets.
It may find accounting mistakes, unsafe external calls, unexpected state changes, or failures in liquidation and withdrawal logic.
Reviewers also examine whether a malicious contract can exploit how another contract handles callbacks.
Such defects are often subtle: the application may appear normal during simple testing but fail when several actions are combined in an unusual order.
Automated analysis helps detect recognized classes of problems and highlights suspicious patterns.
Unit tests check individual behaviors, integration tests exercise connected contracts, and simulated adversarial transactions probe abnormal conditions.
Manual review remains essential because a program can follow its code perfectly while violating the economic design.
For example, a loan might be valid according to a faulty price input yet dangerous for the pool.
No single testing technique covers all these possibilities.
Audit findings are generally assigned severity levels, but labels are judgments rather than universal measurements.
A critical issue may threaten substantial assets or core authorization, while a lower-severity observation may concern reliability, assumptions, or future maintenance.
Some reports include informational recommendations that are not direct vulnerabilities.
A finding's practical importance depends on the actual deployment and surrounding controls.
Counting findings alone does not reliably show which of two protocols is safer.
What an audit cannot promise
Auditors cannot guarantee that every exploit path has been found.
Software behavior may depend on unusual transaction ordering, market stress, chain conditions, or integrations that change later.
Economic attacks can exploit incentives or liquidity assumptions without relying on a traditional coding mistake.
Even a mathematically sound mechanism can behave poorly when its assumptions fail.
Audits reduce uncertainty within their scope, but residual technical and financial risks remain after the report is published.
An audit also cannot secure an organization's internal operations.
Stolen administrator keys, compromised build systems, malicious front-end code, and fraudulent communications may bypass the contracts reviewed.
A protocol with upgrade authority can introduce new code after the original review, and changing parameter values can alter risk even without new code.
External services may fail independently.
These are reasons to evaluate the entire operating system around a contract, not only the published audit badge.
The report describes evidence available at a particular point in the software's development.
A fix for one issue may produce another issue, so meaningful remediation should be reviewed and tested.
A project can also deploy bytecode that differs from the audited version.
Verification requires connecting the report's commit or version to the actual deployed contracts.
Without that link, a reader cannot assume that the reviewed implementation is the one handling user transactions.
How to interpret an audit report
The first useful section is the scope: which repository, commit, contracts, and dependencies were included.
Next are the assumptions about trusted administrators, oracles, and integration partners.
These statements reveal where the reviewers placed the boundary of their analysis.
A report covering a narrow module can still be valuable, but it should not be described as an audit of an entire platform.
Multiple audits can offer different viewpoints without eliminating risk.
The findings section usually explains the issue, its impact, and the developers' response.
Possible statuses include fixed, acknowledged, or unresolved.
A developer may accept a risk because of architectural constraints, but acknowledgment is not the same as a correction.
Readers can also look for a follow-up review of important fixes and whether test coverage was expanded.
The reasoning behind a finding matters more than the headline severity count or a promotional summary.
Audits work best as part of ongoing security practices that include independent testing, restrained administrative privileges, monitoring, and incident response plans.
Public code, bug bounty programs, and transparent upgrade procedures can make scrutiny easier, although none alone establishes safety.
A useful security assessment asks what was reviewed, which assumptions remain, what changed afterward, and how failures would be handled.
The central lesson is that an audit informs judgment; it does not replace it.