Smart Contract Audit Cost in 2026: EVM, Solana and TON Pricing

Nobody wants to hear "it depends" when they're trying to budget a launch, so let's put numbers on the table first: a competent manual audit for a single mid-complexity EVM contract starts around $8,000, and a full DeFi protocol with multiple interacting modules routinely lands between $35,000 and $90,000+. Solana and TON price differently — not because the auditors are lazier or greedier, but because the languages, tooling maturity, and attack surface are genuinely different. Here's how the math actually works.

What Actually Moves the Number

Auditors don't price by the hour you'd guess from a rate card. Most reputable shops quote by estimated review time, which is a function of four things:

• Lines of code (LOC) in scope — not your whole repo, just what's actually deployed and reachable
• Cyclomatic complexity — how many branches, modifiers, and state transitions per function
• External interactions — oracle calls, cross-contract calls, bridges, flash-loan exposure
• Novelty — a standard ERC-20 wrapper is boring; a custom AMM curve or a new staking derivative is not

A 400-line ERC-20 with a vesting schedule might take 3-4 engineer-days. A 400-line perpetuals engine with funding-rate math and liquidation logic can eat 15+ days, because every function has to be checked against every other function's state changes, not just read top to bottom.

EVM Pricing Tiers (Solidity)

EVM is the most commoditized market, which means pricing is also the most predictable:

Tier	LOC (approx)	Scope example	Typical range
Small	under 500	Token, simple vesting, single-owner vault	$8,000 - $15,000
Medium	500-1,500	Staking contract, NFT marketplace, single-pool AMM	$18,000 - $35,000
Large	1,500-4,000	Multi-pool DEX, lending market, DAO governance stack	$40,000 - $75,000
Protocol-scale	4,000+	Cross-chain bridge, perps engine, multi-module money market	$80,000 - $150,000+

Upgradeable proxies (UUPS or Transparent) add 15-25% to the quote on top of whatever tier the logic falls into, because the auditor now has to check storage-slot collisions across every future upgrade path, not just the current implementation. Diamond/EIP-2535 setups push that premium higher still — we've seen facet interaction bugs that a single-contract review would never catch. If you're weighing whether a proxy pattern is even worth the added audit surface, that's a conversation worth having with whoever is doing your smart contract development before you write the storage layout, not after.

Solana Pricing (Anchor / Native Rust)

Solana audits price on a different curve because the risk isn't just in your program logic — it's in account validation. Missing a has_one constraint, an unchecked signer, or a PDA seed collision is a Solana-specific bug class that doesn't exist in EVM, and checking for it means manually tracing every account passed into every instruction.

Rough ranges:

• Small Anchor program (under 600 LOC, 3-5 instructions): $10,000 - $18,000
• Medium program with CPI calls to other protocols (staking, lending): $22,000 - $45,000
• Large program with multiple PDAs, token extensions, and cross-program invocations: $50,000 - $100,000+

CPI (cross-program invocation) is the single biggest cost multiplier on Solana. Every external call the program makes is another place an auditor has to verify the invoked program is actually the one you think it is, not a spoofed account with the same interface. A program that calls into three other protocols will almost always cost more to audit than a program with twice the LOC but zero CPI.

TON Pricing (FunC / Tact)

TON is the newest and most expensive market per line of code right now, for a simple reason: fewer experienced auditors, immature static analysis tooling, and an actor-model architecture — async messages between contracts, no atomic cross-contract calls — that most reviewers coming from EVM or Solana have to relearn. Bounced messages, gas-forwarding mistakes, and message-value miscalculations are TON-specific failure modes that show up constantly in early Tact and FunC contracts.

Expect:

• Small FunC contract (wallet variant, simple jetton): $9,000 - $16,000
• Medium Tact contract with multiple message handlers: $20,000 - $40,000
• Multi-contract system (jetton + NFT collection + custom logic with async coordination): $45,000 - $85,000

If you're scoping a TON project, it's worth reading through a proper FunC and Tact audit checklist before you even request quotes — half the "surprise" cost increases we see come from clients not realizing their bounce-handling logic was never actually tested.

A Worked Example

Say you're launching a staking vault on EVM: 650 LOC, one external price oracle call, a linear reward-rate calculator, and a withdrawal queue. That's medium tier. A rough estimate an auditor might build internally:

base_hours = LOC / 40          # ~16 hours baseline review
complexity_mult = 1.3          # oracle dependency + queue logic
external_calls = 2 * 4         # 2 external calls, 4h each for trust-boundary checks
total_hours = (base_hours * complexity_mult) + external_calls
            = (16 * 1.3) + 8 = ~29 hours manual review

# plus tooling pass: Slither + Foundry invariant fuzzing, ~6-8 hours
# plus report writing + fix verification round, ~10-12 hours

That lands you around 45-50 total engineer-hours, which at a blended senior rate puts the quote in the $22,000-$28,000 range — squarely in the medium EVM tier above.

Manual Review vs. Tooling — Why Both Cost Money

Static analyzers (Slither, Semgrep rulesets, Mythril) catch the boring stuff fast: reentrancy patterns, unchecked returns, obvious integer issues. They're cheap to run, and a reviewer who skips them is wasting your money on manual grep-work. But tooling has a near-zero hit rate on business-logic bugs — the incorrect reward-rate formula, the liquidation threshold that's off by a rounding error, the access-control check that's technically present but checks the wrong role. That's where the manual hours go, and it's also where the real losses happen. If you want a concrete list of what should be in scope either way, we've laid it out in detail in what a smart contract audit actually checks.

What Pushes a Quote Down

• Clean, commented code with an existing test suite (auditors don't have to reverse-engineer intent)
• A written spec or threat model handed over before kickoff
• Using well-audited base contracts (OpenZeppelin, Anchor's standard patterns) instead of custom re-implementations
• Freezing scope before the audit starts — scope creep mid-review is the number-one cause of blown budgets

A thorough code review pass before the formal audit is one of the cheaper ways to cut the final bill — fixing obvious issues yourself means the auditor's hours go toward genuinely hard problems instead of low-hanging fruit you already knew about.

Timing Matters as Much as Price

A lot of teams try to save money by skipping the audit or squeezing it into the week before mainnet. That almost never works out cheaper once you count the cost of a post-launch incident. If you're still deciding whether this is even necessary for your launch, it's worth reading through when you actually need an audit before mainnet before you lock your deployment date. And if your architecture is still in flux, loop in your dapp development team early so the contracts you're about to freeze for audit aren't going to change three weeks later anyway.

Get a scoped quote from a team that audits EVM, Solana, and TON contracts daily — talk to TierZero about your smart contract audit.