Smart contract security is the work of stopping a contract, and the keys, dependencies and systems around it, from moving value in ways its builders never intended. It runs for as long as the code does, because an audit checks one version of a contract under one set of assumptions, and both keep changing after the report is signed.
I put it in two lines in March: an audit does not fail overnight. It expires quietly.
A building inspector signs off a house on the day of the inspection. Knock through a load-bearing wall the following spring and the sign-off is still in the file, signed and dated, describing a house that no longer exists. Nobody lied. The paper simply stopped being about the building.
An audit report works the same way. It is accurate about the code it read, and it says nothing about the code you merged afterwards. This guide covers what smart contract security includes, the vulnerability classes that matter in 2026, the methods teams use against them, and the changes that quietly put an audit out of date.
Quick Answer
Smart contract security is the ongoing work of keeping a contract’s code, permissions, dependencies and surrounding keys from being used to move value in ways nobody intended. An audit is one layer of it. It validates one commit under one set of assumptions, so it needs a fresh look whenever those assumptions change.
What does smart contract security actually cover?
Smart contract security covers four layers: the code, the permissions that decide who can call what, the dependencies and integrations the code trusts, and the people and infrastructure that hold the keys. Each failure in the table below sits in a different one.
| Layer | What goes wrong | A published example |
|---|---|---|
| The code | Logic that runs exactly as written and still does the wrong thing; maths that rounds the wrong way | Balancer V2, November 2025: a rounding direction issue that had been in the code for years (Trail of Bits analysis) |
| Permissions | A privileged role that can act at once, alone, with no window for anyone to react | Adrena, 2026: the single Critical finding was a missing timelock on admin operations, with single-step authority transfer (our Adrena report) |
| Dependencies and integrations | A library, oracle or bridge that behaves differently from what the code assumes | Cetus, May 2025: an overflow check in a shared maths library that checked the wrong thing (our write-up, and Cetus’s incident report) |
| People and infrastructure | Signers, devices, servers and CI pipelines that no contract review reads | Yimmit, 2026: a public deposit webhook that credited balances from amounts and addresses taken straight from the request body (our Yimmit report) |
The last layer is the one founders underrate. Writing about April 2026, I noted that two incidents made up something like 93 to 95 percent of the month’s losses, and neither one was a smart contract exploit. The contracts held. The humans around them did not.
If you are scoping a first review, our manual smart contract audits start from $5,000 and cover the code and permissions layers line by line, including logic and economic risk.
Which smart contract vulnerabilities matter most in 2026?
The OWASP Smart Contract Top 10: 2026 ranks access control first, business logic second and price oracle manipulation third. OWASP calls the 2026 list forward-looking: its order comes from 2025 incident data and a practitioner survey. Here is the full list as of October 2026, with where to read more.
| OWASP rank | Vulnerability class | What it looks like in practice | Read more |
|---|---|---|---|
| SC01 | Access control | A privileged function (admin, governance or upgrade) that the wrong caller can reach | Timelocks and the governance attacks they prevent |
| SC02 | Business logic | Code that does what it says, and not what the protocol means | Formal analysis for founders, without the maths |
| SC03 | Price oracle manipulation | A skewed or stale price feeding borrowing, liquidations or swaps | The oracle staleness finding in our Adrena report |
| SC04 | Flash loan facilitated attacks | A large uncollateralised loan that turns a small bug into a large drain inside one transaction | Flash-loan governance attacks, in our timelock entry |
| SC05 | Lack of input validation | Unsafe parameters from users, admins or other chains reaching core logic | Bridges, and how their verification gets bypassed |
| SC06 | Unchecked external calls | A call to another contract whose failure or callback the caller never handles | Solidity documentation: security considerations |
| SC07 | Arithmetic errors | Scaling and rounding that leak value a little at a time | The Cetus and Balancer bugs audits missed |
| SC08 | Reentrancy | An external call re-entering a function before its state is updated | Solidity documentation: reentrancy |
| SC09 | Integer overflow and underflow | A value wrapping past the limits of its type | Solidity documentation: checked or unchecked arithmetic |
| SC10 | Proxy and upgradeability | An upgrade or initialisation path that is weakly governed | Bridges: when an upgrade changes what counts as valid |
Editor note (remove before publishing): Fidesium’s findings report, which counts how often each class appears across our signed audit reports, is in progress. When it is live, add a “How often we find it” column to this table with each count linked to the report, and link the report from the paragraph above. This page states no counts until then.
Two risks sit outside the list and still need a plan. Transaction ordering (front-running, sandwiching and MEV) is covered in our mempool entry. Keys and people are covered in the April post linked above.
How do teams secure a smart contract?
Teams secure a smart contract by stacking methods that each answer a different question. Tests and fuzzing hunt for inputs that break a rule. Formal verification proves a rule holds. Static analysis flags known patterns. A manual audit reads the logic against what the protocol is meant to do. Bug bounties, monitoring and penetration testing cover the live system and everything around it.
| Method | The question it answers | What it cannot tell you | Go deeper |
|---|---|---|---|
| Fuzzing and invariant tests | Can random inputs and call sequences break a rule you wrote? | Anything about a rule nobody wrote | Fuzzing: what it finds and what it cannot prove |
| Formal verification | Does a written property hold for every possible input? | Whether the specification itself is right | Formal verification |
| Static analysis | Does the code contain known bug patterns? | What the protocol is supposed to do | Solidity static analysis tools |
| Manual audit | Does the logic match the protocol’s intent, including its economics and permissions? | Anything outside the agreed scope | How a smart contract audit works |
| Bug bounty | Will outside researchers find something in live code, for a reward? | What nobody chose to look at | Bug bounty or audit |
| Monitoring | Is something unusual happening on-chain right now? | Whether the code is correct | Continuous monitoring vs one-time audits |
| Penetration testing | Can the servers, keys, APIs and front end around the contracts be broken? | The contract logic itself | Blockchain penetration testing |
The ethereum.org security guidelines make the same point from the other side: an independent review is one of nine steps, next to testing, disaster recovery plans and event monitoring.
Read the third column again. One limit is missing from it, because it applies to every row: each method describes one version of the code. Our fuzzing entry says it plainly: “The run describes one version of the code.” Our formal verification entry says the same of a proof: “It expires when the code changes.” An audit is no different.
Why does a smart contract audit expire?
An audit expires when the code it checked changes, or when the assumptions it validated stop matching the live system. I call the second one audit assumption drift, and it is the riskier of the two, because nothing announces it.
As I wrote then, “The key issue is not code change alone. It is assumption change.” Tests still pass. Deployments succeed. No alarm fires. But the risk model has shifted. A governance contract that assumed limited admin roles gains a new multisig or a delegated role. A dependency upgrade changes how state is handled in some edge case. An oracle is integrated that was never part of the original trust model. None of these breaks anything on the day it ships.
Adrena, a perpetuals exchange on Solana, shows what taking drift seriously looks like. Our assessment covered 33,747 lines of Rust between 10 February and 18 March 2026 and produced three documents, not one. The second covers the v38 to v39 migration: its behavioural differences and its freeze window. A version change was reviewed in its own right instead of being left for the main report to absorb.
Drift can also happen inside an engagement. Our penetration test of the Yimmit exchange ran as an initial review and two re-reviews between June and August 2026. Four of the findings still open at the end “were introduced by changes made during the engagement itself and were raised as new in the final round.” They were found because there was a final round to find them.
The full argument, including why a versionless ‘we were audited’ causes friction in fundraising and exchange listings, is in When does a smart contract audit actually expire?
Which changes need a re-audit, and which do not?
Not every change needs a full re-audit. Changes that leave the system’s assumptions alone usually do not. Changes to invariants, roles, external calls, trust dependencies or fund flows usually need deeper review. The right question is not “Did we change code?” It is “Did we change assumptions?”
| The change | Deeper review? | What it can reopen (OWASP 2026 class) |
|---|---|---|
| UI updates | Usually not | Nothing in the contracts |
| Gas optimisations | Usually not | SC09 integer overflow, if the change adds unchecked blocks |
| Comment edits | Usually not | Nothing |
| Non-sensitive refactors and internal code organisation | Usually not | Nothing, provided behaviour is unchanged and the tests show it |
| Modifying core invariants | Usually yes | SC02 business logic, SC07 arithmetic errors |
| Changing role or permission logic | Usually yes | SC01 access control, SC10 proxy and upgradeability |
| Adding new external contract calls | Usually yes | SC06 unchecked external calls, SC08 reentrancy |
| New cross-contract trust dependencies (oracles, bridges, libraries) | Usually yes | SC03 price oracle manipulation, SC04 flash loan facilitated attacks, SC05 lack of input validation |
| Altering custody logic or fund flow | Usually yes | SC02 business logic, SC01 access control |
The first two columns are the list from my post on audit expiry. The third is our mapping, and it is a starting point for scoping, not a replacement for it.
One row deserves a second look. Since Solidity 0.8.0, arithmetic reverts on overflow and underflow by default, and an unchecked block turns that check off to save gas (Solidity documentation). A gas pass that adds unchecked blocks has removed a safety check. That is an assumption change dressed as a refactor.
Changed code since your audit? Send us the diff and the original report, and we will quote a review priced against what changed (a delta review), not a new audit. Request a quote.
What does smart contract security look like between audits?
Between audits, security means re-running the same checks on every change and watching the live system. Fidesium re-runs audit-grade analysis on every commit, pull request and deployment. It runs on deterministic static and AST (abstract syntax tree) analysis, so the same code gives the same result, and a new result points at the change that caused it.
Every manual audit includes one month of continuous scanning. Each audit is minted as an on-chain NFT tied to the code it covered, so anyone can check which version was reviewed and when. The developer side is on our smart contract tooling page.
For the live protocol, our security services team builds monitoring bots tuned to the protocol’s own logic rather than generic threshold alerts. And every report we have signed and published is on our audits page: 23 reports across 16 protocols, as delivered.
Frequently asked questions
What is smart contract security?
Smart contract security is the work of keeping a contract’s code, permissions, dependencies, and the keys and systems around it, from being used to move value in ways nobody intended. It combines testing, formal verification, static analysis, manual audits, bug bounties and monitoring, and it continues for as long as the code changes.
Is an audited smart contract safe?
An audit does not make a contract safe. It says that named files, at a named commit, were reviewed by a named team, and it lists what they found. It covers that version under the assumptions it checked. Once the code or those assumptions change, the report describes a system that is no longer the one running.
What are the most common smart contract vulnerabilities?
The OWASP Smart Contract Top 10: 2026 ranks access control first, then business logic, price oracle manipulation, flash loan facilitated attacks, lack of input validation, unchecked external calls, arithmetic errors, reentrancy, integer overflow and underflow, and proxy and upgradeability vulnerabilities. The order comes from 2025 incident data and a practitioner survey.
Do I need a new audit after changing my smart contract?
Not always. UI updates, gas optimisations and non-sensitive refactors usually do not need one. Changes to core invariants, role or permission logic, external calls, trust dependencies or fund flows usually need deeper review, often scoped to the change rather than a full re-audit. Our post on when a smart contract audit expires covers the decision in full.
How do I secure a smart contract before launch?
Write down the rules your protocol must never break and test them with fuzzing, using formal verification for the critical ones. Run static analysis, then book a manual audit against a frozen commit. Plan for after launch as well: monitoring, a bug bounty, and a review of every change that alters an assumption the audit relied on.
Security is a process, not a report
Three things to take from this guide:
- Smart contract security covers four layers: the code, the permissions, the dependencies, and the people and infrastructure holding the keys. A review that reads only the first leaves three open.
- Every method has the same expiry clause: tests, proofs, scans and audits each describe one version of the code.
- Re-review follows assumptions, not release frequency. Map each change to the class it can reopen, and scope the review to that.
If you have a launch date coming, or an audit that is older than your last few releases, request a quote. Manual audits start from $5,000 and include two rounds of fix verification, a public report with a badge and an on-chain NFT record, and one month of continuous scanning. Or read our published audit reports first.



