Most smart contract audits are bought too late, scoped too loosely and read too briefly, so teams pay for experts to find basic defects and then deploy code that differs from what was reviewed. An audit is a time-boxed expert review of a specific commit, not a certificate of safety, and its value depends almost entirely on what the team does before and after it. This guide covers how to get audit-ready, how to choose between private and competitive reviews and between firms, what a good engagement and report look like, and how audits fit with bug bounties, formal verification and incident readiness. It is for protocol engineering leads, security leads and anyone signing off a deployment. For the vulnerability classes themselves see the Smart Contract Security Guide and the OWASP Smart Contract Top 10 Guide; this page does not repeat them.
Key takeaways
- An audit reviews one commit hash. The Security Alliance (SEAL) frameworks state that audits assess code at a specific commit and any change creates unaudited code, so deployment must be tied to the reviewed hash plus the reviewed fix commits.
- Preparation is where the value is. SEAL advises clearing static analysis findings, writing a specification with flow diagrams, privileged roles and known limitations, and providing unit, integration and fuzz tests before kickoff, so auditors spend time on logic rather than basic defects.
- Private and competitive audits answer different needs. Private audits give a chosen team's dedicated attention; competitive audits put tens or hundreds of researchers on the code for a prize pool. Many high-value protocols use both, in sequence.
- Judge auditors on evidence, not logos. Read their published reports, check stack and domain fit, and treat any vendor that guarantees finding all vulnerabilities as a red flag, as SEAL lists.
- The audit is one layer. ethereum.org warns against treating audits as a silver bullet; pair them with a bug bounty scaled to funds at risk, monitoring, emergency pause and upgrade controls, and an incident plan.
What an audit is and is not
SEAL describes an engagement in phases: scoping, an initial assessment combining automated testing (static analysis, fuzzing, formal verification where used) with manual code and documentation review, an initial report, a mitigation phase where the team fixes and the auditors re-review, and a final report with residual risks, commonly published. ethereum.org frames audits as an additional round of review that helps catch issues missed during development and testing, and stresses that they will not catch every bug.
| Assurance activity | What it gives you | What it does not | When to use |
|---|---|---|---|
| Internal testing (unit, integration, fuzz, mutation) | Continuous evidence that code does what you intend | Independent challenge of your assumptions | Always, before and after audits |
| Static analysis (for example Slither, Aderyn) | Cheap detection of known patterns | Business logic flaws | Always; clear findings before an audit |
| Private audit | Deep, accountable manual review by a chosen team | Coverage beyond the team's time box | Before first deployment and major upgrades |
| Competitive audit | Many perspectives in a short window | Single accountable reviewer, deep context | After a private audit, or for broad coverage on a budget |
| Formal verification | Proof that specified properties hold | Protection from wrong or missing specifications | Maths-heavy logic and critical invariants |
| Bug bounty | Continuous external review of live code | Pre-launch assurance | From deployment onwards, sized to funds at risk |
| Monitoring and emergency controls | Time to respond when something is missed | Prevention | Always for live value-bearing contracts |
Scoping the review
SEAL calls setting a goal for the review the most important and most overlooked step. A scope that is too large or undefined produces shallow coverage.
- Exact contracts and commit: list every file in scope and out of scope, and freeze a commit hash. SEAL's manual review guidance says changes during review should be communicated and the hash updated.
- Integration surface: state which external protocols, oracles, bridges and tokens the code depends on, and whether their behaviour is in scope (for example, fee-on-transfer or rebasing tokens).
- Privileged roles: include admin, upgrade, pause and governance paths, and the multisig or timelock configuration. These are frequently left out and frequently abused. See the Smart Contract Access Control Guide.
- Deployment and upgrade scripts: initialisation order, constructor arguments and proxy wiring belong in scope for upgradeable systems. See the Smart Contract Upgradeability and Proxy Security Guide.
- What is not covered: front ends, signing infrastructure, keys, cloud hosting and off-chain bots are usually outside a contract audit. Say so explicitly and assure them separately.
- Prioritise under budget: for very large systems, SEAL suggests focusing on the most critical parts; rank contracts by value held and privilege.
As a planning guide only, SEAL's own rough estimates for Solidity audits are 1 to 2 weeks for under 1,000 lines, 2 to 5 weeks for 1,000 to 4,000 lines and 5 or more weeks above that, with weekly costs ranging from $1,000 to $60,000 depending on complexity and reviewer expertise. Treat those as order-of-magnitude figures.
Audit readiness pack
Hand the auditors a pack, not a repository link. The SEAL preparation guidance and ethereum.org's best practice list map to these items.
| Item | Contents | Why auditors need it |
|---|---|---|
| Protocol overview | Plain-English description of what the system does and its components | Defines intended behaviour against which logic flaws are judged |
| Specification and invariants | Properties that must always hold (for example, total shares match total assets), maths formulas simplified | Invariants drive manual and fuzz review |
| Flow diagrams | Every interaction path, including liquidation, withdrawal and emergency flows | Shows sequences an attacker can combine |
| Roles and privileges | Every role, what it can do, who holds it (multisig thresholds, timelock delays) | Centralisation and privilege abuse review |
| Design choices and known issues | Accepted risks, limitations such as supported token types or caps | Avoids paying to rediscover known items |
| Dependencies | Libraries and versions, external contracts and oracles | Integration and supply chain review |
| Test suite and coverage report | Unit, integration (often fork tests), fuzz and invariant tests, with coverage | Lets reviewers test edge cases rather than basics |
| Static analysis results | Output of Slither or similar, with each finding fixed or justified | Removes low-hanging defects from the paid time |
| NatSpec comments | Function-level documentation in code | ethereum.org recommends it to make review easier |
| Walkthrough | Recorded or live session on architecture, critical areas and trade-offs | SEAL recommends it as the first step of the engagement |
SEAL's testing framework recommends unit, integration, fuzz and static analysis always, formal verification where the situation warrants it, and mutation testing to check whether the suite would catch realistic faults. A suite with high coverage but surviving mutants has weak assertions.
Choosing the type of audit and the auditor
Private or competitive
- Private audit: one or more researchers chosen by you or assigned by a firm, confidential, direct communication, typically higher cost with more accountable coverage.
- Competitive audit: open participation from many researchers competing for a prize pool, often more cost-effective and broader in perspective, but less personalised, and the code is usually visible to many people before launch.
- Combined approach: a private audit first to remove the bulk of issues, then a competitive audit on the fixed code, then a bounty at launch.
- Small teams: a single reputable solo auditor plus a competitive contest can give better coverage than one mid-tier firm, if the code is small and well tested.
Selection criteria
| Criterion | Evidence to ask for | Red flag |
|---|---|---|
| Track record | Published reports on similar protocols; findings searchable in public databases | No public reports, only logos |
| Domain expertise | Prior work on your type (lending, DEX, L2, bridge) and language (Solidity, Vyper, Rust, Move) | Generic web2 testers reviewing on-chain logic |
| Methodology | Tools used, manual review approach, fuzzing or formal verification where needed, severity scheme | No clear methodology or standard report format |
| Team | Named reviewers and their time allocation | Bait and switch: seniors on the call, juniors on the code |
| Mitigation review | Fix review included, with time agreed | Report only, no re-review |
| Pricing and scope | Price tied to defined scope and duration | Very low price with vague scope; guarantees to find all bugs |
SEAL makes a useful point about judging auditors by incidents: reviewers with many engagements will have had reviewed code hacked, and sequential audits of the same code are not a fair comparison because the later team benefits from earlier fixes. Simultaneous reviews of the same code are the better comparison. Ethereum.org's developer documentation lists auditing services and competitive audit platforms; inclusion there is a listing, not an endorsement.
Standards you can audit against
- EEA EthTrust Security Levels: the Enterprise Ethereum Alliance specification (Version 3, dated March 2025, with a successor expected in the second half of 2026 according to its status section) defines requirements for Solidity contracts at three levels. [S] is designed so most requirements can be checked by automated static analysis, [M] adds stricter analysis and cases where a human auditor judges whether a feature is necessary, and [Q] analyses whether the business logic does what it claims. Each level includes the ones below.
- Conformance claims: EthTrust defines what a valid conformance claim must include, such as issue date, EVM version, spec version, issuer and level, and states that there is no defined certification process for auditors and that certification is not a warranty.
- OWASP: use the OWASP Smart Contract Top 10 as a checklist of categories the report should cover.
Asking for a report structured against EthTrust levels or OWASP categories makes reports from different firms comparable and shows what was not checked.
Reading the report and verifying fixes
- Check the commit hash and scope on the report match what you intend to deploy, file by file.
- Triage each finding as fixed, partially fixed, acknowledged (accepted risk with a reason) or disputed. Do not leave findings silent.
- Write a regression test for every fixed finding before changing code, so the fix is proven and stays fixed.
- Keep fixes small and separate from new features; SEAL's mitigation phase depends on auditors re-reviewing only the fix diff.
- Get the final report covering every fix and residual risk, and publish it with the deployed addresses and commit.
- Verify deployed bytecode matches the audited source (verified source on the block explorer, reproducible build), and record proxy implementation addresses.
- Treat any later change as unaudited until reviewed, including "small" parameter or library updates.
After the audit: bounties, safe harbor and monitoring
- Bug bounty: ethereum.org describes the "scaling bug bounty", paying in proportion to funds at stake, so disclosure is worth more than exploitation. SEAL's bug bounty guidance adds clear scope, published reward criteria, staffed triage and explicit safe harbor for good-faith research. See the Bug Bounty Platform Buyer's Guide.
- Whitehat Safe Harbor: SEAL's Safe Harbor framework lets protocols pre-authorise whitehats to rescue funds during an active exploit, return them to designated recovery addresses within 72 hours, and receive a pre-defined bounty. It is not a substitute for a bounty.
- Monitoring: emit events for privileged and value-moving actions and alert on them off-chain, as ethereum.org recommends, so you can pause or respond quickly.
- Emergency stop and timelocks: ethereum.org describes emergency stop patterns and timelocks for governance actions; both should be in the audit scope.
- Incident plan: SEAL notes that even audited protocols need incident response plans and emergency communication channels. See the Web3 and Crypto Security Guide.
Where identity fits
Audited code is only as safe as the keys that deploy, upgrade and pause it. The deployer account, the multisig signers behind admin roles, CI tokens that publish deployment scripts and the cloud identities that host the front end are all non-human or privileged identities outside a typical contract audit. Record each of them in the readiness pack, state who holds them and how they are protected (hardware keys, threshold signing, short-lived cloud sessions), and ask for a separate review of signing and release infrastructure before launch. See the MPC Wallet and Threshold Signing Security Guide and the Crypto Exchange Identity and Key Security Guide.
Detection and measurement
- Pre-audit static analysis debt: unresolved static analysis findings at kickoff (target zero unjustified).
- Test strength: branch coverage and mutation score for in-scope contracts.
- Findings density by severity per thousand lines, tracked across audits to show whether preparation is improving.
- Fix verification rate: share of high and medium findings confirmed fixed in the final report.
- Deployment drift: lines of deployed code not covered by any audit or fix review (target zero).
- Bounty health: valid reports per quarter, median time to triage and payout.
Framework mapping
| Activity | NIST SP 800-53 Rev. 5 | NIST CSF 2.0 | Web3 reference |
|---|---|---|---|
| Secure development and testing | SA-15, SA-11 Developer Testing and Evaluation | PR.PS-06 | SEAL Security Testing |
| Static analysis | SA-11(1) Static Code Analysis | ID.RA-01 | EthTrust [S] |
| Fuzzing and dynamic testing | SA-11(8) Dynamic Code Analysis | ID.RA-01 | SEAL Fuzz Testing |
| Independent audit | CA-8 Penetration Testing | ID.IM-02 | SEAL External Security Reviews; EthTrust [M], [Q] |
| Change control to audited hash | CM-3 Configuration Change Control | PR.PS-06 | SEAL Expectations, snapshot in time |
| Bug bounty | RA-5(11) Public Disclosure Program | ID.RA-01 | SEAL Bug Bounties |
| Exploit response | IR-4 Incident Handling | RS.MA-01 | SEAL Safe Harbor |
Common failure patterns
- Auditing a moving target: code keeps changing during the review, so the report covers a version nobody deploys.
- Undocumented intent: without a specification, auditors can only find generic bugs; business logic flaws pass because nobody wrote down what correct means.
- Privileged paths out of scope: admin, upgrade and initialisation code left out, then abused or misconfigured at deployment.
- Treating the badge as the control: publishing "audited" while deploying unreviewed fixes or new modules.
- Assuming a contract audit covers the whole system: the Bybit theft of about $1.5 billion involved genuine multisig signatures obtained through tampered front-end JavaScript after a developer's cloud session was hijacked, not a contract bug. See the Bybit Hack 2025 analysis.
- No bounty or response plan at launch: the first researcher to find a flaw has no rewarded route to disclose it.
Practitioner checklist
- Define and freeze scope by file and commit hash, including privileged roles and deployment scripts.
- Clear or justify every static analysis finding before kickoff.
- Deliver a readiness pack: overview, invariants, flow diagrams, roles, known issues, dependencies, tests.
- Measure coverage and mutation score, and add fuzz and invariant tests for critical paths.
- Choose private, competitive or both based on value at risk, and check auditors' published reports.
- Agree a mitigation review in the contract and keep fixes in small, separate commits.
- Verify deployed bytecode matches the audited and fix-reviewed source.
- Launch a bounty scaled to funds at risk, with safe harbor and staffed triage.
- Assure front ends, signing flows and keys separately from the contract audit.
Standards and references
- Security Alliance (SEAL): What to Expect from a Smart Contract Audit
- Security Alliance (SEAL): Preparing for a Smart Contract Audit
- Security Alliance (SEAL): Selecting a Smart Contract Auditor
- ethereum.org: Smart contract security
- Enterprise Ethereum Alliance: EthTrust Security Levels Specification
- Security Alliance (SEAL): Security Testing
- Security Alliance (SEAL): Whitehat Safe Harbor
- NIST: SP 800-53 Rev. 5
Related NHI Mgmt Group resources: Smart Contract Security Guide · OWASP Smart Contract Top 10 Guide · Smart Contract Access Control Guide · Web3 and Crypto Security Guide