Zero-Knowledge Age Verification on Midnight: How Compact Enables Private On-Chain Data

Efe Kırbaş — Mon, 10 Aug 2026 08:30:56 +0000

How do you verify user eligibility on-chain without revealing sensitive personal identity data?

Traditional KYC processes force an unwanted trade-off: transparency versus privacy. Exposing dates of birth or identity credentials directly on a public ledger introduces severe privacy and security risks.

Midnight Network solves this dilemma through a clean separation of Public vs. Private State:

Private State: The user's sensitive data (e.g., birthdate) stays on-device in their local environment/wallet.
Public State: Only the verification status (e.g., a boolean true/false) is posted to the ledger.

How Compact Structures ZK Predicate Logic

Midnight’s domain-specific language, Compact, allows developers to write zero-knowledge logic without drowning in complex cryptographic circuits.

Here is how a simple ZK predicate for age verification looks in Compact:

contract AgeVerification {
    state {
        is_verified: Map<Address, bool>;
    }

    transition verify_age(birth_year: Uint, current_year: Uint) {
        // Executed inside the ZK circuit
        assert (current_year - birth_year) >= 18;

        // Public ledger only learns the boolean output
        next(is_verified[caller]) = true;
    }
}

How It Works Under the Hood

Local Input: The user inputs their birth_year locally inside their wallet.
ZK Proof Generation: The wallet executes the circuit locally and generates a Zero-Knowledge Proof confirming (current_year - birth_year) >= 18.
Off-Chain Privacy: The actual birth_year raw data never leaves the off-chain environment.
On-Chain Verification: Validators only verify the validity of the mathematical proof—never the raw user inputs.

Why This Matters

This architecture replaces raw data exposure with verifiable cryptographic proofs. From selective KYC to private DeFi credit scoring, Midnight abstracts complex ZK mathematics into simple, readable logic.

Building privacy-first dApps on Midnight changes how we handle data ownership on-chain.

Mastering Zero-Knowledge Identity Patterns in Midnight with Compact

Efe Kırbaş — Sun, 09 Aug 2026 08:10:34 +0000

If you're coming from the world of EVM and Solidity, you know the golden rule: everything on the blockchain is public. If you need to verify a user's identity, you typically have to store their public address or identity hash directly on-chain, creating a permanent, public trail of their activities.

Midnight Network flips this paradigm on its head. As a data-protection blockchain, it allows developers to build applications that protect sensitive data while still guaranteeing execution correctness through Zero-Knowledge (ZK) proofs.

In this guide, we're going to dive into Compact (Midnight’s TypeScript-inspired smart contract language) and explore a fundamental privacy pattern: Zero-Knowledge Identity Verification.

The Concept: Commit-Reveal Identity

To verify a user without exposing who they are, we use a pattern where:

The user holds a Private Secret.
The contract stores a Public Commitment (a hash of the secret).
The user generates a ZK Proof locally to prove they know the secret behind the commitment, without ever revealing the secret itself to the network.

In Compact, this is achieved through three core pillars:

Ledger: Public state visible to everyone.
Witness: Private data that never leaves the user's local machine.
Circuit: The logic that generates a ZK proof locally before submitting a transaction.

The Code Implementation

Here is a fully functional Compact contract implementing this pattern.

pragma language_version >= 0.23;
import CompactStandardLibrary;

// 1. PUBLIC LEDGER STATE
// Directly export a single updatable ledger storage slot.
export ledger last_user: Bytes<32>;

// 2. PRIVATE WITNESS DATA
// Witnesses are strictly local. This value is never sent over the network.
witness secret_key(): Bytes<32>;

// 3. ZK CIRCUITS
export circuit update(): [] {
    // Read the private secret key locally from the user's device
    const sk = secret_key();

    // Derive a cryptographic commitment (identifier) from the private key
    const myself = persistentHash<Bytes<32>>(sk);

    // Write the commitment to the public ledger. 
    // disclose() is used to intentionally make the hashed value public.
    last_user.write(disclose(myself));
}

export circuit verify_user(): [] {
    // Read the private secret key locally again
    const sk = secret_key();

    // Re-calculate the identifier
    const myself = persistentHash<Bytes<32>>(sk);

    // ZK Assertion: Ensure the calculated hash matches the public ledger state.
    // If this fails, the proof generation fails.
    assert(myself == last_user.read(), "Oops: you're not the current user");

    // If successful, the blockchain only receives a mathematical proof 
    // that this assertion passed. The `secret_key` remains hidden!
}

Breaking Down the Magic

Let's look at why this works securely and doesn't leak data:

Step 1: The Witness Function

Unlike Solidity where msg.sender is implicitly public, Compact forces you to define private data explicitly using the witness keyword. When a user interacts with this contract, the secret_key value is supplied locally by the DApp's witness implementation (backed by the private-state provider running in the user's wallet). The Proof Server later generates the ZK proof from data already supplied locally; it never sources or handles your raw secrets.

Step 2: The Hash Commitment

We cannot store the secret_key directly on the ledger. Instead, we use persistentHash, a built-in Compact function designed specifically for deriving state identifiers from private data. It creates a one-way deterministic hash.

Step 3: Zero-Knowledge Assertion

This is where the Zero-Knowledge magic happens. When verify_user() is called, the user's machine executes the code, hashes their local secret, and compares it against last_user.read().
If they match, the machine generates a ZK Proof saying: "I executed this code, and the assertion was true."
The Midnight network validates the proof, not the data. The network knows the user is authorized, but has absolutely no idea what the secret_key actually is.

Conclusion

By separating data into Ledger (public) and Witness (private), and combining them inside a Circuit, Compact makes building Zero-Knowledge applications incredibly intuitive.

You no longer have to be a cryptographer writing complex polynomial equations to utilize ZK-rollups. With a syntax that feels right at home for Web2 and Web3 developers alike, Midnight allows you to build dApps where privacy is the default, not an afterthought.

Have you experimented with Compact yet? Let me know what you're building in the comments!

DEV Community: Efe Kırbaş