Home / Services / Solidity audit

Web3 & Crypto · Solidity audit

Solidity audits by people who write exploits in Foundry for a living.

Solidity is where most of the money in Web3 sits, and where most of it has been lost. We audit EVM contracts line by line — Ethereum, Arbitrum, Optimism, Base, Polygon, BNB Chain, Avalanche and any other EVM network — and prove every Critical and High finding with a Foundry test you can run yourself.

What we test

  • Every Solidity contract in scope, read manually, including libraries and inherited code
  • Access control, ownership, roles, initialisers and upgradeable proxy patterns (UUPS, Transparent, Diamond)
  • Reentrancy in all its forms — single-function, cross-function, cross-contract and read-only
  • Arithmetic, rounding direction, share-price inflation and fee accounting in ERC-4626 style vaults
  • External call safety: unchecked return values, delegatecall, selfdestruct, callbacks and hooks
  • Token integrations: fee-on-transfer, rebasing, ERC-777, permit and non-standard ERC-20 behaviour
  • Signatures and replay: EIP-712, nonces, chain-id, malleability and off-chain order flows
  • Gas griefing, unbounded loops, block-stuffing and MEV exposure of the design

What you get

  • Report with findings ranked Critical / High / Medium / Low / Informational
  • Foundry proof-of-concept test for every Critical and High
  • Remediation per finding, with Solidity diffs where useful
  • Static analysis (Slither) and fuzzing (Echidna / Foundry invariant tests) results, triaged by hand
  • Free retest and a publishable final report

What a Solidity audit from us looks like

We start by building the project locally and running your test suite, because an audit of code that does not compile the way the team thinks it does is worthless. We then read every contract in scope — not a sample — with the storage layout, inheritance graph and external call graph drawn out next to us. Tooling runs in parallel: Slither for pattern detection, Foundry invariant tests and Echidna for property fuzzing. Tool output is triaged by the same engineer doing the manual review, so you never receive a false positive dressed up as a finding.

The EVM-specific bugs we go looking for

Beyond the classics — reentrancy, access control, integer issues — the findings that keep appearing in 2026 post-mortems are subtler: precision loss that becomes exploitable at scale, first-depositor share inflation in vaults, storage collisions after an upgrade, signature replay across chains that share an address, oracle reads that can be moved inside a single transaction, and permissioned functions that assume a trusted caller who can in fact be a contract. We also model the economics: can a flash loan make a profitable path out of your invariant assumptions?

Chains and frameworks

We audit Solidity on Ethereum mainnet and all EVM-compatible networks and rollups, including Arbitrum, Optimism, Base, zkSync Era, Polygon, BNB Chain, Avalanche and Linea, and note the chain-specific differences that matter — precompiles, opcode support, sequencer behaviour, reorg assumptions and bridge trust. Foundry is our default framework for proofs of concept; we work in Hardhat projects as well, and we are comfortable with Vyper and Yul where they appear.

Who hires us for Solidity audits

DeFi protocols before a mainnet launch or a major upgrade; token and launchpad teams that need a clean report for exchanges and investors; DAOs integrating third-party contracts; and teams that already had an audit but have shipped significant changes since. If the contracts will hold real user funds, a manual Solidity audit is the cheapest insurance you will ever buy.

Timeline

A small contract set — a token with vesting, a staking contract, a simple vault — takes about a week. A mid-size protocol with two to five thousand lines takes two to three weeks; larger systems are scoped per module. Every quote is fixed, in writing, and includes one retest. We can usually start within one to two weeks of signing.

Engagement

How an engagement runs

01

Scope

We agree targets, rules of engagement and what success looks like — in writing, before anything starts.

02

Recon

We map your full attack surface the way an adversary would, not just the assets you remembered to mention.

03

Exploit

We attempt real exploitation and chain small weaknesses into business-level impact.

04

Report

You get prioritised findings, proof-of-concept and remediation steps a developer can act on today.

05

Retest

We verify every fix so issues stay closed — and you get a clean report to show customers.

FAQ

Questions about solidity audit

Do you audit upgradeable contracts and proxies?

Yes. Upgradeable systems get specific attention: initialiser protection, storage layout compatibility between versions, admin and timelock design, and the selfdestruct or delegatecall paths that can brick an implementation.

Which tools do you use for Solidity audits?

Foundry for proof-of-concept exploits and invariant fuzzing, Slither for static analysis, Echidna for property-based fuzzing, and our own scripts for storage layout and call-graph analysis. Tooling supports the manual review; it never replaces it.

Can you audit a fork of an existing protocol?

Yes, and forks deserve particular care: the diff from upstream is where most fork exploits live, and upstream findings that were patched after the fork point are often still present.

How long does a Solidity audit take?

One week for a small contract set, two to three weeks for a mid-size protocol. We can usually start within one to two weeks of signing, sooner at a rush premium.

Find out what an attacker would find first.

Send us what you want tested. We'll come back with scope, timing and a fixed quote — no sales theatre.

Start on Telegram