Glossary OS

Plain meaning

Start with the shortest useful explanation before going deeper.

A cryptographic technique where a zero-knowledge proof verifies the correctness of another proof, enabling incremental verification of unbounded computations and proof aggregation. Recursive composition allows a single compact proof to attest to an arbitrarily long chain of computations, essential for rollup proof aggregation and reducing on-chain verification costs. Systems like Plonky2, Halo2, and Nova implement recursive proving.

Mental model

Use the quick analogy first so the term is easier to reason about when you meet it in code, docs, or prompts.

Think of it as a building block that connects one definition to the larger Solana system around it.

Technical context

Place the term inside its Solana layer so the definition is easier to reason about.

Failure modes, audits, attack surfaces, and safe design patterns.

Why builders care

Turn the term from vocabulary into something operational for product and engineering work.

This term unlocks adjacent concepts quickly, so it works best when you treat it as a junction instead of an isolated definition.

AI handoff

Use this compact block when you want to give an agent or assistant grounded context without dumping the entire page.

Recursive Proofs (recursive-proofs)
Category: Security
Definition: A cryptographic technique where a zero-knowledge proof verifies the correctness of another proof, enabling incremental verification of unbounded computations and proof aggregation. Recursive composition allows a single compact proof to attest to an arbitrarily long chain of computations, essential for rollup proof aggregation and reducing on-chain verification costs. Systems like Plonky2, Halo2, and Nova implement recursive proving.
Aliases: Proof Recursion, Proof Aggregation
Related: Zero-Knowledge Proofs (ZKP), ZK-EVM

Glossary Copilot

Ask grounded Solana questions without leaving the glossary.

Use glossary context, relationships, mental models, and builder paths to get structured answers instead of generic chat output.

Open full Copilot workspace

Question

Explain this code

Optional: paste Anchor, Solana, or Rust code so the Copilot can map primitives back to glossary terms.

Ask a glossary-grounded question

The Copilot will answer using the current term, related concepts, mental models, and the surrounding glossary graph.

Concept graph

See the term as part of a network, not a dead-end definition.

These branches show which concepts this term touches directly and what sits one layer beyond them.

Branch

Zero-Knowledge Proofs (ZKP)

A zero-knowledge proof is a cryptographic protocol by which a prover convinces a verifier that a statement is true — for example, that a state transition is valid — without revealing any information beyond the truth of the statement itself, satisfying the properties of completeness, soundness, and zero-knowledge. In Solana's ecosystem, ZKPs are used by ZK Compression (via Groth16 SNARKs) to prove correct state transitions for compressed accounts without storing full account state on-chain, and by the Token-2022 Confidential Transfers extension (via ElGamal encryption and range proofs) to prove token balances are non-negative without revealing the actual amounts. Solana's BPF VM exposes the alt_bn128 elliptic curve syscall to make on-chain Groth16 proof verification computationally feasible within the 1.4M compute unit budget.

Groth16 PLONK

Open term

Branch

ZK-EVM

A zero-knowledge virtual machine that generates cryptographic validity proofs for Ethereum-compatible smart contract execution, enabling ZK rollups that run existing Solidity code. Vitalik Buterin's Type 1-4 classification captures the trade-off between full Ethereum equivalence (Type 1, slower proving) and modified execution (Type 4, faster proving). Major implementations include Polygon zkEVM, zkSync Era, Scroll, and Linea.

Rollup

Open term

Next concepts to explore

Keep the learning chain moving instead of stopping at one definition.

These are the next concepts worth opening if you want this term to make more sense inside a real Solana workflow.

ZK Compression

Zero-Knowledge Proofs (ZKP)

A zero-knowledge proof is a cryptographic protocol by which a prover convinces a verifier that a statement is true — for example, that a state transition is valid — without revealing any information beyond the truth of the statement itself, satisfying the properties of completeness, soundness, and zero-knowledge. In Solana's ecosystem, ZKPs are used by ZK Compression (via Groth16 SNARKs) to prove correct state transitions for compressed accounts without storing full account state on-chain, and by the Token-2022 Confidential Transfers extension (via ElGamal encryption and range proofs) to prove token balances are non-negative without revealing the actual amounts. Solana's BPF VM exposes the alt_bn128 elliptic curve syscall to make on-chain Groth16 proof verification computationally feasible within the 1.4M compute unit budget.

Open term

Security

ZK-EVM

A zero-knowledge virtual machine that generates cryptographic validity proofs for Ethereum-compatible smart contract execution, enabling ZK rollups that run existing Solidity code. Vitalik Buterin's Type 1-4 classification captures the trade-off between full Ethereum equivalence (Type 1, slower proving) and modified execution (Type 4, faster proving). Major implementations include Polygon zkEVM, zkSync Era, Scroll, and Linea.

Open term

Security

Reentrancy (Solana)

In Solana's context, reentrancy refers to a scenario during a CPI call where the called program invokes back into the calling program (direct reentrancy) or into a shared mutable account via a third program (indirect reentrancy), potentially causing the calling program to re-execute logic with state that has been partially modified by the intervening CPI. The Solana runtime prevents direct same-program reentrancy at the VM level — a program cannot CPI into itself — but indirect reentrancy through mutable shared accounts is possible and can cause account-reloading vulnerabilities where a program's cached account data becomes stale. Programs should reload account state after every CPI that may have modified shared accounts and avoid assuming pre-CPI state invariants hold afterward.

Open term

Security

Property-Based Testing

A testing methodology where developers define properties (invariants) that must hold true for all valid inputs, and a test framework generates random inputs to attempt to falsify those properties. Unlike unit tests that check specific examples, property-based testing explores the input space stochastically. For Solana programs, properties might include 'total token supply never changes during transfers' or 'only the authority can modify the config account.' Tools like Trident and proptest support this approach.

Open term

Related terms

Follow the concepts that give this term its actual context.

Glossary entries become useful when they are connected. These links are the shortest path to adjacent ideas.

ZK Compressionzk-proofs

Zero-Knowledge Proofs (ZKP)

A zero-knowledge proof is a cryptographic protocol by which a prover convinces a verifier that a statement is true — for example, that a state transition is valid — without revealing any information beyond the truth of the statement itself, satisfying the properties of completeness, soundness, and zero-knowledge. In Solana's ecosystem, ZKPs are used by ZK Compression (via Groth16 SNARKs) to prove correct state transitions for compressed accounts without storing full account state on-chain, and by the Token-2022 Confidential Transfers extension (via ElGamal encryption and range proofs) to prove token balances are non-negative without revealing the actual amounts. Solana's BPF VM exposes the alt_bn128 elliptic curve syscall to make on-chain Groth16 proof verification computationally feasible within the 1.4M compute unit budget.

Open term

Securityzk-evm

ZK-EVM

A zero-knowledge virtual machine that generates cryptographic validity proofs for Ethereum-compatible smart contract execution, enabling ZK rollups that run existing Solidity code. Vitalik Buterin's Type 1-4 classification captures the trade-off between full Ethereum equivalence (Type 1, slower proving) and modified execution (Type 4, faster proving). Major implementations include Polygon zkEVM, zkSync Era, Scroll, and Linea.

Open term

Stay in the same layer and keep building context.

These entries live beside the current term and help the page feel like part of a larger knowledge graph instead of a dead end.

Security

Missing Signer Check

A vulnerability where a program accepts an account in a privileged role (e.g., admin, authority, payer) without verifying that the account actually signed the transaction, allowing any caller to impersonate that authority by simply passing the target pubkey as an instruction account. In native Solana programs, the check requires asserting account.is_signer == true; in Anchor, the Signer<'info> type enforces this automatically. Exploitation lets an attacker bypass all access control gated on authority equality checks, making it one of the most critical and commonly audited vulnerabilities in Solana programs.

Open term

Security

Missing Owner Check

A vulnerability where a program deserializes and trusts account data without first confirming that the account is owned by the expected program, allowing an attacker to substitute a maliciously crafted account owned by a different program whose byte layout happens to satisfy the deserialization. On Solana, every account stores a 32-byte owner field set to the program that created it; native programs must assert account.owner == &expected_program_id, while Anchor's Account<'info, T> wrapper performs this check automatically. Failure to validate ownership can lead to complete auth bypass if an attacker can construct a fake account whose data parses into a struct with elevated privileges.

Open term

Security

Arbitrary CPI

A vulnerability where a program accepts an arbitrary program account from the caller and invokes it via Cross-Program Invocation (CPI) without verifying it matches a known, trusted program ID, effectively letting an attacker substitute a malicious program that executes under the victim program's authority or manipulates accounts the victim program passes to it. A common pattern is accepting a token_program account without checking it equals spl_token::ID, so the attacker passes a lookalike program that records or drains account data. Prevention requires hard-coding or explicitly checking the program ID before every CPI call.

Open term

Security

PDA Substitution Attack

A vulnerability where a program derives a PDA internally but accepts an externally supplied account as that PDA without re-deriving and comparing the address, allowing an attacker to pass a different PDA (derived from attacker-controlled seeds) that the program will treat as legitimate. Because PDAs are deterministic, the only way to guarantee account identity is to call Pubkey::find_program_address (or equivalent) with the expected seeds inside the program and assert the result equals the supplied key. Anchor's seeds and bump constraints on the Account type automate this re-derivation and equality check.

Open term