Zero-knowledge proofs (ZKPs) have emerged as a promising solution to address the scalability challenges in modern blockchain systems. This study proposes a methodology for generating and verifying ZKPs to ensure the computational integrity of cryptographic hashing, specifically focusing on the SHA-256 algorithm. By leveraging the Plonky2 framework, which implements the PLONK protocol with the FRI commitment scheme, we demonstrate the efficiency and scalability of our approach for both random data and real data blocks from the NEAR blockchain. The experimental results show consistent performance across different data sizes and types, with the time required for proof generation and verification remaining within acceptable limits. The generated circuits and proofs maintain manageable sizes, even for real-world data blocks with a large number of transactions. The proposed methodology contributes to the development of secure and trustworthy blockchain systems, where the integrity of computations can be verified without revealing the underlying data. Further research is needed to assess the applicability of the approach to other cryptographic primitives and to evaluate its performance in more complex real-world scenarios.
The advent of blockchain technology has revolutionized
various industries, offering a decentralized and secure
approach to data management and transactions [
Zero-knowledge Proofs (ZKPs) have gained significant
attention as a potential solution to the scalability problem
in blockchain networks [
The primary objective of this research is to investigate the application of zero-knowledge proofs for ensuring the computational integrity of cryptographic hashing in blockchain systems. We aim to develop and evaluate a methodology for generating and verifying ZKPs using the Plonky2 framework, a state-of-the-art ZKP toolkit. The main tasks of this study include: 1. 2. 3. 4.
Generating ZKPs for cryptographic hashing of random data using Plonky2.
Testing the generated ZKPs to assess their correctness and efficiency.
Applying the developed methodology to real data
blocks from the NEAR blockchain [
Analyzing the performance and scalability of the proposed approach for both random and realworld data.
By addressing these tasks, we seek to contribute to the development of efficient and scalable solutions for ensuring the integrity of computations in blockchain systems, ultimately supporting the broader adoption of this transformative technology.
0000-0003-2331-6326 (O. Kuznetsov); 0009-0004-6380-5233 (A. Yezhov); 0009-0009-9662-9615 (V. Yusiuk); 0000-0002-5605-9293 (K. Kuznetsova) © 2024 Copyright for this paper by its authors. Use permitted under Creative Commons License Attribution 4.0 International (CC BY 4.0).
ZKPs are cryptographic protocols that allow a prover to
convince a verifier of the validity of a statement without
revealing any information beyond the truth of the statement
itself [
Completeness: If the statement is true, an honest prover can convince an honest verifier of its validity.
Soundness: If the statement is false, no cheating prover can convince an honest verifier that it is true, except with a small probability.
Zero-knowledge: The verifier learns nothing beyond the truth of the statement. 1. 2.
Mathematically, a ZKP for a statement x ∈ L can be
represented as an interactive protocol between a prover P
and a verifier V, where L is an NP language. The prover P
aims to convince the verifier V that x ∈ L without revealing
any additional information. The protocol is described as
follows [
1, if x L; (P,V )(x)
0, otherwise, where (P,V)(x) denotes the output of the interaction between P and V on input x.
The construction of ZKPs relies on several
cryptographic primitives and techniques, such as
commitment schemes, challenge-response protocols, and
hash functions [
Commitment: The prover sends a commitment to the verifier, which binds the prover to a specific value without revealing it.
Challenge: The verifier sends a random challenge to the prover.
Response: The prover computes a response based on the commitment, challenge, and private information related to the statement being proved.
The verifier then checks the validity of the response and
accepts or rejects the proof accordingly. The Fiat-Shamir
heuristic [
Cryptographic hash functions play a vital role in
blockchain systems, ensuring the integrity and
immutability of data. However, the computation of hash
functions can be time-consuming, especially for large
datasets. ZKPs can be employed to prove the correctness of
hash computations without revealing the input data,
thereby reducing the computational burden on blockchain
nodes [
In this study, we focus on the application of ZKPs to the
SHA-256 hash function, which is widely used in blockchain
systems. The Plonky2 framework, developed by Polygon
Zero, is utilized to generate and verify ZKPs for SHA-256
computations. Plonky2 is a modern ZKP toolkit that
implements the PLONK protocol [
The PLONK protocol is a universally updatable
structured reference string scheme that enables efficient
proof generation and verification for arbitrary arithmetic
circuits [
By leveraging the capabilities of the Plonky2 framework, we aim to develop an efficient and scalable methodology for generating and verifying ZKPs for SHA256 computations, ultimately contributing to the advancement of privacy-preserving and computationally efficient blockchain systems.
In this section, we present a detailed description of the
methodology employed for generating and testing ZKPs
to ensure the computational integrity of cryptographic
hashing. Our approach consists of three main stages:
generating ZKPs for random data, testing the obtained
proofs, and applying the developed methodology to real
data blocks from the NEAR blockchain [
To generate ZKPs, we utilized the Plonky2 framework developed by Polygon Zero. Plonky2 implements the PLONK protocol in conjunction with FRI as a commitment scheme, providing a robust and efficient verification mechanism. The generation process involved the following steps:
Generating random data of various lengths (10, 100, 1000, 10000 bytes).
Computing the SHA-256 hash function for the generated data.
Creating a ZKP to validate the correctness of the hash computation using Plonky2.
Storing the generated proof and the corresponding circuit for subsequent verification.
The experiments for generating ZKPs were conducted on a server with an AMD Ryzen 9 7950X 16-Core Processor running at 4.7 MHz. For each length of random data (10, 100, 1000, 10000 bytes), we measured the following parameters: The complexity of native verification (computing the hash function and comparing the result with the hash code) in cycles per byte and seconds.
The complexity of circuit generation in cycles per byte and seconds.
The complexity of proof generation in cycles per byte and seconds.
The complexity of proof verification in cycles per byte and seconds. 1. 2. 3. 4.
The size of the generated circuit in gates.
The size of the generated proof in bytes.
To verify the correctness of the generated ZKPs, we employed the following methodology:
Loading the generated proof and the corresponding circuit for each set of random data. Verifying the proof using Plonky2 while measuring the verification complexity in cycles per byte and seconds.
Comparing the hash code obtained from the verification with the original hash code computed for the random data.
To assess the applicability of the developed methodology to real-world data, we utilized blocks from the NEAR blockchain of various heights and with different numbers of transactions:
Block #121,114,606 at height 121,114,606,
containing 52 transactions (5677 bytes) [
Block #121,136,789 at height 121,136,789,
containing 78 transactions (5092 bytes) [
Block #121,117,653 at height 121,117,653,
containing 102 transactions (4897 bytes) [
Block #121,089,333 at height 121,089,333, containing 169 transactions (6262 bytes) [26].
The selected blocks reflect the diversity of real data in the NEAR blockchain and allow us to evaluate the performance of ZKPs generation and verification in various scenarios.
The process of generating and testing ZKPs for the selected NEAR blocks involved the following steps: Obtaining the binary block data from the NEAR blockchain using the provided block hashes.
Generating ZKPs for each block using Plonky2 while measuring the complexity of the circuit and proof generation.
Verifying the generated proofs while measuring the verification complexity.
Comparing the obtained results with the results for random data to assess the applicability and scalability of the proposed approach.
By following this structured methodology, we aim to thoroughly evaluate the efficiency and practicality of generating and verifying ZKPs using Plonky2 for both random data and real data blocks from the NEAR blockchain [27]. The results of these experiments will be presented and discussed in the following section.
In this section, we present and analyze the results obtained from generating and testing ZKPs for both random data and real data blocks from the NEAR blockchain. The experiments were conducted using the methodology described in the previous section, and the results provide valuable insights into the efficiency and scalability of the proposed approach.
The complexity of native verification, circuit generation, proof generation, and proof verification increases with the length of the random data. However, the increase in complexity is not linear, indicating the scalability of the proposed approach.
The time required for native verification remains negligible (in the order of microseconds) even for larger data lengths, highlighting the efficiency of the native verification process.
The time required for circuit generation and proof generation increases with the data length but remains within acceptable limits (less than 13 seconds for 10000 bytes of data).
The time required for proof verification is significantly lower than that of proof generation, emphasizing the efficiency of the verification process, which is crucial for the practical application of ZKPs.
The sizes of the generated circuits and proofs increase with the data length but remain manageable (less than 250 KB for 10,000 bytes of data), ensuring the feasibility of storing and transmitting the generated proofs.
These results confirm the efficiency and scalability of the proposed approach for generating and verifying ZKPs using the Plonky2 framework for random data of various lengths.
To illustrate the relationship between the complexity of proof verification and the length of random data, we present Fig. 1, which shows the proof verification time as a function of the input data size. As evident from Fig. 1, the proof verification time remains consistently low, even for larger data sizes, with a verification time of approximately 0.0044 seconds for random data of length 10,000 bytes. This observation highlights the efficiency of the verification process and its potential for scalability in real-world applications.
The linear relationship between the verification time and the data length can be attributed to the design of the Plonky2 framework and the underlying cryptographic primitives, such as the PLONK protocol and the FRI commitment scheme. The efficient arithmetic circuit representation and the optimized proof construction in Plonky2 contribute to the fast verification times, even for larger datasets.
To assess the applicability of the developed methodology to real-world scenarios, we generated and tested ZKPs for data blocks from the NEAR blockchain. Table 2 presents the results obtained for the selected blocks, including the block height, the number of transactions, the block size, and the complexity and time required for native verification, circuit generation, proof generation, and proof verification.
The results in Table 2 lead to the following observations: 1.
The complexity of native verification for real data blocks is comparable to that of random data of similar sizes, confirming the consistency of the native verification process. 1,000 1,752
The time required for circuit generation and proof generation for real data blocks is also comparable to that of random data, demonstrating the applicability of the proposed approach to real-world scenarios.
The time required for proof verification remains consistently low (around 0.004 seconds) for all the tested real data blocks, regardless of the number of transactions or block size, highlighting the efficiency of the verification process.
The sizes of the generated circuits and proofs for real data blocks are similar to those of random data, indicating the feasibility of storing and transmitting the proofs in realworld applications.
These results validate the applicability and scalability of the proposed methodology for generating and verifying ZKPs using Plonky2 for real data blocks from the NEAR blockchain.
The consistency in performance between random and real data suggests that the approach can be effectively utilized in practical scenarios, such as ensuring the computational integrity of cryptographic hashing in blockchain applications.
The experimental results presented in this section demonstrate the efficiency and scalability of the proposed approach for generating and verifying ZKPs using the Plonky2 framework. The methodology exhibits consistent performance for both random data and real data blocks from the NEAR blockchain, highlighting its potential for practical applications.
The complexity of native verification, circuit generation, proof generation, and proof verification scales well with increasing data lengths, ensuring the feasibility of applying the approach to larger datasets. The time required for proof verification remains consistently low, even for real data blocks with a large number of transactions, emphasizing the efficiency of the verification process, which is crucial for the practical adoption of ZKPs.
Moreover, the sizes of the generated circuits and proofs remain manageable, even for larger data lengths and real data blocks, indicating the feasibility of storing and transmitting the proofs in real-world scenarios. This is particularly important for blockchain applications, where the storage and transmission of proofs should not introduce significant overhead.
The consistency in performance between random and real data suggests that the proposed methodology can be effectively applied to ensure the computational integrity of cryptographic hashing in various applications, including blockchain systems. The ability to generate and verify ZKPs efficiently and scalably can contribute to the development of more secure and trustworthy systems, where the integrity of computations can be verified without revealing the underlying data.
However, it is important to note that the current study focuses on the specific case of cryptographic hashing using the SHA-256 algorithm. Further research is needed to assess the applicability of the proposed approach to other cryptographic primitives and to evaluate its performance in more complex real-world scenarios.
In conclusion, the experimental results presented in this section provide strong evidence for the efficiency and scalability of the proposed methodology for generating and verifying ZKPs using the Plonky2 framework. The approach demonstrates consistent performance for both random and real data, highlighting its potential for practical applications in ensuring the computational integrity of cryptographic hashing, particularly in the context of blockchain systems.
In this study, we proposed and evaluated a methodology for generating and verifying ZKPs to ensure the computational integrity of cryptographic hashing in blockchain systems. By leveraging the Plonky2 framework, we demonstrated the efficiency and scalability of our approach for both random data and real data blocks from the NEAR blockchain.
The experimental results showed that the proposed methodology achieves consistent performance across different data sizes and types, with the time required for proof generation and verification remaining within acceptable limits. The complexity of native verification, circuit generation, proof generation, and proof verification scales well with increasing data lengths, indicating the feasibility of applying the approach to larger datasets.
Moreover, the sizes of the generated circuits and proofs remain manageable, even for real-world data blocks with a large number of transactions. This is particularly important for blockchain applications, where the storage and transmission of proofs should not introduce significant overhead.
The consistency in performance between random and real data suggests that the proposed methodology can be effectively applied to ensure the computational integrity of cryptographic hashing in various blockchain systems. The ability to generate and verify ZKPs efficiently and scalably contributes to the development of more secure and trustworthy systems, where the integrity of computations can be verified without revealing the underlying data.
Further research is needed to assess the applicability of the proposed approach to other cryptographic primitives and to evaluate its performance in more complex real-world scenarios. Nonetheless, the results presented in this study provide a solid foundation for the development of efficient and scalable solutions for ensuring the integrity of computations in blockchain systems, ultimately supporting the broader adoption of this transformative technology. https://nearblocks.io/blocks/5qD3eZtUrkheHKEG hQw3oarPHsdjiAmWNASeZV9W1r5s [26] Near Block 4oMRqMRD1P6wPtnkPURNpa6s nxUvMFMyDZCv7uSq53FX | Near Blocks. URL: https://nearblocks.io/blocks/4oMRqMRD1P6wPtn kPURNpa6snxUvMFMyDZCv7uSq53FX [27] K. Kuznetsova, et al., Solving Blockchain Scalability Problem Using ZK-SNARK, Advances in Artificial Systems for Logistics Engineering III, Springer Nature Switzerland, Cham (2023) 360– 371. doi: 10.1007/978-3-031-36115-9_33.