← All posts
Audit ProcessFork Testing

Core vs Fork: What Fork Testing Finds That a Standard Smart Contract Audit Misses

Security Wiz team3 min read

ShareTelegramX

We offer smart contract audits in two tiers, Core and Fork. They differ less in how hard we look than in how we prove what we find. Think of a car: Core is a mechanic inspecting every part in the garage, and Fork adds a test drive on real roads. Here's what each includes and how to choose.

Core: scan plus manual review

Core combines two things:

  1. An automated scan. Scanning tools, plus rules we've written ourselves, sweep your code for known kinds of weakness. What comes out is a list of leads. A lead is never a finding on its own.
  2. A manual review. We first merge your code and everything it depends on into one continuous document, so a reviewer can follow each action from start to finish. Then, for every action a user or an administrator can take, we work out who is allowed to take it, what it reads and changes, which other contracts it relies on, where money moves, and what it assumes.

A person confirms every lead. On Core, we confirm a finding with a test on our own machines or by following the exact route through the code that causes the problem. That's a real standard of proof, and for many projects it's enough.

Fork: add attacks on the real thing

Fork includes everything in Core and adds testing on a fork of the live network. A fork is a private copy of the blockchain, frozen at one moment, with the real apps, the real money in them, and the real behavior of every token. Nothing we do there reaches the real network. We use test keys, and the fork lets us act as any account without needing its real keys.

On the fork we:

  • Launch your code exactly the way your own scripts do, then check who ends up in control and what the settings are.
  • Run your tests, then our own. We write down the rules your product must never break and have software throw thousands of random actions at it to try to break them.
  • Attempt realistic attacks: borrowing huge sums for a single transaction (flash loans), moving prices in real markets, placing trades just before and after a victim's trade to profit from it, misusing an administrator's key, and tampering with the upgrade process.
  • Test the awkward cases: tokens that charge a fee on every transfer or block certain accounts, a connected app that has been paused, a price feed that has stopped updating.
  • Save every successful attack as a test you can run yourself. It becomes the proof in your report, and the check we run again after your fix.

What fork testing finds that reading the code can't

A reviewer can reason about where your product gets its prices. A fork lets us actually move the price in a real market and watch what your product does. The difference shows up in a few places:

  • Problems between apps, where your code is correct on its own and breaks against how a real app it connects to behaves.
  • Money-driven attacks, where the attack depends on real funds and real prices and wouldn't show up with made-up test values.
  • Setup and launch issues, which only exist once the system is running with its real settings.
  • False alarms. A fork also tells us when a suspected problem can't be used by an attacker, which keeps your report focused on what matters.

How to choose

  • Core fits simpler projects, early-stage code, or teams that need a thorough review on a tighter budget.
  • Fork fits anything that holds meaningful value, relies on other apps or outside price feeds, can be upgraded after launch, has complicated financial rules, or is about to launch with real money in it.

If you're unsure, describe your project and we'll recommend one. Either way, you get findings ranked by severity, a concrete fix for each, and a recheck of your fixes. See the FAQ for more on how the process runs, or request an audit to get a quote within 24 hours.

ShareTelegramX

Shipping something onchain?

Send us your repo and we’ll return a quote within 24 hours.

Request an Audit