NewsFlash Articles Data Fundraising BlockBeats Pro

a16z launches new zero-knowledge proof tools Lasso and Jolt to enhance SNARK performance and development experience.

Read this article in 7 Minutes

Lasso and Jolt address three key issues: performance, developer experience, and auditability.

Source: Felix, PANews

a16z Crypto has launched two SNARK-related technologies: Lasso and Jolt. Lasso is a new lookup parameter that significantly improves the cost of the prover, while Jolt (Just One Lookup Table) is a framework designed specifically for Ethereum Virtual Machine-compatible Rollups, a novel approach to building SNARK VM using Lasso. Lasso and Jolt can significantly accelerate the expansion and construction of applications in Web3, and together represent a new SNARK design approach that can improve the performance of widely deployed toolchains by an order of magnitude or more. In addition, they provide a better and more convenient developer experience, and make auditing easier. Lasso and Jolt address three key issues: performance, developer experience, and auditability.

More efficient performance

Lasso is a new search parameter where the prover promises less and smaller values than previous work. The research team at a16z crypto states that Lasso can significantly improve the overall speed of SNARK provers, with a performance improvement of ten times compared to tools such as Halo2 toolchain, thus helping to develop faster ZK-rollups. It is expected that performance will increase by about 40 times after optimization. Therefore, the team believes that Lasso's prover technology will surpass all existing zero-knowledge SNARK prover technologies adopted by major Ethereum L2 scaling solutions.

Jolt has implemented the "lookup singularity" vision originally proposed by Barry Whitehat of the Ethereum Foundation, aiming to achieve simpler tools and lightweight, lookup-centric circuits. Compared to the existing zkVM, the team expects Jolt to achieve similar or better performance, and more importantly, provide a simplified and accessible developer experience.

More Convenient Developer Experience

Compared to existing methods, Lasso provides a more developer-friendly and auditable path for implementing zkVM.

The previous SNARK design method involved manually optimizing CPU instructions by specifying them as circuits - a low-level and error-prone task that requires specialized knowledge of domain-specific languages. In contrast, developers from different language ecosystems should be able to use Lasso relatively easily.

This is because in Lasso, an instruction is defined by decomposing its sub-table: its "large" lookup table can be composed of some smaller "sub-tables". More importantly, such decomposition can be described concisely in high-level programming languages. For example, an instruction can be implemented in just 50 lines of Rust. In addition, many instructions in different instruction sets are conceptually the same, allowing for a lot of code reuse - for example, WASM, EVM, and RISC-V all specify the same basic arithmetic, bitwise, and comparison operations.

More easily audited

Lasso simplifies the developer experience and makes it easier to audit than previous methods. The auditability of zkVM is particularly valuable, as many SNARKs have already gained significant value on the blockchain. Because Lasso implements instruction logic in Rust and encourages cross-instruction set code reuse, it focuses the areas to be audited on a relatively small and readable codebase.

Currently, in addition to the work required to fully implement Jolt, there are many tasks in progress or waiting for other developers to complete, including:

- Implement/integrate different polynomial commitment schemes, such as Multilinear Variants of KZG (PST, Zeromorph, etc.), Dory, Ligero, Brakedown, and Sona. (Note: the links in the "a" tags should not be translated and should be preserved in the output.)

-Product parameter optimization described in Section 6 of the Quarks paper implementation- More comprehensive benchmark testing and error handling.- Using SNARK for recursive implementation of efficient on-chain proof verification.