Fantom: A Scalable Framework for Asynchronous Distributed Systems

Authors Ahn, Sang-Min; Kwon, Hyeonmin; Park, Anyang; et al. (Fantom Foundation)
Year 2018
Project Fantom
License MIT
Official Source https://fantom.foundation/papers/

This page is an educational summary and analysis of an official whitepaper or technical paper, written for reference purposes. It is not a verbatim reproduction. CryptoGloss does not claim authorship of the original work. All intellectual property rights remain with the original author(s). The official document is linked above.

“Fantom: A Scalable Framework for Asynchronous Distributed Systems” is the 2018 paper by the Fantom Foundation (with primary academic contributions from Sang-min Ahn and collaborators) introducing Lachesis — an asynchronous Byzantine Fault Tolerant (aBFT) consensus protocol based on a Directed Acyclic Graph (DAG) of events. Fantom’s aBFT design targets fast finality (~1 second) without a designated leader and with theoretical tolerance for asynchronous networks (no assumption of bounded message delays).

The Fantom Opera network (built on Lachesis) launched mainnet in December 2019 and became a major EVM-compatible DeFi hub, peaking in 2021–2022 with notable protocols including André Cronje’s Solidly DEX.

> Papers: Available at fantom.foundation/papers.


Publication and Context

BFT consensus protocols (PBFT, HotStuff) require a synchronous or partially synchronous network — they assume messages eventually arrive within a finite (though potentially unknown) delay bound. Under fully asynchronous conditions (where messages can be arbitrarily delayed), the FLP impossibility theorem proves no deterministic protocol can guarantee both safety and liveness.

Lachesis claims to be aBFT — achieving safety under fully asynchronous networks and liveness under partial synchrony. The DAG-based structure avoids the single-leader dependency of view-based BFT protocols, which are vulnerable to leader failures and denial-of-service.


Lachesis Protocol: DAG of Events

In Lachesis, validators do not produce blocks in the traditional sense. Instead, each validator continuously produces event blocks that reference:

  • Its own most recent event block (self-parent)
  • A recent event block from at least one other validator (other-parent)

This creates a DAG where each event block is linked to multiple prior events. The DAG implicitly encodes a causal ordering of events.

Graph structure:

V1: E1 --> E4 --> E7
         /       /
V2: E2 --> E5 --> E8
              /
V3: E3 --> E6

(Each event references its parent and at least one event from another validator)


Root and Frame Structure

Lachesis identifies special event blocks called roots — event blocks that are “strongly seen” by a supermajority of validators:

Strongly seen (2/3+ rule): An event Y “strongly sees” an older event X if Y is connected to X via paths through events of 2/3+ distinct validators. This DAG-reachability condition is the aBFT equivalent of the 2/3+ quorum in traditional BFT.

Frames: The protocol groups roots into numbered frames. Once a root accumulates 2/3+ supporting roots in its frame, it becomes a confirmed root — all events below it in the DAG are finalized in the Lachesis total order.

The total ordering of events is deterministic given the DAG structure — all honest validators who observe the same DAG arrive at the same transaction order independently.


aBFT Safety and Liveness Claims

Property Lachesis Claim
Safety Holds under full asynchrony (f < n/3 Byzantine)
Liveness Holds under partial synchrony
Finality time ~1–2 seconds on Opera mainnet
Leader required No — leaderless DAG ordering
Message complexity O(n²) gossip per event

The aBFT safety claim means that even if network partitions delay messages arbitrarily, finalized transactions cannot be reversed. Liveness requires eventual message delivery.


Fantom Opera: EVM Compatibility

Fantom Opera uses Lachesis for consensus but added an EVM-compatible execution layer — standard Solidity contracts deploy and run on Opera without modification. This allowed the entire Ethereum DeFi toolstack (Hardhat, MetaMask, Ethers.js) to be used natively.

Each Opera node:

  1. Receives transactions from users
  2. Creates event blocks via Lachesis gossip
  3. Once events are finalized by Lachesis, the EVM executes them in the determined order
  4. State root is committed to the DAG

Gas on Opera: Fees are paid in FTM (the native token); gas mechanics are Ethereum-compatible.


André Cronje and the DeFi Era

In 2021–2022, Fantom became a major DeFi chain, partly because of André Cronje (creator of Yearn Finance) deploying experimental DeFi protocols on Opera. At peak, Fantom had >$12B TVL (total value locked). The 2022 DeFi contraction and Cronje’s brief departure from the space caused TVL to collapse to <$500M.


Reality Check

Lachesis’s aBFT properties are formally sound, and Fantom Opera’s 1-second finality in practice is real. However:

  • DAG throughput vs. claims: Like most DAG-based systems, the real-world TPS ceiling is lower than theoretical maximums due to state access patterns and EVM execution bottlenecks — not the consensus mechanism alone.
  • Protocol simplification: Fantom’s Sonic upgrade (2024) restructured the underlying architecture significantly from the original Lachesis whitepaper, improving performance but making the original whitepaper’s description partially outdated.
  • Single-chain DeFi limits: Despite EVM compatibility, Fantom’s ecosystem is smaller than Ethereum L2s; after the 2022 TVL collapse, recovery has been partial.
  • Centralization: Fantom’s Foundation has significant influence over protocol development and key parameter decisions.

Legacy

Lachesis’s leaderless DAG-based aBFT approach influenced the design of IOTA 2.0 (Tangle 2.0), Hedera Hashgraph (similar DAG-based virtual voting), and academic work on DAG-BFT protocols that led to Narwhal and Bullshark (used in Sui). The framework demonstrates that DAG consensus can be EVM-compatible and practically fast.


Related Terms


Research

  • Ahn, S., et al. (2018). Fantom: A Scalable Framework for Asynchronous Distributed Systems. Fantom Foundation.

— Primary paper. Section 4 defines the Lachesis protocol; Section 5 proves safety under asynchrony.

  • Fischer, M.J., Lynch, N.A., & Paterson, M.S. (1985). Impossibility of Distributed Consensus with One Faulty Process. J. ACM 32(2).

— The FLP impossibility theorem that motivates aBFT protocol design.

  • Danezis, G., Kokoris-Kogias, L., Sonnino, A., & Spiegelman, A. (2022). Narwhal and Tusk: A DAG-based Mempool and Efficient BFT Consensus. EuroSys 2022.

— Later DAG-BFT protocol with formal proofs; directly influenced by DAG consensus designs like Lachesis.