Who Audits Solana and Move? The Non-EVM Audit Gap in 2026

Three audits, one overflow

On 22 May 2025, Cetus, the largest decentralized exchange on the Sui blockchain, was drained of roughly $223 million in a matter of minutes. The bug that did it was not exotic. A helper function named checked_shlw, meant to confirm that a number would not overflow when shifted left by one 64-bit word, was written so loosely that it silently truncated the most significant bits of a value inside the protocol’s liquidity math. An attacker opened a position with a trivial deposit, tricked the contract into treating it as worth orders of magnitude more, and borrowed the pools dry. A cited technical breakdown by Dedaub walks through the truncation step by step.

What made Cetus the defining audit story of the cycle was not the mechanism; it was the paperwork. The vulnerable code had passed through three separate security firms. OtterSec and MoveBit had reviewed earlier versions of the automated market maker, and Zellic had signed off in April 2025, roughly a month before the exploit, reporting nothing beyond informational findings, according to post-mortem reporting collected by PANews. Three names that any Sui or Solana founder would be proud to list on a landing page, and the money still walked out through a function all three had seen. Cetus later recovered most of the funds and restarted, but the question it left behind has not gone away.

Most of crypto’s audit reputation was built on Ethereum. The marquee firms, the famous reports, the whole vocabulary of severity and remediation grew up around Solidity and the Ethereum Virtual Machine. But the code that breaks now increasingly does not run on the EVM at all. It runs on Rust, on Solana and the chains that borrowed its design, and on Move, the language behind Sui and Aptos. Those environments have their own bug classes, their own tooling, and a far shallower pool of people who can read them well. This is a review of the firms that work there, and of the gap that Cetus turned into a headline.

Why auditing non-EVM is a different job

On Ethereum, a smart contract holds its own storage and calls out to other contracts, and the archetypal disaster is reentrancy: a contract calls an untrusted address that calls back in before the first call has finished settling its books. Solana works nothing like that. Programs are largely stateless; the data they touch lives in separate accounts that the caller passes in with every instruction. The archetypal Solana bug is not reentrancy but account confusion: failing to check that an account is really the one it claims to be, that its owner is the expected program, or that a supposed signer actually signed. The Anchor framework adds guardrails, but developers still get owner checks, signer checks, and program-derived-address logic wrong.

Robert Chen, who runs the Solana-heavy audit shop OtterSec, argues the model itself helps. Speaking to SolanaFloor, he said that “programs on Solana are fundamentally more secure because of the programming model,” pointing out that “there’s no re-entrancy on Solana, which mitigates a pretty large attack surface.” He is careful to temper it: Solana had its own rough stretch of exploits in 2022 and 2023, and economic attacks do not care what virtual machine they run on. It is an honest version of the case, from someone with every reason to make the opposite one.

Rust’s reputation for safety can even work against a review. Because the language eliminates the memory-corruption bugs that plague C and C++, teams sometimes treat Rust code as safe by default, when the exploitable mistakes on Solana are almost always logic: an account never checked for its owner, an integer that overflows in a release build where overflow checks are off, a cross-program call that trusts a program it should not. Those are invisible to the compiler and only as visible to an auditor as the scope and the hours allow. The skills transfer poorly from Solidity, which is why the firms that do this well tend to be Rust-first rather than EVM shops with a Solana practice bolted on.

Move pushes in the other direction. It was designed at Facebook’s Libra and Diem project to make digital assets first-class citizens of the language. Its resources are linear types: they cannot be copied or silently discarded, only moved, so whole categories of double-spend and accidental-duplication bugs are ruled out by the type system, and an on-chain bytecode verifier re-checks every module before it runs. Move, in other words, was built to be proven correct, which is exactly why Cetus stings. The fatal overflow did not live in the elegant, verifiable core; it lived in a numeric helper that the proofs never reached.

The chains, the languages, and where they break

Non-EVM is not one place. Solana compiles Rust down to its own bytecode and runs it on a parallel execution engine; Sui and Aptos both use Move but model the world differently (Sui is object-centric, Aptos account-centric); Stellar’s Soroban and much of Cosmos run Rust through WebAssembly or CosmWasm; Starknet uses its own language, Cairo. Each shift changes which mistakes are easy to make and which tools exist to catch them. Even in a soft market these are not fringe ecosystems: Solana traded around $97 and Bitcoin near $75,700 in mid-September 2026, with the total crypto market capitalization around $2.66 trillion, according to CoinGecko, while SUI and APT changed hands far below their cycle peaks (SUI near $0.70, APT around $0.50) after steep drawdowns, per Coinpedia’s September market read.

For an auditor, each of those shifts is a different specialty, not a dialect. The account model changes what a finding even looks like; the Move type system rules out bugs that dominate Solidity while opening others; a fuzzer written for Ethereum bytecode is useless against sBPF. That is why the roster of firms doing serious non-EVM work is short, and why a Solana or Sui founder cannot simply hire the most famous name in Ethereum auditing and assume the expertise carries over.

Who actually audits the chains that aren’t Ethereum

A distinct tier of firms grew up to work off the EVM. Some are Solana-native and have since expanded; some are Move specialists; a few of the big multi-chain houses staffed up in Rust and Move to keep pace. The table below is not a ranking, it is a map of who does this work and what each is known for.

OtterSec is the firm most associated with Solana security. Co-founded in February 2022 and led by chief executive Robert Chen, a Carnegie Mellon graduate, it has audited Solana’s core code and Account Compression, worked on Aptos internals, and, by its own accounting on Solana Compass, secured more than $36 billion in on-chain value and patched over $1 billion of vulnerabilities across 120-plus projects, with a client list that runs from the Solana Foundation and Circle to Tether, LayerZero, Kamino, and Jito. Its founder is also one of the more thoughtful public voices on why the chain behaves the way it does.

OtterSec is also bound up in the Cetus story in an awkward way. It had reviewed an earlier version of the code, and post-mortem analyses note that one of its reports flagged an adjacent numeric cast as a suggestion rather than a critical finding. Then, when Sui’s validators voted to return the frozen loot, the multisig wallet that received it was controlled by Cetus, the Sui Foundation, and OtterSec. The firm that had signed off on the code held one of the keys to the money’s return. That is not an accusation; it is a snapshot of how small and interwoven the non-EVM security world still is.

Zellic: CTF pedigree and the Code4rena bet

Zellic was founded in 2020 by Stephen Tong, Jasraj Bedi, and Luna Tong, veterans of perfect blue, the competitive-hacking team ranked number one in the world in 2020, 2021, and 2023. That offensive-security DNA is the pitch: the people reading your Rust or Move learned to break software in capture-the-flag competitions, not in a compliance seminar. In August 2024 the firm made its first acquisition, buying the Paradigm-backed competitive-audit platform Code4rena, where crowds of independent researchers called wardens compete to find bugs for a share of a prize pool; Paradigm’s samczsun called Zellic “one of the top auditing firms in the world” in the announcement, and Zellic framed the deal as a way to pair a fixed-fee audit with a public competition.

The bet did not survive the cycle. In May 2026 Code4rena wound down, and Immunefi absorbed its clients and wardens, leaving Zellic with the brand and the pedigree but without the crowd it had bought. For non-EVM founders, Zellic’s appeal is its Rust and Move depth and its habit of publishing detailed research. It is also, awkwardly, the firm whose April 2025 review of Cetus, the last before the hack, returned only informational findings. None of that makes Zellic a weak shop; it makes the point that even a very good firm is only ever certifying the exact code, in the exact configuration, that sat in front of it.

Neodyme and Sec3: breaking Solana before the market does

Some of the best Solana security work looks less like a Solidity audit and more like offensive research. Neodyme, a firm with roots in the European capture-the-flag scene, made its name in December 2021 by disclosing a rounding bug in the Solana Program Library’s Token Lending program that, at the time, put roughly $2.6 billion at risk across every protocol built on it. The flaw let an attacker borrow a small amount and withdraw a slightly larger, rounded-up amount, over and over, until the pools were empty. Over about eighteen months on Solana’s core, Neodyme reported more than eighty bugs, including one in durable nonces, the offline-signing feature that would resurface years later in the Drift attack, as its project profile records.

Sec3, formerly Soteria, took the opposite tack: automate as much of Solana review as possible. Founded in 2021 by formal-methods researchers, it built X-Ray, a scanner purpose-made for Solana that flags more than fifty classes of vulnerability across both raw Rust and Anchor programs and plugs into a project’s continuous-integration pipeline, described on the firm’s own blog. Its clients include the Solana Foundation, Jupiter, Wormhole, Raydium, Orca, and Metaplex, and its pitch is coverage before, during, and after launch rather than a single point-in-time report. Between Neodyme’s manual research and Sec3’s automation, Solana’s security stack looks less like Ethereum’s and more like a mix of red-team disclosure and always-on scanning.

The Move camp: a language built to be proven

Move’s specialist is MoveBit, a brand under the security group BitsLab (which also runs the EVM-focused ScaleBit and the TON-focused TonBit). MoveBit markets itself as the first firm to bring formal verification to the Move ecosystem, and the claim has substance: it wrote formal specifications for large parts of the Aptos Framework that were then discharged by the Move Prover, work it documents on its own blog. It also ships the Move Analyzer tooling for developers and, like everyone in 2026, an AI-assisted scanner.

The Move Prover is the reason Move is interesting to auditors. As CertiK’s primer explains, developers annotate their Move code with a specification (preconditions, postconditions, invariants) and the Prover mathematically checks that no input can violate it, discharging the conditions through SMT solvers. When a property is specified, the guarantee is absolute in a way testing can never match. The catch is the same one that surfaced at Cetus and that the arithmetic buried in an automated market maker’s curve makes vivid: a proof only covers what you write down. When the specification stops at the edge of a numeric library, the guarantee stops with it.

Anatomy of the Cetus miss

Line up the three reviews and the failure looks less like negligence and more like the physics of scope. According to Cyfrin’s root-cause analysis and the PANews reporting cited above, MoveBit’s earlier audit listed value overflows among the things it checked and still did not catch this specific pattern; OtterSec’s review flagged an adjacent risk, a cast between integer widths in a related function, but classified it as a suggestion rather than a critical issue; and Zellic’s April 2025 review, the most recent before the exploit, returned only informational findings. The numeric library that actually did the arithmetic appears to have sat outside the audited scope, and Sui’s native support for 256-bit integers (which Aptos lacks) made the specific truncation easy to overlook.

That pattern is exactly what CertiK’s data shows spreading. In its Hack3d report for the first half of 2026, code vulnerabilities were the most common attack category, 204 incidents for about $152 million, and a growing share of the targeted contracts were more than a year old, with monthly incidents in that cohort climbing from seven in October 2025 to eighteen in May 2026. Attackers are patiently re-reading code that passed its audit and shipped. CertiK co-founder Ronghui Gu put the danger plainly to Forbes: “A project gets audited once before deployment, passes, and then never revisits that code again. The danger window doesn’t close after launch.” Cetus was audited in April and drained in May.

What no audit catches, on any VM

Even a flawless non-EVM audit would not have stopped the two largest Solana losses on record. The first, Wormhole in February 2022, was a genuine Rust bug: the Solana-side bridge used a deprecated function that failed to properly verify the guardians’ signatures, and the attacker slipped in a counterfeit system account to forge an authorization and mint 120,000 wrapped ETH, worth about $326 million at the time, as Halborn’s post-mortem describes. Jump Crypto replaced the funds from its own balance sheet.

The second, Drift in April 2026, involved no code bug at all. Attackers posed as a quantitative trading firm for months, then abused Solana’s durable nonces to get Security Council members to blind-sign dormant transactions that quietly handed over administrative control; a fake collateral token did the rest, and roughly $285 million left, most of it as Jupiter liquidity-provider tokens, in what Chainalysis ties to North Korean operators. It is the second-largest Solana incident ever, and it lives entirely in the human and operational layer that no Rust review inspects. It is a reminder that what a signer actually sees and approves on the screen can matter more than any line of audited code.

The industry-wide numbers say the same thing. In CertiK’s first-half tally, wallet and key compromise was the single costliest category, more than $444 million across just 33 incidents, dwarfing the $152 million from all 204 code-vulnerability cases combined. Suhail Kakar, developer-relations lead at TAC Blockchain, made the blunt version of the point after a different hack, telling Cointelegraph that “audited by X means almost nothing. Code is hard, DeFi is harder.” The table below sets the three defining non-EVM incidents side by side.

When the validators can hit undo

The non-EVM recovery story is where things get genuinely strange, because it cuts against crypto’s own ideology. When Cetus was drained, the attacker bridged about $61 million to Ethereum, where it was gone, but roughly $162 million was still sitting on Sui. A large share of Sui’s validators simply agreed to stop processing transactions from the thief’s addresses, freezing the loot in place, as reported at the time. Days later a community vote, scheduled to run a week but closed after two because support was so lopsided, saw validators representing more than 90 percent of staked SUI approve a protocol upgrade that moved the frozen funds to the recovery multisig, after which users were repaid with help from a $30 million Sui Foundation loan, per CryptoSlate.

On Ethereum or Bitcoin that is close to unthinkable. The validator set is too large and too committed to neutrality to coordinate a freeze, and the last time Ethereum did anything comparable, the DAO fork of 2016, it split the chain in two. On Sui it took two days. The trade is explicit: chains with smaller, more coordinated validator sets can claw money back, which is exactly the censorship the movement was built to resist. It is the same rollback question that followed Cronos when validators halted the chain after the Tectonic exploit, and it runs straight into the economics of who actually runs those validators. For a founder deciding where to deploy, this belongs in the security calculus: not only who audits the chain, but whether the chain can undo a theft, and whether you want to build on one that can.

The bug-bounty and tooling layer

An audit is a snapshot; the defenses that run continuously are bug bounties and automated tooling. Solana’s largest bounty belongs to the lending protocol Kamino, run with Immunefi: up to $1.5 million for a critical finding, set at 10 percent of the funds at risk with a floor of $150,000, dropping to $100,000 for high-severity bugs and a flat $10,000 for mediums, as Coinspeaker reported. Kamino is a money market, the kind of protocol where users borrow against their crypto, and it descends directly from the SPL lending lineage that Neodyme’s $2.6 billion disclosure once threatened. Immunefi says it has paid researchers more than $120 million and watches over $190 billion in user funds, catching, in its telling, critical bugs that audits alone had missed.

Tooling is thinner off the EVM, though it is closing fast. Solidity has a decade of fuzzers and static analyzers behind it; Rust and Move are catching up. Ackee Blockchain’s Trident, backed by the Solana Foundation, brought coverage-guided fuzzing to Anchor and Rust programs, hunting exactly the arithmetic overflows and missing account constraints that manual review can miss. The Move Prover offers real formal verification, but only for the properties a team writes down. And Certora, the best-known formal-verification firm, open-sourced its Prover in February 2025 and extended it beyond the EVM to Solana and Stellar, supporting Rust and Move alongside Solidity. The gap is not that non-EVM tools are bad; it is that they are younger, less battle-tested, and maintained by a smaller community, which is precisely the condition under which a numeric library slips out of scope.

What it costs, and who accredits nobody

Non-EVM work costs more, for a simple reason: fewer people can do it. Sherlock’s 2026 pricing reference and other market breakdowns, including one from QuillAudits, put Solidity audits roughly 20 to 30 percent cheaper than equivalent Rust, Move, or Cairo scopes, with Rust and zero-knowledge work commanding premiums of 30 to as much as 120 percent over comparable EVM engagements. A mid-complexity DeFi protocol might budget $60,000 to $120,000 for a first audit and one remediation review on Ethereum; the same scope in Rust or Move runs higher, and the shortlist of firms qualified to do it well is short. Thin supply is not just a price problem, it is a redundancy problem: when only a handful of firms can read your code, getting three of them, as Cetus did, still leaves you inside one small circle of expertise.

And nobody accredits any of them. There is no Public Company Accounting Oversight Board for Solidity, and certainly none for Rust or Move; no United States regulator licenses smart-contract auditors or sets standards for how a review is conducted. The Securities and Exchange Commission under Chair Paul Atkins spent 2026 on Project Crypto, an effort aimed at whether a token is a commodity or a security, not at code-review quality. So on every chain, EVM or not, the only thing policing audit quality is reputation. Cetus is what happens when three good reputations all point at the same blind spot.

How to vet a non-EVM auditor

If you are shipping on Solana, Sui, Aptos, or anything else off the EVM, a few questions separate a real engagement from a logo on a landing page.

• Chain-native track record. Ask for Rust or Move reports on real programs, not a wall of EVM logos. Reading Solidity well does not mean reading sBPF or Move well.
• Scope discipline. Confirm that dependencies and numeric libraries are in scope, not just your top-level module. Cetus died in a helper the auditors did not fully own.
• Real tooling. Does the firm run Solana- or Move-specific fuzzing (Trident, X-Ray) and, where it fits, formal verification with written specifications, or only manual review?
• Freshness and monitoring. An April audit did not save Cetus in May. Ask about re-review on upgrades and continuous monitoring after launch.
• A live bounty. A standing Immunefi program is the only defense that runs every hour after the report is filed.
• Read the report, not the badge. Look at severity, level of effort, and what was explicitly out of scope, which is usually where the next hack lives.

The non-EVM audit market is younger, pricier, and thinner than the EVM one, and Cetus showed exactly what that combination costs. The firms are real, and several are genuinely excellent. But the word audited carries the same warning on Sui or Solana that it carries on Ethereum, with one difference that should keep founders honest: far fewer people are able to check the work.

Frequently Asked Questions

Which firms audit Solana and Move smart contracts?

The Solana and Rust specialists include OtterSec, Zellic, Neodyme, and Sec3, while MoveBit (part of BitsLab) leads on Move for Sui and Aptos. Several multi-chain houses, including Halborn, Trail of Bits, and the formal-verification firm Certora, also staff Rust and Move teams. There is no official accreditation, so track record on your specific chain matters more than a general reputation.

Why do non-EVM audits cost more than Ethereum audits?

The pool of auditors who can read Rust, Move, or Cairo well is much smaller than the pool for Solidity. Market pricing references for 2026 put Solidity audits roughly 20 to 30 percent cheaper than equivalent non-EVM scopes, with Rust and zero-knowledge work commanding premiums of 30 to as much as 120 percent over comparable Ethereum engagements.

Did three audit firms really miss the Cetus bug?

Yes. OtterSec, MoveBit, and Zellic all reviewed Cetus code, and Zellic’s April 2025 review, roughly a month before the exploit, reported only informational findings. The fatal overflow sat in a numeric library that appears to have been outside the audited scope, and Sui’s native 256-bit integers helped hide the specific truncation.

Are Solana programs more secure than Ethereum contracts?

OtterSec founder Robert Chen argues that Solana’s model removes reentrancy and so closes a large attack surface. But Solana suffered heavy exploits in 2022 and 2023, and the Wormhole and Drift losses show non-EVM chains are far from immune. Economic and operational attacks, like the social engineering behind Drift, ignore the virtual machine entirely.

Can stolen funds be recovered on Solana, Sui, or Aptos?

Sometimes. After the Cetus hack, Sui validators froze about $162 million and a governance vote approved returning it, something possible only because the validator set is small and coordinated enough to act, which Ethereum and Bitcoin reject by design. Funds bridged away first were lost, and recovery remains the exception rather than the rule.

By Anneke de Vries, HOGE Wire security desk.