Verify STARK Proof

WHAT IT DOES

Verify STARK Proof enables you to cryptographically verify STARK (Scalable Transparent ARgument of Knowledge) zero-knowledge proofs, a post-quantum secure proof system that does not require a trusted setup. STARKs are the foundation of modern scalability solutions including StarkEx, StarkNet, and various zk-rollup implementations. Unlike SNARKs, STARKs are transparent (no trusted setup), quantum-resistant, and scale efficiently to large computations. The tool takes a complete STARK proof (Merkle root, values, and FRI proof paths), verification parameters, public inputs, and a security level preference (128-bit or 256-bit), and performs the full verification algorithm to confirm the proof's validity. If the verification succeeds, the tool returns a valid result, confirming that the proof demonstrates knowledge of inputs satisfying a computation without revealing those inputs. This is essential for applications that require post-quantum security and transparent verification.

HOW TO USE

Connect your wallet using the BGWallet connector (required for context). Select the proof format: "JSON" for structured proof data (recommended) or "Hex" for raw hex-encoded proof components. Choose the security level: 128-bit (standard) or 256-bit (higher security). Enter the STARK proof as a JSON object containing the Merkle root, values, and FRI proof paths. Enter the verification parameters as a JSON object containing the field configuration and number of FRI queries. Enter the public inputs as a JSON array of field elements. Click "Verify Proof" to run the verification. The tool displays the proof format, security level, number of public inputs, and the verification result: a green "Verified" checkmark if the proof is valid and a red "Invalid" X if it fails. The result includes a detailed explanation of the outcome and the verification status.

TECHNICAL MECHANISM

This tool implements STARK proof verification following the STARK protocol with FRI (Fast Reed-Solomon Interactive Oracle Proof). The verification process involves: (1) verifying the Merkle tree commitments to the execution trace polynomials using the provided Merkle roots and paths; (2) verifying the low-degree property of the committed polynomials using the FRI protocol, which includes checking the consistency of the FRI proof paths and verifying the Reed-Solomon proximity test; (3) verifying that the public inputs are correctly encoded in the computation; and (4) checking the AIR constraints against the committed polynomials. The verification uses the specified security level to determine the number of FRI queries and the soundness parameters. The tool performs the verification using the STARK-friendly prime field and hash functions. All computation is performed locally in the browser, with no data sent to external servers. The verification process is transparent and does not require a trusted setup.

WHAT IT CANNOT SEE

This tool cannot verify that the proof corresponds to actual on-chain state or values without additional context—you must ensure the public inputs match the expected on-chain data. It does not support all ZK proof systems (only STARKs). The tool cannot verify proofs without the circuit-specific verification parameters; both the proof and verification parameters are required for verification. It does not support hardware acceleration for verification; all computation is done in software in the browser. The tool cannot verify the correctness of the verification parameters without additional trust assumptions; you must trust the parameter generation. It does not support verification of proofs generated with non-standard field configurations beyond the STARK-friendly prime field. The tool cannot verify proofs for circuits with mutable or dynamic parameters; the verification parameters must match the circuit. It does not support proof aggregation or recursive verification; it only verifies a single proof. The tool cannot recover the original inputs from the proof; zero-knowledge proofs reveal only what they are designed to reveal. It does not support all STARK variants or customized AIR constraints beyond the standard STARK implementation.

PLEASE NOTE

This tool is designed for developers and users working with STARK proofs, which are increasingly adopted in blockchain scalability solutions due to their transparency and post-quantum security. STARKs do not require a trusted setup, eliminating the need for multi-party computation ceremonies. The verification is transparent and can be performed by anyone with the public verification parameters. The security level determines the verification time and proof size—128-bit is sufficient for most applications, while 256-bit provides future-proof security against quantum attacks. The verification parameters must be generated specifically for the circuit and security level. The tool uses a STARK-friendly field and hash functions optimized for verification. Always verify proofs from trusted sources using a standard STARK verification library before relying on them in production systems. The verification result proves that the prover knew inputs satisfying the circuit, but it does not prove that those inputs correspond to real-world data without additional context. The tool supports standard STARK verification, which is the most widely adopted STARK variant in blockchain applications.