A useful Solidity audit is a repeatable review of the contract system, not a scan for suspicious code. Start with the exact source and build configuration, define the assets and trust assumptions, and write down the invariants the system must preserve. Then review privileged actions and external interactions, test edge cases and transaction sequences, combine automated tools with manual analysis, and verify every fix. A clean tool report or completed audit reduces risk; neither proves a contract is bug-free.
What to assemble before the audit
Begin with the version of the system that is actually intended for deployment or upgrade. An audit of a different source revision, compiler configuration, or dependency set may not describe the deployed code.
As an Amazon Associate I earn from qualifying purchases.
- The exact source revision and build settings, including the Solidity compiler version.
- The dependency lockfile and the versions of imported contracts or libraries.
- Deployment configuration, including initialization and upgrade arrangements where applicable.
- An architecture description: contracts, external protocols, user roles, and the calls between them.
- A plain-language description of intended behavior, failure handling, and any emergency or pausing behavior.
Record the reviewed revision and configuration so test results and findings can be tied to a specific build. Solidity’s Security Considerations documentation cited here is for version 0.8.23; compiler and platform behavior can vary, so check documentation for the project’s actual compiler rather than applying version-specific guidance indiscriminately.
How to define scope and threat-model the system
Model the contracts as a state machine, not a collection of isolated functions. Identify the states the system can enter, who can move it between them, what crosses contract boundaries, and what must remain true as balances, shares, debt, rewards, and permissions change. Ethereum.org’s security guidance recommends using threat modeling to prioritize high-value or weak areas when review time is limited.
#1 Best Overall
List what can be lost or changed
Identify user funds and other assets at risk, as well as protocol properties attackers might manipulate: supply, fees, eligibility, implementation addresses, or access rights. Note external protocols and tokens the design relies on. Include governance and operational actors in the model; a technically sound role check can still leave a serious risk if the privileged key is poorly controlled.
Write invariants before writing more tests
State critical guarantees in plain language first. For example, specify which actors may move funds, what must remain consistent across a deposit and withdrawal, or what conditions must hold after minting or burning. Then translate those statements into tests or properties. Secure, symmetrical state transitions matter: examine both directions of a process instead of checking only the usual successful path.
Threat modeling is a way to focus the review, not a substitute for it. Adam Shostack’s Threat Modeling: A Practical Guide for Development Teams is supplemental general threat-modeling material; it is not a Solidity audit checklist.
Rank #2
How to review permissions and administrative powers
Make an inventory of every function and state variable that can affect funds, token supply, implementation addresses, fees, roles, pause state, or user eligibility. For each sensitive action, establish who can call it, how that authority is assigned, and what the action can change.
- Check for missing, overly broad, misassigned, or unexpectedly inherited permissions.
- Review initialization and ownership or role transfer, including revocation and emergency actions.
- For upgradeable systems, determine who can authorize an upgrade and whether implementation and administrative responsibilities are separated as intended.
- Trace the consequences of minting, pausing, withdrawing, changing configuration, and moving user assets—not just whether a modifier appears on the function.
- Consider how privileged keys are controlled operationally and whether multi-party approval fits the project’s risk.
Slither summaries can help surface visibility, authorization relationships, and inheritance structure, but a reported relationship needs contextual review. Confirm that the actual caller restrictions match the system’s intended trust model.
How to trace external calls and reentrancy
For every external call, token transfer, callback, and low-level call, follow the storage reads and writes on both sides of the interaction. Solidity 0.8.23’s Security Considerations documentation states: “Any interaction from a contract (A) with another contract (B) and any transfer of Ether hands over control to that contract (B).” That handoff means the callee may call back before the original operation has finished.
Questions to ask at each interaction
- Can the callee reenter the same function or a different function that uses the same state?
- Does an invariant temporarily stop holding while control is outside the contract?
- Can a callback, unusual token behavior, or failed call take a different path than the normal case?
- Are state changes and checks-effects-interactions ordered appropriately for this code path?
- If a reentrancy guard is used, does it cover every relevant shared-state path rather than just one entry point?
Do not stop at searches for .call. Follow control flow through token hooks, proxy or delegatecall behavior, cross-function paths, and error handling. Reentrancy is one external-control-flow risk; economic assumptions and protocol composition require separate analysis.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11How to check arithmetic, state transitions, and edge cases
Exercise values and sequences that ordinary successful transactions may not cover. Review zero, minimum, and maximum inputs; rounding direction; division by zero; casts; precision and decimal assumptions; and loop limits. Check consistency across paired operations such as deposit and withdrawal or mint and burn. Ask whether unusual sequences can leave balances, shares, debt, rewards, or permissions inconsistent.
Test boundaries and state transitions against the invariants you defined, not just against expected example inputs. Solidity 0.8.23 documentation also cautions that compiler and platform bugs remain possible; record and assess the project’s exact compiler version and settings.
How to review tokens, standards, and upgradeability
Token integrations
Do not assume an external token behaves like a simple reference implementation. Where relevant to the integration, examine return-value handling, fee-on-transfer behavior, rebasing, callbacks, decimals, blacklist or pause controls, and other non-standard transfer semantics. Ethereum.org’s security checklist recommends targeted token-integration and ERC conformance checks. The OWASP Smart Contract Security Verification Standard version 0.0.1 (2024) also includes requirements concerning rebasing, rewards, fee handling, Merkle claims, arbitrary user input, and low-level calls.
Upgradeable systems
Treat upgrade architecture as explicit audit scope. Review initialization, implementation and admin separation, storage-layout compatibility, upgrade authorization, and recovery procedures. A review of ordinary contract logic alone does not establish that an upgrade path is safe.
Free tools Windows power users keep installed
One-click scans. No signup required.
Which tests and analysis tools to combine
Use multiple methods because they answer different questions. Ethereum.org’s tools guide describes the following trade-offs; its runtime and finding descriptions are guidance, not guarantees for every project or current tool release.
| Method | Useful for | Effort or runtime described in the guide | What it may miss |
|---|---|---|---|
| Slither static analysis | Fast checks for common and structural issues; relevant printers or checks can help inspect inheritance, visibility, authorization, and standards conformance. | Seconds; the guide describes moderate missed-bug risk and low false alarms. | Static analysis can miss issues, and any warning needs contextual review. |
| Echidna property-based fuzzing | Generating inputs and transaction sequences against properties that express protocol invariants. | Minutes; the guide says it reports true positives. | Random exploration can miss bugs because it does not exhaust every possible state. |
| Manticore symbolic execution | Deeper analysis of selected, high-value properties where the setup and cost are justified. | Hours; the guide’s “none” missed-bug and false-alarm entry is qualified by all paths being explored without timeout. | Results depend on the properties and paths explored; timeouts limit what has been established. |
| Unit and integration tests | Checking intended behavior and assembling adversarial sequences and boundary cases. | Not stated in the guide. | Ordinary unit tests focus on expected behavior and are not, by themselves, well suited to the edge cases where security flaws often live. |
| Manual review | Business logic, economic assumptions, protocol composition, transaction ordering or front-running, privacy assumptions, and cryptographic operations. | Not stated in the guide. | It depends on reviewer judgment and scope; use it alongside, not instead of, executable checks. |
For fuzzing, properties should express system guarantees rather than merely restating individual function outputs. For symbolic execution, choose critical properties deliberately: an analysis result only speaks to the properties and paths actually explored. Neither method makes manual reasoning unnecessary.
How to triage findings and verify fixes
Keep confirmed vulnerabilities distinct from tool warnings and unresolved design questions. For each finding, document enough information for another reviewer to reproduce and assess it.
- Affected contract and function, plus the reviewed source revision.
- Reachable conditions and the capabilities an attacker would need.
- Likely impact and the invariant or intended behavior at risk.
- Evidence or a reproduction, such as a failing test or sequence.
- Proposed remediation and the tests or analyses that will verify it.
After changing code, rerun relevant tests and analyses on the changed revision. Request an independent review of the fixes and of any high-impact paths. An audit can find flaws missed earlier, but it cannot promise to find every bug.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →How to prepare for deployment and incidents
Security work includes the ability to detect and respond to problems after deployment. Review deployment and recovery procedures alongside the code. Confirm the team can identify deployed versions and dependencies, monitor contracts, secure privileged wallets, and determine what actions are available if a flaw is found. Document upgrade or migration procedures and prepare an incident response plan before it is needed.
How to choose an independent review
When arranging an external review, compare the reviewers’ relevant protocol experience, stated scope and exclusions, independence, deliverable quality, remediation and retest process, schedule, and approach to handling findings. Ethereum.org lists audit firms and competitive audit platforms as ecosystem resources, but the presence of a provider on a resource list does not establish its current terms, availability, or relative quality. Evaluate the engagement itself rather than treating a provider name or completed audit as a security guarantee.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
