Aligned builds the tools that turn Ethereum into the world’s financial backend.
Ethereum
Joined January 2024
- Tweets8.8K
- Following38
- Followers83.8K
- Likes6.3K
Lambda VM is an open-source zkVM for RISC-V being built in collaboration with @class_lambda and @3miLabs.
to learn more about it, read the article on its principles: blog.alignedlayer.com/lambda…
every rollup needs a way to prove its transactions executed correctly.
without a zk engine, you're asking people to trust an operator instead.
Lambda VM takes a program, runs it, and produces a mathematical proof that Ethereum can verify.
with it, security stops being an assumption and becomes a guarantee.
interoperability protocol is a part of the stack that lets enterprises and governments launch products on @ethereum
to learn more, read blog.alignedlayer.com/what-i…
i've seen things you people wouldn't believe...
a wallet, a rollup, a bridge, a prover: several vendors, one app that still doesn't ship.
months of integration for a product that launches to nobody.
wallets guarded by seed phrases nobody can remember.
all those integrations, lost in time, like the multiple vendors you no longer need.
Epochs are what we run today. Prove-and-retire is still an experiment, and it's doing a lot better than we expected.
Both designs are in the post below. Lambda VM is built with @class_lambda and @3miLabs.
Post: blog.alignedlayer.com/lambda…
Epochs work, but each one drags along its own fixed tables and FRI, so proof size and verification time grow with the epoch count.
Prove-and-retire pays in compute instead.
Re-running a program is cheap next to proving it; holding everything at once was the real problem.
The second, prove-and-retire, keeps one proof and re-runs the program. The first pass builds each table, commits to it and drops it, keeping the root; once the challenge is drawn, a second pass rebuilds and proves them. The proof that comes out is the monolithic one, verifier included.
The first one is epochs. Within a stretch of cycles only memory depends on what came before.
So we split the run into epochs, prove each by itself, and give each a table of the memory cells it touched, with values coming in and going out, chained to the next epoch.
Nothing is re-executed.
