Join our Newsletter — 33% off our NHI Course
Home› Guides› Smart Contract Audit Readiness and Choosing an Auditor…
Guide Fraud Prevention

Smart Contract Audit Readiness and Choosing an Auditor Guide: Scope, Prepare and Verify Fixes

PDF for newsletter subscribers · free to read online

← All guides
By NHI Mgmt Group, edited by Lalit Choda Updated 27 October 2026 13 min read
On this page

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 activityWhat it gives youWhat it does notWhen to use
Internal testing (unit, integration, fuzz, mutation)Continuous evidence that code does what you intendIndependent challenge of your assumptionsAlways, before and after audits
Static analysis (for example Slither, Aderyn)Cheap detection of known patternsBusiness logic flawsAlways; clear findings before an audit
Private auditDeep, accountable manual review by a chosen teamCoverage beyond the team's time boxBefore first deployment and major upgrades
Competitive auditMany perspectives in a short windowSingle accountable reviewer, deep contextAfter a private audit, or for broad coverage on a budget
Formal verificationProof that specified properties holdProtection from wrong or missing specificationsMaths-heavy logic and critical invariants
Bug bountyContinuous external review of live codePre-launch assuranceFrom deployment onwards, sized to funds at risk
Monitoring and emergency controlsTime to respond when something is missedPreventionAlways 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.

ItemContentsWhy auditors need it
Protocol overviewPlain-English description of what the system does and its componentsDefines intended behaviour against which logic flaws are judged
Specification and invariantsProperties that must always hold (for example, total shares match total assets), maths formulas simplifiedInvariants drive manual and fuzz review
Flow diagramsEvery interaction path, including liquidation, withdrawal and emergency flowsShows sequences an attacker can combine
Roles and privilegesEvery role, what it can do, who holds it (multisig thresholds, timelock delays)Centralisation and privilege abuse review
Design choices and known issuesAccepted risks, limitations such as supported token types or capsAvoids paying to rediscover known items
DependenciesLibraries and versions, external contracts and oraclesIntegration and supply chain review
Test suite and coverage reportUnit, integration (often fork tests), fuzz and invariant tests, with coverageLets reviewers test edge cases rather than basics
Static analysis resultsOutput of Slither or similar, with each finding fixed or justifiedRemoves low-hanging defects from the paid time
NatSpec commentsFunction-level documentation in codeethereum.org recommends it to make review easier
WalkthroughRecorded or live session on architecture, critical areas and trade-offsSEAL 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

CriterionEvidence to ask forRed flag
Track recordPublished reports on similar protocols; findings searchable in public databasesNo public reports, only logos
Domain expertisePrior work on your type (lending, DEX, L2, bridge) and language (Solidity, Vyper, Rust, Move)Generic web2 testers reviewing on-chain logic
MethodologyTools used, manual review approach, fuzzing or formal verification where needed, severity schemeNo clear methodology or standard report format
TeamNamed reviewers and their time allocationBait and switch: seniors on the call, juniors on the code
Mitigation reviewFix review included, with time agreedReport only, no re-review
Pricing and scopePrice tied to defined scope and durationVery 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

  1. Check the commit hash and scope on the report match what you intend to deploy, file by file.
  2. Triage each finding as fixed, partially fixed, acknowledged (accepted risk with a reason) or disputed. Do not leave findings silent.
  3. Write a regression test for every fixed finding before changing code, so the fix is proven and stays fixed.
  4. Keep fixes small and separate from new features; SEAL's mitigation phase depends on auditors re-reviewing only the fix diff.
  5. Get the final report covering every fix and residual risk, and publish it with the deployed addresses and commit.
  6. Verify deployed bytecode matches the audited source (verified source on the block explorer, reproducible build), and record proxy implementation addresses.
  7. 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

ActivityNIST SP 800-53 Rev. 5NIST CSF 2.0Web3 reference
Secure development and testingSA-15, SA-11 Developer Testing and EvaluationPR.PS-06SEAL Security Testing
Static analysisSA-11(1) Static Code AnalysisID.RA-01EthTrust [S]
Fuzzing and dynamic testingSA-11(8) Dynamic Code AnalysisID.RA-01SEAL Fuzz Testing
Independent auditCA-8 Penetration TestingID.IM-02SEAL External Security Reviews; EthTrust [M], [Q]
Change control to audited hashCM-3 Configuration Change ControlPR.PS-06SEAL Expectations, snapshot in time
Bug bountyRA-5(11) Public Disclosure ProgramID.RA-01SEAL Bug Bounties
Exploit responseIR-4 Incident HandlingRS.MA-01SEAL 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

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

PDF for subscribers

Take this guide with you

Every section, table and checklist in one PDF, with links to the sources and related guides. Subscribe to our weekly NHI & AI Identity Journal and we’ll email you a download link.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Researched and written by the NHI Mgmt Group editorial team using AI tools, under the editorial direction of Lalit Choda. Facts are drawn from the sources listed on this page and checked by our automated quality process. Last updated 27 October 2026. Spotted an error? Use our contact page.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM and Agentic AI security. nhimg.org

PDF Downloads for Newsletter Subscribers

Get the guide

Enter your details and we’ll email you a download link.

The full guide is free to read online. The PDF is a thank you for subscribing.

Fill in all fields marked * and tick the PDF box to continue.