Skip to content
Crypto.world

Research

Belobog: Move Language Fuzzing Framework For Real-World Smart Contracts

Move is a smart contract language with a strong static type system and "resource-oriented" semantics, used on blockchains such as Sui and Aptos. That type system blocks many classic bugs, but it also…

Belobog: Move Language Fuzzing Framework For Real-World Smart Contracts
arXiv
2512.02918
Published
2025-12-02
Authors
Ziqiao Kong, Wanxu Xia, Zhengwei Li, Yi Lu, Pan Li, Liqun Yang, Yang Liu, Xiapu Luo, Shaohua Li

AI summary

Overview

Research area: Blockchain and smart contract security, specifically dynamic testing (fuzzing) of smart contracts written in the Move language for the Sui and Aptos blockchains.

Technical level: Advanced. The paper assumes familiarity with fuzzing, static type systems, dependency/graph-based program synthesis, and concolic (concrete-plus-symbolic) execution.

Scope (one sentence): The paper presents Belobog, a type-aware fuzzing framework that builds a dependency graph from a Move smart contract's type system to generate and mutate well-typed transactions, augmented by a concolic executor, and evaluates it on 109 real-world Move projects, two major on-chain incidents, and three live audits.

What This Paper Is About

Move is a smart contract language with a strong static type system and "resource-oriented" semantics, used on blockchains such as Sui and Aptos. That type system blocks many classic bugs, but it also blocks existing smart contract fuzzers: they cannot construct transactions that the Move Virtual Machine will accept, so most generated inputs are rejected before reaching meaningful code. The paper's goal is to build a fuzzer that always produces syntactically and semantically valid Move transactions, so that dynamic testing can actually exercise contract logic and surface vulnerabilities that the type system cannot prevent.

Key Contributions

  1. The first fuzzing framework for Move smart contracts (Belobog). It is type-aware by construction: every generated or mutated transaction is guaranteed to be well-typed, addressing object type safety, function type parameters, and object type abilities ("Hot Potato" objects that have neither drop nor store).
  2. A dependency-graph-guided transaction engine. For a target contract, Belobog builds a graph whose nodes are type nodes (default types and Hot Potato types) and function nodes, with edges annotated by type-substitution constraints. Transactions are produced by finding a graph trace in this graph, resolving type parameters to concrete types, and instantiating the trace; mutation extends, inserts into, or shrinks that trace.
  3. A concolic executor built on the MoveVM. It collects path constraints (branch/assertion predicates, arithmetic with overflow ranges, cast range constraints, vector index bounds) and flips branch conditions to produce inputs that reach hard-coded checks that random values would almost never satisfy; it runs with a 500 ms timeout per transaction.
  4. An empirical case for the problem plus a real-world evaluation. The authors measure how common the hard Move features are, and evaluate Belobog on audit data, two notorious exploits, and three ongoing audits, releasing a 17k-line Rust implementation with six built-in oracles and a user-defined oracle interface.

Main Findings

  • Prevalence of hard features: Across all two billion transactions on the Sui blockchain from November 2024 to November 2025, among the top 90% most-used packages, more than 80% contain at least one type parameter or "Hot Potato."
  • Existing fuzzers fail on these features: On a constructed contract, all transactions from ItyFuzz and Sui-Fuzzer had type-mismatch errors and were rejected without execution; after removing all type parameters, Sui-Fuzzer still produced no valid transactions, while ItyFuzz only occasionally succeeded through inefficient random mutation.
  • Bug reachability on audited code (DS1): Belobog detected 100% of critical and 79% of major vulnerabilities that human experts had manually audited, across 37 projects containing 960 smart contracts with 9 Critical, 53 Major, and 47 Medium vulnerabilities.
  • Overall dataset size: Evaluation covered 109 real-world Move smart contract projects in total (the 37-project audited dataset DS1 plus the 72-project, 387-contract MoveScan dataset DS2).
  • Incident reproduction: Belobog reproduced full exploits for both Cetus (reported $200 million loss) and Nemo (reported $2.6 million loss) without any prior knowledge.
  • New bugs in live audits: Applied to three ongoing auditing projects, Belobog found 2 critical, 2 major, and 3 medium new vulnerabilities, all acknowledged by the project developers.
  • Implementation cost: 17k lines of Rust overall, of which 4.1k lines support forking a specific on-chain checkpoint for local on-chain data access, 3.7k lines cover dependency graph construction, graph tracing, and transaction generation/mutation, and 2k lines cover concolic execution; porting coverage instrumentation and instruction tracing between Sui and Aptos required 483 and 638 lines of difference respectively.
  • Coverage, throughput, and ablation results: The provided text truncates before the RQ2 (coverage/throughput) and RQ3 (ablation) results, so those specific numbers are not reported here.

Methodology in Plain English

The authors start from an observation: fuzzing a Move contract is mostly a typing problem. Move states are strongly typed objects; objects can only be created by the module that defines them; generic functions need concrete type arguments; and some objects have no drop/store ability, so they must be consumed by exactly one later call in the same transaction (the "Hot Potato" pattern used for flash loans). Random bytes therefore almost never form a runnable transaction.

Belobog's approach is to encode all of this in a graph built from the contract's source and its dependencies. Type nodes record whether a type is freely usable or a Hot Potato, and function nodes are connected to the input and output types they consume and produce, with annotations saying how type parameters must be substituted for one another. To create a transaction, the fuzzer walks this graph to find a chain of calls that starts from primitive or void inputs and ends with every produced object consumed, picks concrete types for the parameters, and fills primitive values randomly. Mutation reuses the same graph: it can tweak values AFL-style, attach extra calls to unconsumed objects, splice in a new function, or delete a call and repair the trace.

Because random values rarely satisfy checks like assert!(paid == amount + fee), the fuzzer also runs each transaction concretely on the MoveVM while recording the symbolic constraints behind the branches taken, then asks a solver to flip a branch condition and rewrites the primitive inputs accordingly. Execution feedback is standard branch coverage: transactions that hit new coverage become seeds; transactions that violate an oracle are reported. Since smart contracts have no universal bug oracle, Belobog ships six generic oracles (infinite loop, precision loss, unnecessary type conversion, unnecessary bool judgment, SHL overflow, and a new "earning profits" check) and exposes an interface for users to write their own invariants in Move. For the audited dataset, the authors wrote custom oracles derived from the audit findings (averaging 15 lines per vulnerability), reviewed by two additional Move auditors with at least one year of full-time experience to avoid overfitting.

Why This Matters

Impact on research. Belobog shows that when a language's type system is the main obstacle to input generation, the right move is to make the fuzzer type-directed rather than to make the mutator smarter. The dependency-graph-plus-trace formulation, borrowed from signature graphs and API graphs in program synthesis, is a reusable recipe for other strongly typed execution environments, and the paper supplies a concrete measurement of how often the blocking features appear in production code.

Real-world applications:

  • Pre-deployment auditing of Sui and Aptos contracts, where the fuzzer's custom oracles can encode protocol invariants such as "the sender's balance must not increase."
  • Post-incident analysis and exploit reproduction, as demonstrated on Cetus and Nemo, to confirm root causes and verify patches.
  • Continuous integration for DeFi protocols whose packages compose across module and package boundaries, since Belobog builds graphs over multiple contracts at once.
  • Fork-based testing against real on-chain state at a specific checkpoint, which lets teams test against live objects and liquidity rather than synthetic fixtures.

Industry relevance. The Move ecosystem holds substantial value (the paper cites Sui and Aptos together at 6.4 billion market capitalization and 1.5 million daily active users), and the incidents cited caused losses in the hundreds of millions of dollars. A tool that finds 100% of audited critical vulnerabilities and produced seven previously unknown, developer-acknowledged findings in three live audits is directly usable by audit firms and protocol teams.

Future Directions

  • General-purpose oracles. The paper explicitly frames oracle design as orthogonal and unsolved; extending beyond the six built-in checks and per-project custom invariants toward automated invariant inference is the biggest open gap.
  • Severity and triage. Turning oracle violations into ranked, deduplicated findings that auditors can act on quickly remains largely manual.
  • Cross-chain generalization. The authors note that Sui and Aptos codebases have diverged significantly (483 and 638 lines of divergence in coverage instrumentation and instruction tracing); supporting further Move-based chains or new language versions implies ongoing porting work.
  • Scaling concolic reasoning. The 500 ms per-transaction solver budget is a deliberate trade-off; how much more the approach would find with better constraint solving, or how it degrades on large transactions, is left open.

Target Audience

Blockchain security researchers and fuzzing researchers will get the most from the technical core (dependency graphs, graph traces, concolic constraint collection). Move developers and smart contract auditors on Sui and Aptos will benefit from the practical results and the oracle-writing workflow. Graduate students studying language-aware test generation will find the framing of type-system constraints as a fuzzing problem particularly instructive. Readers without a background in fuzzing or static typing should expect a steep curve.

Authors’ abstract

Move is a resource-oriented programming language designed for secure and verifiable smart contract development and has been widely used in managing billions of digital assets in blockchains, such as Sui and Aptos.Move features a strong static type system and explicit resource semantics to enforce safety properties such as the prevention of data races, invalid asset transfers, and entry vulnerabilities. However, smart contracts written in Move may still contain certain…

The full abstract on arXiv
Read the original paper