# EPF Week 5 Update I have been granted access to the SP1 and RISC Zero results from Grandine, but some local environment setup challenges and errors have delayed further work. Nevertheless, I have utilized this week to strengthen my architectural foundation and rust skills, and established comprehensive practices that will accelerate the integration once these blockers are resolved. ## Architectural Planning I have conducted comprehensive architectural analysis for integrating zkVMs like OpenVM into the Grandine Ethereum consensus client. I mainly focused on understanding the architectural implications and challenges of embedding proving systems into a production consensus client. I did some detailed research on Grandine's optimized Rust architecture, which uses its parallelized consensus core design for zkVM integration. Due to Grandine's lightweight memory footprint (approx 2.5GB on mainnet) and ability to handle 50,000 Holesky validators on single hardware, I focused on an integration pattern while preserving these performance characteristics. Key integration points include the state root computation pipeline, validator duty scheduling system, and epoch boundary processing where Grandine's optimized parallelization can be extended to include zkVM proving workloads. I have to design comprehensive state serialization mechanisms that uses Grandine's efficient memory management to minimize zkVM integration overhead. The approach builds on Grandine's existing SSZ serialization optimizations and fork-based state management, creating efficient translation layers that convert beacon state objects into zkVM-compatible formats while preserving Grandine's memory efficiency. This integration maintains compatibility with Grandine's existing `libmdbx` based state storage while enabling seamless zkVM access to beacon state data structures. ## Research and Development I researched about OpenVM precompiles in Powdr and they seem to have achieved great benchmark results. Here are some of the benchmark and contraint-level profiling info from the `powdr-openvm` STARK proving system. ```ini total_trace_cells = 8_512_346 (excluding preprocessed) preprocessed_trace_cells = 1_769_474 main_trace_cells = 1_394_618 perm_trace_cells = 7_117_728 quotient_poly_cells = 3_858_416 trace_height_constraint_0 | weighted_sum = 20_606 | threshold = 2_013_265_921 trace_height_constraint_1 | weighted_sum = 57_720 | threshold = 2_013_265_921 trace_height_constraint_2 | weighted_sum = 10_303 | threshold = 2_013_265_921 trace_height_constraint_3 | weighted_sum = 57_756 | threshold = 2_013_265_921 trace_height_constraint_4 | weighted_sum = 800 | threshold = 2_013_265_921 trace_height_constraint_5 | weighted_sum = 288 | threshold = 2_013_265_921 trace_height_constraint_6 | weighted_sum = 41_068 | threshold = 2_013_265_921 trace_height_constraint_7 | weighted_sum = 0 | threshold = 2_013_265_921 trace_height_constraint_8 | weighted_sum = 1_110_397 | threshold = 2_013_265_921 ProgramAir | Rows = 4_096 | Cells = 73_728 | Prep Cols = 0 | Main Cols = [9, 1] | Perm Cols = [8] VmConnectorAir | Rows = 2 | Cells = 34 | Prep Cols = 1 | Main Cols = [5] | Perm Cols = [12] PersistentBoundaryAir<8> | Rows = 32 | Cells = 896 | Prep Cols = 0 | Main Cols = [20] | Perm Cols = [8] MemoryMerkleAir<8> | Rows = 256 | Cells = 11_264 | Prep Cols = 0 | Main Cols = [32] | Perm Cols = [12] AccessAdapterAir<8> | Rows = 32 | Cells = 928 | Prep Cols = 0 | Main Cols = [17] | Perm Cols = [12] RangeTupleCheckerAir<2> | Rows = 524_288 | Cells = 4_718_592 | Prep Cols = 2 | Main Cols = [1] | Perm Cols = [8] Rv32HintStoreAir | Rows = 2 | Cells = 112 | Prep Cols = 0 | Main Cols = [32] | Perm Cols = [24] VmAirWrapper<Rv32RdWriteAdapterAir, Rv32AuipcCoreAir> | Rows = 8 | Cells = 288 | Prep Cols = 0 | Main Cols = [20] | Perm Cols = [16] VmAirWrapper<Rv32JalrAdapterAir, Rv32JalrCoreAir> | Rows = 16 | Cells = 768 | Prep Cols = 0 | Main Cols = [28] | Perm Cols = [20] VmAirWrapper<Rv32CondRdWriteAdapterAir, Rv32JalLuiCoreAir> | Rows = 8 | Cells = 272 | Prep Cols = 0 | Main Cols = [18] | Perm Cols = [16] VmAirWrapper<Rv32BranchAdapterAir, BranchLessThanCoreAir<4, 8> | Rows = 8 | Cells = 416 | Prep Cols = 0 | Main Cols = [32] | Perm Cols = [20] VmAirWrapper<Rv32BranchAdapterAir, BranchEqualCoreAir<4> | Rows = 2_048 | Cells = 86_016 | Prep Cols = 0 | Main Cols = [26] | Perm Cols = [16] VmAirWrapper<Rv32LoadStoreAdapterAir, LoadStoreCoreAir<4> | Rows = 16 | Cells = 1_104 | Prep Cols = 0 | Main Cols = [41] | Perm Cols = [28] VmAirWrapper<Rv32BaseAluAdapterAir, LessThanCoreAir<4, 8> | Rows = 2 | Cells = 122 | Prep Cols = 0 | Main Cols = [37] | Perm Cols = [24] VmAirWrapper<Rv32BaseAluAdapterAir, BaseAluCoreAir<4, 8> | Rows = 8_192 | Cells = 524_288 | Prep Cols = 0 | Main Cols = [36] | Perm Cols = [28] BitwiseOperationLookupAir<8> | Rows = 65_536 | Cells = 655_360 | Prep Cols = 3 | Main Cols = [2] | Perm Cols = [8] PhantomAir | Rows = 1 | Cells = 14 | Prep Cols = 0 | Main Cols = [6] | Perm Cols = [8] Poseidon2PeripheryAir<BabyBearParameters>, 1> | Rows = 256 | Cells = 78_848 | Prep Cols = 0 | Main Cols = [300] | Perm Cols = [8] VariableRangeCheckerAir | Rows = 262_144 | Cells = 2_359_296 | Prep Cols = 2 | Main Cols = [1] | Perm Cols = [8] 2025-07-17T09:55:15.915714Z INFO powdr_openvm: App proof took 1.892972291s 2025-07-17T09:55:15.915720Z INFO powdr_openvm: Public values: [226, 230, 236, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] 2025-07-17T09:55:15.962167Z INFO powdr_openvm: App proof verification done. 2025-07-17T09:55:15.962169Z INFO powdr_openvm: All done. successes: tests::guest_prove_simple ``` The entire time taken to generate the STARK proof for the guest program is less than 2 seconds, which is quite efficient given the huge traces indicative of expensive proof generation and verification. The STARK proof is constructed by encoding program execution as a set of AIR modules, each enforcing constraints over a trace. The largest traces come from `RangeTupleCheckerAir` and `VariableRangeCheckerAir`, which highlights the importance of boundedness in computation. Lookup-based modules like `BitwiseOperationLookupAir` and hashing modules like `Poseidon2PeripheryAir` add cryptographic constraints, and `VmAirWrapper` modules enforce instruction-level behaviour. All constraints seem to stay safely under their validity thresholds, which confirms the sound proof generation. According to me, the crux behind this strong performance lies in the end-to-end optimization of the pipeline in how they are using STARK-friendly fields like BabyBear, RISC-V style guest programs and modular AIR components. ## Goals for the upcoming week 1. OpenVM-Grandine Integration: Implement first iteration of OpenVM integration into Grandine codebase, using architectural planning completed this week 2. Performance Characterization: Establish definitive performance profiles for zkVM integration under various Grandine operational scenarios and validator set configurations 3. Production Readiness Assessment: Validate integrated system architecture against real-world Grandine deployment requirements, identifying any remaining challenges ## Resources - [precompiles](https://www.youtube.com/live/daiMhkt0XTw?si=oi-kORNAvmAgGbTV) - [powdr](https://github.com/powdr-labs/powdr) ## Conclusion Although a major part got delayed due to setup issues, I still utilized this productively and established comprehensive practices, enhance architectural quality, and tested out OpenVM precompiles by Powdr. I have strengthened my foundation which positions the project for accelerated progress once these issues are fixed, with confidence in system reliability and scalability for mainnet deployment scenarios.