# PLONK verification · Build with zero-knowledge proofs on Chromia · Learn Chromia > This guide shows how the zkp-demo dapp verifies PLONK (Permutations over Lagrange-bases for Oecumenical Noninteractive arguments of Knowledge) proofs to… Source: https://chromia.com/learn/zero-knowledge-proof/dapp/dapp-verification/ Build with zero-knowledge proofs on ChromiaLesson 13 of 19 1. [01Introduction to the course](https://chromia.com/learn/zero-knowledge-proof/introduction/) 2. [02Zero-knowledge proof](https://chromia.com/learn/zero-knowledge-proof/zero-knowledge-proof/) 3. [03Project setup](https://chromia.com/learn/zero-knowledge-proof/setup/) 4. [04Architecture overview](https://chromia.com/learn/zero-knowledge-proof/architecture-overview/) Module 1: Writing Circom circuits 1. [05Overview](https://chromia.com/learn/zero-knowledge-proof/circom-circuits/) 2. [06Circom circuits: introduction](https://chromia.com/learn/zero-knowledge-proof/circom-circuits/circom-circuits-introduction/) 3. [07Circom files overview](https://chromia.com/learn/zero-knowledge-proof/circom-circuits/circom-circuits-project/) 4. [08Circom circuits: compile](https://chromia.com/learn/zero-knowledge-proof/circom-circuits/circom-circuits-compile/) Module 2 – Dapp 1. [09Overview](https://chromia.com/learn/zero-knowledge-proof/dapp/) 2. [10Dapp: setup and run](https://chromia.com/learn/zero-knowledge-proof/dapp/dapp-setup-run/) 3. [11Dapp overview](https://chromia.com/learn/zero-knowledge-proof/dapp/dapp-overview/) 4. [12Dapp entities](https://chromia.com/learn/zero-knowledge-proof/dapp/dapp-entities/) 5. [13PLONK verification](https://chromia.com/learn/zero-knowledge-proof/dapp/dapp-verification/) 6. [14Dapp operations overview](https://chromia.com/learn/zero-knowledge-proof/dapp/dapp-operations/) 7. [15Dapp queries overview](https://chromia.com/learn/zero-knowledge-proof/dapp/dapp-queries/) Module 3 – Frontend 1. [16Overview](https://chromia.com/learn/zero-knowledge-proof/frontend/) 2. [17Frontend: setup and run](https://chromia.com/learn/zero-knowledge-proof/frontend/frontend-setup-run/) 3. [18Frontend architecture](https://chromia.com/learn/zero-knowledge-proof/frontend/frontend-explore/) 4. [19Frontend: test](https://chromia.com/learn/zero-knowledge-proof/frontend/frontend-test/) [Learn](https://chromia.com/learn/)[Build with zero-knowledge proofs on Chromia](https://chromia.com/learn/zero-knowledge-proof/) 13 / 19Module 2 – DappAdvanced # PLONK verification This guide shows how the zkp-demo dapp verifies PLONK (Permutations over Lagrange-bases for Oecumenical Noninteractive arguments of Knowledge) proofs to protect the integrity of private token operations. ## What is PLONK verification? PLONK verification checks cryptographically that a zero-knowledge proof was produced correctly, without exposing the private data behind it. In this course, it confirms that private transfers, shielding, and unshielding are mathematically valid while the details stay hidden. ## Core verification function: `zkp.check_plonk_proof` ### Function overview Chromia provides `zkp.check_plonk_proof` as a built-in function for verifying PLONK proofs inside blockchain operations: Chromia ZKP Library ``` /** * Checks whether or not the current transaction contains a valid PLONK proof. * * @param verification_key_id ID of the verification key that the proof must have been validated with * @param public_signals The public signals that the proof must have been validated with */ function check_plonk_proof( verification_key_id: text, public_signals: list ) ``` ### Verification requirements The dapp can only verify a proof if the transaction carries a `zkp_plonk_verify` GTX operation with these three parts: 1. **Verification key ID**: Identifies a key that you have configured in `chromia.yml` 2. **PLONK proof**: The proof data that the circuit produced 3. **Public signals**: The public values the proof attests to ### Dapp verification keys Each operation in the course has its own verification key, for three keys in total: zkp-demo/rell/chromia.yml ``` # chromia.yml configuration zkp: plonk: verification_keys: private_transfer: # For anonymous transfers curve: bn128 nPublic: 5 shield_operation: # For converting public to private tokens curve: bn128 nPublic: 4 unshield_operation: # For converting private to public tokens curve: bn128 nPublic: 4 ``` ## Verification security features ### Double-spending prevention Verification also checks nullifiers, which stops a proof from being reused: zkp-demo/rell/src/zkp\_demo/operations.rell ``` // Check if nullifier has been used before require_not_exists(nullifier_registry @* { .nullifier == nullifier }); // Register the nullifier after successful verification create nullifier_registry(nullifier = nullifier, block_height = op_context.block_height); ``` ### Signal integrity When `check_plonk_proof` succeeds, you know that: * The submitted public signals are exactly the ones the proof was built for * The proof was produced under the correct circuit constraints * Nothing was altered in transit ### Circuit constraint validation A valid PLONK proof gives a mathematical guarantee that: * The prover holds the private key behind the commitment * Arithmetic relationships, such as balances, are preserved * The circuit logic ran correctly from start to finish Together, these checks keep every private operation in the course both confidential and mathematically correct, and they underpin the secure private token transfer system. Written for this site from Chromia’s public course. Code samples are the course’s own. [← Previous**Dapp entities**](https://chromia.com/learn/zero-knowledge-proof/dapp/dapp-entities/)[Next →**Dapp operations overview**](https://chromia.com/learn/zero-knowledge-proof/dapp/dapp-operations/) On this page * [What is PLONK verification?](#what-is-plonk-verification) * [Core verification function: zkp.check\_plonk\_proof](#core-verification-function-zkpcheck_plonk_proof) * [Verification security features](#verification-security-features)