Tactus O1: First Based EVM Rollup on CKB

One canonical history. No privileged L2 sequencer.

Following my earlier discussion on based EVM architectures for CKB, I’ve taken this direction forward as an independent project: Tactus O1.

Tactus O1 is an experimental EVM validity rollup designed around CKB’s PoW consensus and Cell model. The central idea is to allow independent builders to propose EVM batches, while CKB determines their canonical succession and eventually verifies the resulting execution through validity proofs.

I’m developing this as a solo research and engineering project for now. The repository already contains working components and reproducible experiments, although the complete rollup and its security guarantees are still under development.

1. The direction

Godwoken established an important precedent for running Ethereum-compatible applications on CKB. With Tactus O1, I’m interested in taking a different approach to sequencing and settlement.

The goal is to combine:

  • Permissionless batch proposals, with CKB rather than a privileged L2 sequencer determining canonical history.
  • Ethereum-compatible execution, built around Reth/revm and familiar Solidity tooling.
  • CKB data availability, so accepted transaction inputs can be independently retrieved and replayed.
  • Validity-enforced settlement, with execution proofs verified on CKB.
  • Independent recovery and exits, without relying indefinitely on the original operator.

The intended architecture is:

flowchart TB
    U["Ethereum wallets and applications"]
    B["Independent batch builders"]
    C["CKB PoW + Cell-based ordering"]
    D["CKB batch-data publication"]
    E["Independent EVM replay"]
    P["ZK validity proving"]
    S["CKB settlement and withdrawals"]

    U --> B
    B --> C
    B --> D
    C --> E
    D --> E
    E -. "Planned" .-> P
    P -. "Planned" .-> S

The important distinction is that builders still determine transaction order within their candidate batches. CKB determines which batch succession becomes canonical.

The proposal therefore removes the need for an exclusive L2 sequencing authority, but it does not automatically eliminate censorship or guarantee fast confirmations.

Those properties need to be established separately.

2. Why O1?

The previous thread explored the broader design space. Here is the short version of where I’ve landed:

Settlement model CKB data availability External data availability
ZK validity O1 — Selected baseline O2 — Future Validium domain
Optimistic O3 — CKB-VM Court research O4 — Parked

I’ve chosen O1: CKB-based sequencing, CKB data availability and ZK validity settlement as the initial development path.

It offers a relatively clear security model: CKB establishes the accepted batch history, the necessary execution data is published on CKB, and validity proofs are intended to secure the resulting state transitions.

External DA may eventually be useful for higher-throughput applications, but it introduces different recovery assumptions. I would rather establish the O1 guarantees first than introduce those assumptions prematurely.

O3 remains an interesting research direction, particularly for CKB-VM-based adjudication, but it is not part of the initial implementation.

3. What exists today?

I’ve been working on the protocol’s basic execution, ordering and recovery boundaries.

The repository now includes:

  • CKB ordering experiments, exercised on isolated CKB devnets with competing transactions and controlled reorganisations.
  • EVM execution and differential tests, comparing a pinned Shanghai-profile revm implementation against Geth on a limited set of workloads.
  • Authenticated batch-data publication, followed by independent EVM state reconstruction from canonical CKB history.
  • Priority-inclusion experiments, testing how CKB Cell dependencies behave under competing and uncooperative builders.

One result has been particularly instructive.

A priority message can be legitimately admitted on CKB, and a challenge against its omission can mature successfully, while a builder continues producing valid batches without processing that message.

flowchart TB
    A["User submits a priority message"]
    B["Message is admitted on CKB"]
    C["Challenge becomes valid"]
    D["Builder continues producing batches"]
    E["Message remains unprocessed"]
    F["Enforceable processing rule"]

    A --> B --> C --> D --> E
    E -. "Still required" .-> F

This illustrates the difference between being allowed to submit a transaction and having an enforceable right to its processing.

It is also why I don’t consider permissionless batch construction alone sufficient evidence of censorship resistance.

The experiments are making progress, but G2 — enforceable forced inclusion — remains open.

4. What comes next?

The immediate objective is to complete one coherent, independently verifiable rollup path:

Ethereum execution → CKB ordering and data publication → validity proof → CKB settlement → independent withdrawal.

There are three main questions I want to resolve:

Enforceable inclusion. Can CKB’s existing Cell and Script primitives require the processing of admitted priority messages without introducing a privileged sequencer or an unacceptable contention bottleneck?

Settlement liveness. How can the protocol ensure that a canonically accepted batch cannot permanently block later settlement because its execution is unprovable?

Independent recovery. Can another operator reconstruct the necessary state and proving inputs, settle valid execution, and support withdrawals after the original operator disappears?

The project has reproducible local evidence for several underlying mechanisms, but not yet for these complete guarantees. End-to-end ZK settlement, production custody and independent exits remain unfinished.

I’m deliberately keeping more elaborate fast-preconfirmation schemes, execution DAGs and external DA outside the initial implementation until the core security path is established.

5 Likes

A follow-up on Tactus O1. The latest experiments exposed two problems I need to address. Generating a ZK proof took roughly 78 minutes on my laptop, while verification on CKB consumed about 3.985 billion cycles, exceeding mainnet’s 3.5 billion limit. The prototype works on a devnet with a higher limit, but is not mainnet-ready. The prover also replays execution history from genesis, so the cost grows as the chain gets longer.

The other concern is settlement lag. CKB can keep accepting EVM transaction batches while their proofs are still pending. That means transaction ordering can move ahead of verified settlement, potentially delaying withdrawals indefinitely if proving cannot keep up. The priority route has a related limitation: it prevents builders from selectively skipping sealed requests while batches continue, but cannot guarantee timely progress when builders or provers stop cooperating.

I’ve been looking at other based rollups such as Taiko and Igra for comparison. Taiko manages outstanding proposals through bounded queues, prover incentives and L1 forced inclusion, although proving delays can still stall progress. Igra takes a different approach, carrying ordinary EVM transactions all through Kaspa L1 without requiring the same ZK settlement pipeline, but with different execution-verification and custody assumptions. For Tactus, I’m investigating incremental proving, cheaper CKB verification and bounded settlement lag. These are still open research questions.

1 Like

CKB verification costs:

The earlier settlement verifier was eating about 3.98 billion CKB cycles. I replayed the same proof, public outputs, and transaction context with the optimized settlement script, and it dropped to roughly 333 million cycles which is a 91.6% reduction.

The big wins came from more efficient elliptic-curve and finite-field arithmetic, plus compiler optimizations. The verification equation and checks are unchanged.

That comparison is for the settlement script group specifically. Separately, I committed two complete proof-receipt transactions on a fresh local devnet with a 3.5-billion-cycle block limit, each coming in at about 334 million cycles.

Proof generation:

For the same workload from my original report, proving time dropped from 77m55s to 13m50s​ ,that’s also a steep 82.2% reduction, or roughly 5.6× faster. This includes guest-side optimizations, SP1 crypto patches, and bumping CPU worker threads from 4 to 8 on the same machine.

That said, the verified workload is small. 9 batch/block inputs, 8 of them empty blocks, and 4 transaction inputs in the final block covering both valid and invalid cases.

What’s actually being verified?

The proof covers execution of Tactus’s pinned EVM state-transition program, transaction signature recovery and validation, contract execution, and the resulting state and block commitments. CKB verifies the proof and binds its public outputs to the ordered batch history and settlement state. It does not​ rerun the EVM on-chain.

2 Likes

Tactus 0.02 — making the rollup lifecycle explicit

Tactus 0.01 explored whether an EVM rollup on CKB could work. In 0.02, the focus is making the different parts agree: how transactions enter the system, what order they follow, when their results can be trusted, and what users can do if progress stops.

The most important distinction is between being ordered and being settled. A transaction appearing in the rollup’s history does not, by itself, make its result available for withdrawals.

flowchart LR
    A[Request accepted] --> B[Order recorded on CKB]
    B --> C[Execution checked]
    C -. Next proof milestone .-> D[Proof accepted on CKB]
    D --> E[Result settled]

What changes

Deposits and priority requests now follow explicit queues. Once a batch of work is fixed, later arrivals cannot change what it contains. Publishing progress must respect both queues, rather than advancing one while quietly leaving the other behind.

There are limits on how much work can remain unproven. When those limits are reached, new work pauses. The paths needed to make progress or respond to a stall remain available.

flowchart TD
    A[Unproven work reaches the limit] --> B[Pause further admission or publication]
    B --> C[Settle existing work]
    B --> D[If progress stays stalled, use the recovery path]

Reports now distinguish ordered work, settled results, claims that are ready to submit, and payments already included on CKB. Each on-chain observation shows its own confirmation depth. A provisional promise is not shown as settled, and a chain reorganization can change previously reported status.

The system also has an explicit response to a prolonged stall. After the required waiting period, another participant can freeze the instance. Freezing stops new progress and preserves the boundary used to determine each person’s rights.

flowchart TD
    A[Progress remains stalled] --> B[Waiting period passes]
    B --> C[Any participant can trigger a freeze]
    C --> D[Uncredited deposits can be refunded]
    C --> E[Supported wallet balances use the settled state]

These rights are different. A deposit that has not been credited can be refunded after a freeze. A normal withdrawal must match its recorded request. An emergency wallet claim needs the owner’s authorization and uses the settled balance. The same entitlement cannot be claimed twice. Fees and payment costs come from external funds, rather than reducing the amount the user is owed.

What we checked

Local CKB networks have exercised full queues, competing submissions, a stalled instance, refunds, node outages and a genuine chain reorganization. Recovery follows the replacement chain and discards rights that existed only on the abandoned branch.

Maximum-size publication transactions were accepted by the local CKB node. The proving program also reproduced the expected results for full backlogs, maximum-size inputs, mixed successful and failed transactions, and heavier computation and signature workloads.

These checks establish execution and protocol behavior. A complete new proof, accepted settlement and the resulting asset release remain the next milestone. We do not yet have an end-to-end proving-speed improvement to announce for 0.02.

What remains ahead

Shared cells still create competition between submissions, and admission fairness remains an open problem. General emergency exits for assets held by contracts are also unfinished; the wallet exit path does not cover every DeFi position.

Next comes the complete proof-to-settlement demonstration. Later work will reduce repeated proving work and measure performance on suitable proving hardware. A separate RISC-V contract experiment will explore execution choices without holding up the main protocol work.

Try it

The release includes the protocol implementation, recovery tools, fixed program files and downloadable test evidence. The getting started guide explains how to check the download and run a local development instance.

1 Like