Validium Docs
  • Overview
  • Connect to Validium
  • Start Coding 🚀
    • Quickstart
      • Overview
      • Deploy using Validium CLI
      • Deploy using Quickstart Repository
      • Deploy your first contract
      • Create an ERC20 token
  • Tooling
    • Block Explorers
    • Hardhat-Validium
      • Overview
      • Installation
      • Guides
        • Getting started
        • Migrating Hardhat project to Validium
        • Compiling non-inlinable libraries
      • Plugins
        • hardhat-zksync
        • hardhat-zksync-solc
        • hardhat-zksync-vyper
        • hardhat-zksync-deploy
        • hardhat-zksync-upgradable
        • hardhat-zksync-verify
        • hardhat-zksync-verify-vyper
        • hardhat-zksync-ethers
        • hardhat-zksync-node
        • Hardhat Community Plugins
    • Foundary
      • Overview
      • Installation
      • Getting Started
      • Migration Guide
        • Overview
        • Compilation
        • Deployment
        • Testing
  • Test and Debug
    • Getting Started
    • Docker L1 - L2 Nodes
    • In-Memory Node
    • Continuous Integration
    • Hardhat
    • Foundry
  • API Reference
    • Overview
    • Conventions
    • ZKs JSON-RPC API
    • Debug JSON-RPC API
    • Ethereum JSON-RPC API
    • PubSub JSON-RPC API
  • Concepts
    • Transaction Lifecycle
    • Blocks and Batches
    • Validium Network Fee Mechanism
    • Finality
    • System Upgrades
    • ZK Chains
    • Data Availability
      • Overview
      • Recreating L2 state from L1 pubdata
      • Validiums
    • Account Abstraction
    • L1 <-> L2 Communication
  • Components
    • Overview
    • Smart & System Contracts
      • Smart Contracts
      • System Contracts
    • Shared Bridges
    • Sequencer / Server
    • Validium Network EVM
      • Overview
      • Bootloader
      • Precompiles
      • Virtual Machine Specification
        • ZKsync Virtual Machine primer
        • VM Formal Specification
    • Prover
      • Overview
      • ZK Terminology
      • Running the Prover
      • Circuits
        • Overview
        • Circuit Testing
        • CodeDecommitter
        • DemuxLogQueue
        • ECRecover
        • KeccakRoundFunction
        • L1MessagesHasher
        • LogSorter
        • Main VM
        • RAMPermutation
        • Sha256RoundFunction
        • StorageApplication
        • Sorting and Deduplicating
          • Overview
          • SortDecommitments
          • StorageSorter
          • LogSorter
      • Boojum Gadgets
      • Boojum Function - `check_if_satisfied`
    • Compiler
      • Compiler Toolchain Overview
        • Compiler Toolchain Overview
        • Solidity Compiler
        • Vyper Compiler
        • LLVM Framework
      • Specification
        • Overview
        • Code Separation
        • System Contracts
        • Exception Handling
        • EVM Legacy Assembly Translator
        • Instructions
          • Instruction Reference
          • EVM
            • Native EVM Instructions
            • Arithmetic
            • Bitwise
            • Block
            • Call
            • Create
            • Environment
            • Logging
            • Logical
            • Memory
            • Return
            • Sha3
            • Stack
          • Extensions
            • Overview
            • Validium Network Extension Simulation (call)
            • Validium Network Extension Simulation (verbatim)
          • EVM Legacy Assembly
          • Yul
        • EraVM Binary Layout
    • Fee Withdrawer
    • Portal - Wallet + Bridge
    • Block Explorer
    • Transaction filtering
Powered by GitBook
On this page
  • How Validium Network Utilizes ZK Proofs
  • The Proving Process
  • Understanding Circuits in Validium Network
  • What Validium Network's Circuits Prove
  • Additional Resources
  1. Components
  2. Prover

Overview

Exploring the prover in Validium Network, a ZK rollup technology, which ensures secure and efficient transaction verification through cryptographic proofs.


Validium Network utilizes Zero-Knowledge (ZK) proofs to ensure secure and efficient transaction processing on the Ethereum blockchain. This technology compresses transactions, significantly reducing fees for users while maintaining the robust security standards of Ethereum.

How Validium Network Utilizes ZK Proofs

Zero-Knowledge proofs enable a verifier to confirm that a prover has correctly executed a computation without revealing the specifics of the transaction. This approach ensures both privacy and data security. In Validium Network, the prover is responsible for demonstrating the correct execution of Validium Network's Ethereum Virtual Machine (EVM), and this proof is then verified by a smart contract on Ethereum.

The Proving Process

The proving process in Validium Network involves several crucial steps:

  1. Witness Generation: This is the initial phase where, upon transaction initiation by a user, a witness is generated. This witness acts as proof of the transaction's validity according to the network's consensus rules, without disclosing any transaction details. Witnesses for new transactions are collected in batches and processed together.

  2. Circuits: To generate accurate proofs, standard code logic must be converted into a format interpretable by the proof system. This conversion involves organizing code into various circuits within a virtual machine, ensuring that every aspect of the code execution can be proven.

  3. Proof System: The ZK circuit requires a robust proof system for processing. In Validium Network, this system is called Boojum. It comprises several components:

    • Boojum: This repository acts as a toolkit containing essential tools for proving and verifying circuit functionality, along with backend components necessary for circuit construction.

    • zkevm_circuits: This repository is where the actual EVM-replicating circuits are built using tools from Boojum.

    • zkevm_test_harness: Serving as the testing ground, this repository contains various tests to ensure the circuits function correctly and includes code essential for running these circuits.

Understanding Circuits in Validium Network

A ZK circuit functions similarly to an arithmetic circuit, where inputs at the bottom pass through various computational steps, resulting in a final output at the top. The prover's job is to demonstrate that each step of the circuit is computed correctly, satisfying the circuit with the correct outputs.

It's crucial that each circuit step is fully constrained to prevent any incorrect computations by a malicious prover. In Zero-Knowledge terminology, an underconstrained circuit may result in a soundness error, allowing invalid proofs to pass verification.

What Validium Network's Circuits Prove

The primary purpose of Validium Network's circuits is to ensure the correct execution of the VM, covering every opcode, storage interaction, and the integration of precompiled contracts. These elements are crucial for the holistic functioning and security of the system.

Additional Resources

Through these sophisticated cryptographic processes, ZKsync's prover efficiently secures and verifies transactions, leveraging the power of ZK proofs to enhance blockchain scalability and security.

PreviousProverNextZK Terminology

Last updated 7 months ago

Arithmetic Circuit Diagram

For those interested in a deeper dive into the technology behind Validium Network's proof system, resources like Vitalik Buterin's blog on and the paper provide extensive information on the arithmetization process. More comprehensive details can also be found in the .

Plonk
Plonky2
Redshift Paper