---
# System prepended metadata

title: Ethproofs V2 Analysis

---

# Ethproofs V2 Analysis

## Website
### Main Navigation 
>Left-hand margin (top to bottom)

##### Navigation Header
- Ethproofs Logo
- Light / Dark / System Mode toggle
- Search by block search bar

##### Navigation Clusters
###### Home
- Home Dashboard

###### Explore
- zkVMs Dashboard
- Provers Dashboard
- Blocks Dashboard
- Killers Dashboard
- Teams Dashboard

###### Learn
- Learn
- API

###### Contribute
- Build Ethproofs
---
### Home Dashboard (landing page)
- Hero Text: "Building a fully SNARKed Ethereum"

#### KPI Chart 1 (cost)
- Title: cost
- Hero Metric 1: avg (the average cost for all proofs submited via all cluster, adjusts based on selected time scale)
- Hero Metric 2: median (the median cost for all proofs submited via all cluster, adjusts based on selected time scale)
- Line Graph: X-axis: days, Y-axis: cents or fractions of a dollar
- "Options" dropdown: checkbox to include "average" in the line graph, checkbox to include "median" in the line graph
- Timescale: selection buttons to constrain line graph by time scale: 7-days, 30-days, 90-days

#### KPI Chart 2 (latency)
- Title: latency
- Hero Metric 1: avg (the average latency (time taken) to produce all proofs submited via all cluster, adjusts based on selected time scale)
- Hero Metric 2: median (the median latency (time taken) to produce all proofs submited via all cluster, adjusts based on selected time scale)
- Line Graph: X-axis: days, Y-axis: minues and seconds
- "Options" dropdown: checkbox to include "average" in the line graph, checkbox to include "median" in the line graph
- Timescale: selection buttons to constrain line graph by time scale: 7-days, 30-days, 90-days

#### Preview Table 1 (zkVMs)
- This widget shows a preview of the zkVMs Dashboard (see below for details)

#### Preview Table 2 (Clusters)
- This widget shows a preview of the Clusters Dashboard (see below for details)

#### Preview Table 3 (Latest Blocks)
- This widget shows a preview of the Blocks Dashboard (see below for details)


---
### zkVMs Dashboard
- A table of all zkVMs currently being used to prove blocks via clusters
- Each row in the table represents a zkVM and is noted in the following format:
    - `zkVM` by `Team` 
        - the `zkVM` hyperlinks to the zkVM Details page (see below) 
        - the `Team` hyperlinks to the Team Details page (see below)
- Each row in the table has the following columns:
  - Latest Version (w/ tool tip: `The most recent version of this zkVM being used by teams on ethproofs.org`)
  - ISA (w/ tool tip: `instruction set architecture: Defines the instruction set this zkVM implements to generate zero-knowledge proofs for Ethereum transactions. The ISA determines which EVM operations can be efficiently proven and verified on-chain`)
  - Used by (w/ tool tip: `number of active clusters: Number of active clusters that use this zkVM on ethproofs.org`)
  - Current Pizza Infographic preview with a toggle dropdown that reveals a larger version of the infographic (see below for details.)


### Clusters Dashboard
- Table with two tabs:
  - Multi-machine
  - Single machine
- Each tab view of the table has rows for each cluster
- Each row has the following columns:
  - Cluster name
  - xkVM Name
  - Team Name
  - Open Source (yes or no) (w/ tool tip:"Indicates whether the zkVM is open source or not")  
  - Binary Available (yes or no) (w/ tool tip: "Indicates whether the necessary zkVM binary is available for verification. This binary contains the compiled circuit and verification keys essential for validating proofs")  
  - Avg Cost (yes or no) (w/ tool tip:"Is calculated by multiplying the hourly cloud rate for equivalent hardware by the number of instances used, then multiplying by proof generation time (converted from milliseconds to hours by dividing by 3,600,000)" )  
  - Avg Time (yes or no) (w/ tool tip:"Is the average duration of computation time during the proof generation process, self reported by proving teams in milliseconds. Time spent generating proof of execution" )  
  - Dropdown revealing preview of cluster details page:
    - Num GPUs
    - Total GPU RAM
    - Num CPU Cores
    - Total CPU RAM
    - Last updated date
    - Link to Cluster details page

### Blocks Dashboard
- The page is a table with two tabs:
  - Tab 1: Multi-Machine (hardware) Clusters
  - Tab 2: Single Machine (hardware) Clusters
- The table has a row for each `Block` that received a proof from a `Team` using a `Cluster` powered by a `zkVM`.
- The table has the following columns:
  - **Block** indicates Ethereum block height and how long ago the block was produced w/ the tool tip:
      - **API Endpoint Title:** "block"
      - **API Endpoint:** `block number`
      - **API Endpoint Definition:** "`block number` value from execution block header" (block height number)
      - **Calc from API Endpoint Title:** "Time since block published"
      - **Calc from API Endpoint:** `now - timestamp`
      - **Calc from API Endpoint Definition:** "`timestamp` value from execution block header"
  - **Gas Used** status bar showing how much of total gas available in the block was used by the block w/ the tool tip:
      - **API Endpoint Title:** "gas used"
      - **API Endpoint:** `gas used`
      - **API Endpoint Definition:** "`gas used` value from execution block header. Total gas units executed within block. Proportional to the amount of computational effort a block outputs. Less gas = less computationally intense = easier to prove.
      - **Calc from API Endpoint Title:** "Percentage of block gas limit"
      - **Calc from API Endpoint:** `gas_used / gas_limit x 100`
      - **Calc from API Endpoint Definition:** "`gas_used` value from execution block header `gas_limit` value from execution block header"
  - **Cost per Proof** shows the cost of the most efficnent proof produced for the block (lowest cost) and the average cost of all Clusters producing a proof for that block in fractions of a dollar w/ the tool tip:
      - **API Endpoint Title:** "cost per proof"
      - **API Endpoint:** `∑(hourly price per instance * instances per cluster) * proving time / (1000 * 60 * 60)`
      - **API Endpoint Definition:** 
        - hourly price per instance is the per-hour USD rate charged by AWS for one instance of the cluster of hardware most-equivalent to that being used by the prover. 
        - instances per cluster is the number of AWS-equivalent instances of a given type being used within a cluster of hardware responsible for generating a proof. 
        - The above products are summed up to calculate the total hourly cost for the cluster. proving time is duration of computation time during the proof generation process, self reported by proving teams in milliseconds. 
        - Divide by `(1000 * 60 * 60)` to convert milliseconds to hours
  - **Cost per Mgas** shows the cost of the most efficent proof in a per Mgas metric and the average cost for all Clusters producing a proof for that block per Mgas in a fractions of a dollar w/ the tool tip:
      - **API Endpoint Title:** "cost per Mgas"
      - **API Endpoint:** `∑(hourly price per instance * instances per cluster) * proving time / (1000 * 60 * 60) / gas used / 10^6`
      - **API Endpoint Definition:** 
        - hourly price per instance is the per-hour USD rate charged by AWS for one instance of the cluster of hardware most-equivalent to that being used by the prover
        - instances per cluster is the number of AWS-equivalent instances of a given type being used within a cluster of hardware responsible for generating a proof
        - The above products are summed up to calculate the total hourly cost for the cluster
        - proving time is duration of computation time during the proof generation process, self reported by proving teams in milliseconds
        - Divide by `(1000 * 60 * 60)` to convert milliseconds to hours
        - `gas used` value from execution block header
        - Divide by `10^6` to convert gas to megagas (Mgas)
        - Proving costs in USD per million gas units proven
        - Normalized USD cost per gas unit to allow comparison amongst proofs of different sized blocks. More gas consumption in a block means more computation to prove.
  - **Proving Time** indicates the status of the proof generation ("Completed proofs published", "Current proofs in progress", "Queued for proving") along with the number of Clusters submitting proofs for that block and the "fastest total time to proof" w/ the tool tip:
      - **API Endpoint Title:** "proving time"
      - **API Endpoint:** `proving time`
      - **API Endpoint Definition:** 
        - proving time is duration of computation time during the proof generation process, self reported by proving teams in milliseconds
        - Time spent generating proof of execution 
  - **Proof Status** w/ the tool tip:
      - **API Endpoint Title:** "total time to proof (fastest proof shown)"
      - **API Endpoint:** `proof submission time - timestamp`
      - **API Endpoint Definition:** 
        - proof submission time is the timestamp logged by Ethproofs when a completed proof has been submitted
        - `timestamp` value from execution block header
  - Link to Block Details Page (see below) 

### Killers Dashboard
>Prover killers (aka Killers) are adversarially-crafted benchmarks to test zkVMs with worst-case blocks. The goal is to find performance bottlenecks, trigger edge cases, and push zkVMs to their limits.

- The page is a table with two tabs:
  - Tab 1: Multi-Machine (hardware) Clusters
  - Tab 2: Single Machine (hardware) Clusters
- The table has a row for each Cluster
- The table has the following columns:
  - Team Name / Cluster name
  - Time and Cost required to prove Killer 1: `SHA256 slayer` (w/ a tool tip describing the details of this killer block)
  - Time and Cost required to prove Killer 2: `Keccak killer` (w/ a tool tip describing the details of this killer block)
  - Time and Cost required to prove Killer 3: `modexp murderer` (w/ a tool tip describing the details of this killer block)
  - Time and Cost required to prove Killer 4: `ecrecover ripper` (w/ a tool tip describing the details of this killer block)
  - Time and Cost required to prove Killer 5: `pairings punisher` (w/ a tool tip describing the details of this killer block)


### Teams Dashboard
- A list of Teams that are submitting Proofs (proving blocks) to Ethproofs
- Each row in the table is a Team
- The table has the following columns:
  - Team Name
  - Average Proving Time
  - Average Cost Per Proof


### Learn

### API

---
### zkVM Details Page
#### Key Info Header
- zkVM Name field
- Team Name: team name and logo (hyperlinks to Team Details Page)
- Latest Version: vX.X.X
- Release Date: Month Day, Year
- ISA: RISC-V, etc
- Official Repository: link to GitHub

#### Performance Infographic
- The primary infographic looks like a pizza w/ 8 slices
- Each slice is colored red, yellow, or green
- The details for what each slice corresponds to and how the color is determined is listed below

#### Infographic Details (i.e. Pizza Slices)
###### Verification Times
- Horizontal Bar w/ three color areas: Red, Yellow, Green
- Current Time in ms indicated on bar
- Tool Tip:
  - `Time required for a verifier to check the validity of proofs being generated by this zkVM, using a single iPhone 16 core`.
  - Red: ≥ 16ms, Yellow: < 16ms, Green: < 1ms
##### Proof Size
- Horizontal Bar w/ three color areas: Red, Yellow, Green
- Current size in MB indicated on bar
- Tool Tip:
  - `The size of the proof generated by this zkVM, measured in kilobytes (KiB)`.
  - Red: ≥ 512KiB, Yellow: < 512KiB, Green: < 32KiB
##### Protocol Soundness
- Colored Dot (red, yellow, or green) indicating the current state
- Tool Tip:
 - `The level of assurance provided by the zkVM protocol, based on its audit and verification status`.
  - Red: Not fully audited, Yellow: Fully audited, Green: Formally verified
###### Security Target
- Colored Dot (red, yellow, or green) indicating the current state
- Tool Tip:
  - `The security target of the zkVM, measured in bits, represents the level of cryptographic security provided by the system`.
  - Red: < 100 bits, Yellow: ≥ 100 bits, Green: ≥ 100 bits
##### Implementation
- Colored Dot (red, yellow, or green) indicating the current state
- Tool Tip:
  - `The level of assurance provided by the zkVM implementation, based on its audit and verification status`.
  - Red: Not fully audited, Yellow: Fully audited, Green: Formally verified
##### Quantum Security
- Colored Dot (red, yellow, or green) indicating the current state
- Tool Tip:
  - `The quantum security level of the zkVM, indicating its resistance to attacks by quantum computers. Hash-based is post-quantum and indicates ≥ 64 bits of QROM-provable security`.
  - Red: curve-based, Yellow: lattice-based, Green: hash-based
##### EVM STF bytecode
- Colored Dot (red, yellow, or green) indicating the current state
- Tool Tip:
  - `The level of assurance provided by the EVM STF bytecode, based on its audit and verification status`.
  - Red: Not fully audited, Yellow: Fully audited, Green: Formally verified
##### Bounties
- Colored Dot (red, yellow, or green) indicating the current state
- Tool Tip:
  - `The maximum bounty amount offered for critical vulnerabilities in the zkVM, indicating the level of commitment to security`.
  - Red: < $64k for critical bugs, Yellow:  ≥ $64k for critical bugs, Green:  ≥ $1M for critical bugs 

---
### Cluster Details Page
#### Key Info Header
- Cluster Name field
- `Single machine Cluster` or `Multi-machine Cluster` denoted
- Open Source: "Yes" or "No"
- Binary Available: "Yes" or "No"
- Average Cost: shown in fractions of a dollar
- Average Time: shown in minutes and seconds
- `Download the binary here` (links to GH repo where you can download the binary for the zkVM used by the cluster) https://github.com/succinctlabs/sp1/releases
- zkVM: name of zkVM used
- ISA: name of ISA used (w/ tool tip: `instruction set architecture
Defines the instruction set this zkVM implements to generate zero-knowledge proofs for Ethereum transactions. The ISA determines which EVM operations can be efficiently proven and verified on-chain`)
- Proof Type: name of Proof Type used

#### Cluster Hardware Details
- CPU Name
  - Number of CPU cores
  - Total CPU RAM in GB
- GPU Name
  - Number of GPUs
  - Total GPU RAM in GB
- Pricing Info:
  - Number of Machines: count
  - Pricing input: $/hour
#### Pricing Tool Tip
>Populated information from cloud pricing equivalent equipment list
  - Hardware configuration selected
  - Memory: in GB
  - Type: GPU config
  - Region: location of hardware selected for pricing equiv
  - vCPU: number of virtual CPUs
  - Hourly price per insance: in dollars per hour
  - Total hourly price: in dollars per hour

---
### Block Details Page 
#### Key Block Details
- Block height number
- Block hash
- Time stamp dd/mm/yy, hh:mm:ss UTC
- Gas used: in Gwei
- Slot
- Epoch

#### Proof Availability
- Status of proofs
  - Completed proofs published
  - Current proofs in progress
  - Queued for proving
- Multi-Machine Performance
  - fastest proving time (w/ tool tip: "fastest proving time - `proving time` proving time is duration of computation time during the proof generation process, self reported by proving teams in milliseconds. Time spent generating proof of execution. Fastest reported proving time for any of the proofs submitted for this block")
  - average proving time (w/ tool tip: "average proving time`∑(proving time) / number of completed proofs for block` proving time is duration of computation time during the proof generation process, self reported by proving teams in milliseconds.  Time spent generating proof of execution. Average reported proving time for all completed proofs submitted for this block")
  - fastest total time to proof (w/ tool tip: "fastest total time to proof `proof submission time - timestamp` proof submission time is the timestamp logged by Ethproofs when a completed proof has been submitted. `timestamp` value from execution block header. Total time delay between execution block timestamp and completion and publishing of proof. Fastest time to proof for any of the proofs submitted for this block" )
  - avg total time to proof (w/ tool tip: "average total time to proof `∑(proof submission time - timestamp) / number of completed proofs for block` proof submission time is the timestamp logged by Ethproofs when a completed proof has been submitted. `timestamp` value from execution block header. Total time delay between execution block timestamp and completion and publishing of proof. Average time to proof for all of the proofs submitted for this block")
- Single Machine Performance 
    - fastest proving time (w/ tool tip)
  - average proving time (w/ tool tip)
  - fastest total time to proof (w/ tool tip)
  - avg total time to proof (w/ tool tip)
  
#### Proof Costs
- Multi-Machine Performance
  - cheapest cost per proof (w/ tool tip: "cheapest cost per proof `∑(hourly price per instance * instances per cluster) * proving time / (1000 * 60 * 60)` hourly price per instance is the per-hour USD rate charged by AWS for one instance of the cluster of hardware most-equivalent to that being used by the prover. instances per cluster is the number of AWS-equivalent instances of a given type being used within a cluster of hardware responsible for generating a proof. The above products are summed up to calculate the total hourly cost for the cluster. proving time is duration of computation time during the proof generation process, self reported by proving teams in milliseconds. Divide by `(1000 * 60 * 60)` to convert milliseconds to hours. Proving costs in USD to prove execution of entire block")
  - average cost per proof (w/ tool tip: "avg cost per proof `∑(hourly price per instance * instances per cluster) * proving time / (1000 * 60 * 60)` hourly price per instance is the per-hour USD rate charged by AWS for one instance of the cluster of hardware most-equivalent to that being used by the prover. instances per cluster is the number of AWS-equivalent instances of a given type being used within a cluster of hardware responsible for generating a proof. The above products are summed up to calculate the total hourly cost for the cluster. proving time is duration of computation time during the proof generation process, self reported by proving teams in milliseconds. Divide by `(1000 * 60 * 60)` to convert milliseconds to hours. Proving costs in USD to prove execution of entire block")
  - cheapest cost per Mgas (w/ tool tip: "cheapest cost per mgas `∑(hourly price per instance * instances per cluster) * proving time / (1000 * 60 * 60) / gas used / 10^6` hourly price per instance is the per-hour USD rate charged by AWS for one instance of the cluster of hardware most-equivalent to that being used by the prover. instances per cluster is the number of AWS-equivalent instances of a given type being used within a cluster of hardware responsible for generating a proof. The above products are summed up to calculate the total hourly cost for the cluster. proving time is duration of computation time during the proof generation process, self reported by proving teams in milliseconds. Divide by `(1000 * 60 * 60)` to convert milliseconds to hours. `gas used` value from execution block header. Divide by `10^6` to convert gas to megagas (Mgas). Proving costs in USD per million gas units proven. Normalized USD cost per gas unit to allow comparison amongst proofs of different sized blocks. More gas consumption in a block means more computation to prove." )
  - avg cost per Mgas (w/ tool tip: avg cost per mgas `∑(hourly price per instance * instances per cluster) * proving time / (1000 * 60 * 60) / gas used / 10^6` hourly price per instance is the per-hour USD rate charged by AWS for one instance of the cluster of hardware most-equivalent to that being used by the prover. instances per cluster is the number of AWS-equivalent instances of a given type being used within a cluster of hardware responsible for generating a proof. The above products are summed up to calculate the total hourly cost for the cluster. proving time is duration of computation time during the proof generation process, self reported by proving teams in milliseconds. Divide by `(1000 * 60 * 60)` to convert milliseconds to hours. gas used value from execution block header. Divide by `10^6` to convert gas to megagas (Mgas). Proving costs in USD per million gas units proven. Normalized USD cost per gas unit to allow comparison amongst proofs of different sized blocks. More gas consumption in a block means more computation to prove.)
- Single Machine Performance 
  - cheapest cost per proof (w/ tool tip)
  - average cost per proof (w/ tool tip)
  - cheapest cost per Mgas (w/ tool tip)
  - avg cost per Mgas (w/ tool tip)

#### Proofs
- Table with two tabs:
  - Multi-machine
  - Single machine
- Each tab view of the table has rows for each cluster
- A row for each Cluster submitting a proof for that Block - each row has the following columns:
  - Cluster name
  - xkVM Name
  - Team Name
  - Total Time to Proof (w/ tool tip: "total time to proof. `proof submission time - timestamp`. proof submission time is the timestamp logged by Ethproofs when a completed proof has been submitted. `timestamp` value from execution block header")
  - Proving Time (w/ tool tip: "proving time. `proving time`. proving time is duration of computation time during the proof generation process, self reported by proving teams in milliseconds. Time spent generating proof of execution")
  - zkVM Cycles (w/ tool tip: "zkVM cycles. `proving cycles`. proving cycles is self-reported by zkVM Developer. The number of cycles used by Succinct to generate the proof. This number will vary depending on hardware and zkVMs being used by different provers and should not be directly compared to other provers.")
  - Cost per Proof (w/ tool tip: "cost per proof `∑(hourly price per instance * instances per cluster) * proving time / (1000 * 60 * 60)` hourly price per instance is the per-hour USD rate charged by AWS for one instance of the cluster of hardware most-equivalent to that being used by the prover. instances per cluster is the number of AWS-equivalent instances of a given type being used within a cluster of hardware responsible for generating a proof. The above products are summed up to calculate the total hourly cost for the cluster. proving time is duration of computation time during the proof generation process, self reported by proving teams in milliseconds. Divide by (1000 * 60 * 60) to convert milliseconds to hours. Proving costs in USD to prove execution of entire block" )


---
### Killer Details Page
>Does not exist

---
### Team Details Page
- Team Name
- Social Links:
  - website
  - X/Twitter
  - GitHub
- Multi-Machine Performance Details:
  - Proofs: number of proofs submitted view that cluster
  - Avg Cost: the average cost to produce those proofs
  - Avg Time: the average time to produce those proofs 
- Single Machine Performance Details:
  - Proofs: number of proofs submitted view that cluster
  - Avg Cost: the average cost to produce those proofs
  - Avg Time: the average time to produce those proofs 
-Table of all Clusters w/ two tabs:
  - Multi-machine
  - Single machin
- Each tab view of the table has a row for each Cluster
- Each Cluster has the following columns:
  - zkVM: name of zkVM used
  - ISA: name of ISA used (w/ tool tip: `instruction set architecture
Defines the instruction set this zkVM implements to generate zero-knowledge proofs for Ethereum transactions. The ISA determines which EVM operations can be efficiently proven and verified on-chain`)
  - Proof Type: name of Proof Type used
