Launching Linea stack

Recently, my team has been working mainly on the launching the Linea L2 stack. It has been a long way, starting from the investigating the prover code with aim to improve its performance up to launching the whole system.

Here is the docker-compose example that can help any team to launch their own L2. It also contains the brief overview of the parts Linea consists of.

From my side, Linea made a good impression on myself, their approach in using own arithmetization in a couple with own proving protocol (Votex) and Gnark is really novel. I’m proud that my team became one of the open-source contributors to the Linea.

FS security

Here is a short recap from Lita of the recent article about practical attack on the interactive protocols under Fiat-Shamir heuristics.

We’ve been discussing the recent paper —https://t.co/5lAT8xQ0tI — “How to Prove False Statements: Practical Attacks on Fiat-Shamir” by Khovratovich, Rothblum, and Soukhanov, which highlights a diagonalization attack against certain GKR-based proof systems that embed their own…

— Lita (@0xLita) February 3, 2025

ZK-STARK explained [lecture]

Recently I’ve taken part in the ZKDL Camp as a lector where I’ve turned my ZK-STARK paper into the lecture format. Enjoy by link: Introduction into STARKs

Pinocchio/Groth16 cheatsheet

Based on ZKDL Camp

File download:

• Dark
• White

Valida vs RISC0 benchmarks

The following post introduces my results on benchmarking ZKVMs from RISC0 and Valida. Valida caught my eye because of the declarations of the fastest existing ZKVM (but still not fully constrained haha). Here we go with my results:

1. Evaluation of the 46th Fibonacci element:

   • RISC0 9.102s (prove + verify)
   • Valida 1.41s (1.075s prove + 0.266s verify)

2. Evaluating Pedersen commitment with Rust k256 library:

  let private_key = Scalar::from(12345678909876554321u128);
  let amount = Scalar::from(12345u64);
  let g = k256::ProjectivePoint::GENERATOR;
  let h = g.mul(k256::Scalar::from(12345u32));
  let commitment = g.mul(private_key).add(h.mul(amount));

• RISC0 24m18.388s (prove + 0.5s verify)
• Valida 15m31.673s (prove + 0.379s verify)

In conclusion, we can see that Valida is probably faster, but only 9 times for Fibonacci and 1.6 times for k256 library. Also, RISC0 can successfully generate proofs using only 20GB RAM while Valida requires 120GB RAM for k256 benchmark.