Wake

Four AI auditing tools. Fourteen protocols. The shape tells the story.

Wake Arena 3.1's blue area contains the other three on every axis.

Where all systems struggle — Burve, Notional — the gap closes.

Where the work matters — Lend, Munchables, Virtuals — the edge is visible and consistent.

What the chart doesn't show: 49 of the 63 found vulnerabilities were confirmed by more than one Wake Arena agent independently.

The shape reflects consensus, not a single model's guess.

Learn more ↓

1/
LLM performance is not uniform across programming languages: it tracks training-data representation, and Solidity sits at the low-resource end.

In 2026, the strongest agent evaluated detects 45.9% of real Solidity vulnerabilities; LLM-written Solidity tests are 2–4.6% correct.

The evidence:

On 94 high-severity findings from Code4rena and Sherlock protocols:

Wake Arena 3.1 caught 63 — 67%.

Nearest competitors, GPT-5.2 xhigh and Zellic v12, caught 41 — 44%.

Public, reproducible, labels taken as-is. Some models may have trained on these codebases — fair caveat.

→ github.com/Ackee-Blockcha…

Bridges fail because testing one chain at a time misses the interaction bugs.

Cross-chain protocols introduce synchronization challenges that single-chain tests cannot replicate.

Different block times.
Event relay timing.
State consistency across networks.

Testing these in isolation creates false confidence.

The contract works on Ethereum.
Works on Polygon.

But fails when they interact.

Wake was designed from day one with multi-chain as a first-class citizen.

Not an afterthought.
Not a plugin.
Built-in.

Spin up multiple blockchain instances in one test suite.

Each maintains independent state, accounts, and configuration.

Fork mainnet on both chains simultaneously.

Test realistic cross-chain scenarios with production token contracts and actual network conditions.

The framework enforces chain-specific account usage.

Can't accidentally deploy an Ethereum contract using a Polygon account.

Can't transfer funds across chains without explicit relaying logic.

This prevents an entire class of testing mistakes while making complex multi-chain scenarios straightforward to express.

Real bridge exploits often emerge from timing assumptions, failed relay attempts, or reorg handling.

Wake lets you simulate these edge cases systematically: chain reorganizations, message ordering issues, and timeout scenarios.

One cross-chain DEX aggregator caught a critical synchronization bug during Wake testing that would have drained user funds during high network congestion.

The bug only manifested when both chains processed transactions simultaneously with specific timing.

Multi-chain protocols are complex.
Testing infrastructure shouldn't make them harder.

With built-in mainnet forking, independent time manipulation per chain, and intuitive Python APIs for cross-chain logic, Wake gives teams the testing foundation that distributed protocols require.

Cross-chain testing should be straightforward, not heroic.

Discover Wake's multi-chain capabilities ↓

Learning to write security tests?

"Awesome Wake Tests" collects real production test suites from Aave, Lido, Axelar + comprehensive reentrancy defense patterns + educational resources (workshops, Ethernaut solutions, benchmarks).

Study how protocols securing billions test their code ↓