We’re excited to see what the community builds with this!. Check out the code and the documentation: which describes the different components and shows how to run a rollup example end-to-end. 16/16.

The Celestia team provided us with ideas, architectures and example code we’ve built on. To deploy this, teams would need to create a node to orchestrate operations, modifying state transition handling and so on - we’ve provided examples for all of these in the project. 15/16.

It was a pleasure working with Mina and Celestia. The Mina team helped in figuring out details in the niches we got into, since this is the biggest o1js program to date and utilizes precompiles and recursion in unique ways. They were also prompt to fix issues in o1js. 14/16.

Afterwards, we tie it all together to a multi-step process of producing SP1 proofs for consensus and blob inclusion, verifying them in o1js programs and updating the state of Mina zkapps. 13/16.

Groth16 is used by many others - @RiscZero, Circom, @arkworks_rs and more. We provide an end-to-end example of verifying Risc Zero proofs inside o1js in our documentation. This example can be converted to other Groth16 proofs with a change of public input handling. 12/16.

Then, we move one level up to proving systems. We implement two: PLONK (the gnark variant) and Groth16. The gnark variant of PLONK is used by SP1, and as a result, not only Blobstream and blob inclusion proofs can be verified on Mina, but any SP1 program. 11/16.

Additionally, o1js has an extremely ergonomic in-circuit native recursion API. While this is a topic for a new post, it’s worth highlighting that this kind of easy-to-use recursion opens up many possibilities for scalability architectures, games and more. 10/16.

o1js has elegant abstractions and precompiles for foreign field arithmetic, hashes and elliptic curve operations, which we’ve used for extension fields, G1, G2 and Gt groups and proving system operations. These can be reused by a change of parameters for other curves. 9/16.

This was the most challenging part of the project. Implementing pairings in circuits isn’t easy in itself, but splitting it across circuits is harder. That said, some aspects in o1js made our work more productive. 8/16.

We expect this kind of splitting and compression architectures to be needed in more o1js programs with large amounts of constraints, and so we’ve built it generically such that other projects can use it directly. 7/16.

To be precise, we produce proofs for these split circuits in parallel, and then apply Merkle tree recursive proof composition, resulting in a single root proof with a code hash, ensuring this proof corresponds to the compression of all the lead proofs. 6/16.

We then went on to implement the cryptography needed for BN254 pairings in o1js. Being limited to 64k constraints per circuit, we split the pairing computation to dozens of proofs, efficiently pass data between them and compress into a single one to be published. 5/16.

Before the project, @AndrijaNovakov6 and @liameagen published On Proving Pairings (, allowing for highly efficient verification of pairing execution in circuits, applicable everywhere where non-determinism can be utilized. 4/16.

We combine @SuccinctLabs’s SP1 proofs for Celestia’s consensus and blob inclusion in o1js, Mina’s zkapps programming language. To make this practical, we worked hard over the last few months on new architectures and efficiency techniques. 3/16.

Mina zkapps only have a few storage slots on-chain, and its succinct design doesn’t require users to have access to all the previous data used to synchronize and verify the Mina state, leading to potential lack of data availability for zkapps. 2/16.

We’re excited to unveil o1js-blobstream, bringing @CelestiaOrg data availability to @MinaProtocol zkapps!. o1js-blobstream uses consensus proofs so that Mina verifies the latest Celestia state and enables zkapps to demonstrate the data they used was published on Celestia. 1/16.

Check out the code base ⤵️. 4/4.

Built on wgpu-rs, our library integrates seamlessly into Rust-based clients and supports multiple backends, such as Metal and Vulkan. This lays the groundwork to integrate these improvements into Fuel nodes, paving the way for faster and more efficient blockchain networks. (As a.

Our benchmarks show that the GPU implementation beats CPU-based libraries in production past 512 signatures for secp256r1 ECDSA, 8192 signatures for secp256k1 ECDSA, and 2048 signatures for curve25519 EdDSA. 2/4.

Parallel execution for full nodes offers significant performance improvements. Traditionally, a fresh @fuel_network node syncs to the latest block by downloading and serially re-executing all transactions in the chain. By executing these expensive cryptographic opcodes in.