ZK Proofs para devs: onde usar (e onde NÃO usar) em produtos reais

ZK (Zero Knowledge) é a ferramenta mais mencionada em blockchain e uma das mais mal entendidas.

Desenvolvedor novo em cripto ouve "escalabilidade" e pensa "preciso de ZK-rollup". Ouve "privacidade" e pensa "ZK é solucao". Realidade 2026: ZK é poderoso e caro. Use onde realmente importa.

Vamos entender o que é, quando faz sentido, quando é overengineering puro, e como você implementa sem ter PhD em criptografia.

ZK em linguagem humana (sem formulas)

Zero Knowledge Proof = você prova que conhece algo sem revelar o algo.

Exemplo analogico:

Normal: você quer provar que conhece senha do banco. Digita pra banco. Banco vê.

ZK: você quer provar que conhece senha SEM digitar. Como? Usa um truque criptográfico que diz "eu conheço o SHA256 dessa senha. Aqui tá a prova" (prova matemática, nao a senha).

Banco verifica a prova em <1s. Aí sabe que você conhece senha (sem ver ela).

Outro exemplo: você quer provar que é maior de idade sem revelar data de nascimento. ZK permite isso.

Na blockchain: você quer provar que "transferi $100 corretamente" sem divulgar pra todo mundo que sou você. ZK prova: "essa transacao e valida (signatures, balances tudo ok)" SEM revelar remetente/destinatario.

O trade-off fundamental: custo de prover vs verificacao barata

Aqui vai a razao pela qual ZK eh tao importante em blockchain:

On-chain verificacao de transacao:

Normal: todo node verifica cada transacao (10k nodes). Custo: 10k X verificacao = muita computacao redundante.

Com ZK: 1 prover gera prova (custoso, 10-100 segundos). Nodes apenas verificam prova (< 1ms cada). Custo: 1 X prover + 10k X verificacao cheap = economiza 99%.

Isso eh escala. Nao porque ZK eh magico; porque desloca o custo do verificacao pra prova.

Trade-off real (2026):

Aspecto	Sem ZK	Com ZK
Tempo pra gerar prova	0 (nao ha)	10-120s
Tamanho da prova	N/A	100-500 bytes
Custo on-chain	21k-500k gas	50k-200k gas
Latencia ao usuario	13s (1 bloco)	10s (prover) + 13s (block)
Privacy	Nenhuma	Full (depende do scheme)

Quando vale a pena? Quando volume justifica o overhead de prover.

Exemplo:

• Aplicacao com 1 transacao/dia: Nao vale. Gas de setup > economia.
• Aplicacao com 10k transacoes/dia: Vale. Prover roda 1x dia, depois batch tudo.

Casos de uso realistas onde ZK faz sentido

1. ZK-Rollups (escala)

Bundler coleta 10k transacoes, prova que todas sao validas sem revelar conteúdo. Depois seta prova on-chain. Resultado: 10k transacoes em 1 on-chain transacao.

Exemplo: zkSync, StarkNet.

Real em 2026? Sim. zkSync tem ~US$2B TVL. StarkNet em growth.

2. Identity/KYC privado

Usecase: você quer usar DeFi (precisa ser KYCd por regulacao). Mas nao quer revelar pra todo mundo sua identidade on-chain.

Solucao: você faz KYC com serviço centralizado (Onfido, Jumio). Serviço gera ZK proof: "esse endereço e KYCd" (sem revelar seu nome). Você seta a prova no contrato.

Contrato: "pede prova ZK de KYC, senão rejeita".

Real em 2026? Sim. Privacy pools (zkKYC), Civicpass (privado), ZKSIM (identity).

3. ZK light client / bridge

Blockchain A quer saber estado de blockchain B, mas nao quer rodar node de B (custoso, lento).

Solucao: ZK proof que diz "bloco 2M53k de chain B eh esse header" (prova matematica). Light client apenas verifica prova.

Real em 2026? IBC (Inter-Blockchain Communication) em Cosmos usa isso. Ethereum <-> zkEVM bridges usam.

4. Private voting

Usecase: DAO vote, mas nao quer que spy saiba como voce votou (coercao, bots).

Normal: vota publico on-chain. Qualquer um pode ve e fazer bots (comprar seu voto).

Com ZK: vota, gera ZK proof "votei em opcao X" sem revelar X on-chain. Tally soa as provas depois (reveal).

Real em 2026? Ainda raro. ZKVote, Semaphore (Ethereum), Aleo usam.

5. Off-chain compute verification

Usecase: seu app precisa rodar funcao complexa (modelo IA, simulacao). Nao quer pagar gas em blockchain, mas quer que ninguém mine a saída.

Solucao: roda off-chain, gera ZK proof "rodei corretamente". Prova vai on-chain.

Real em 2026? Risc Zero, SP1 estao buildando exatamente isso. Prover pode rodar modelo ML, blockchain só valida prova.

Casos onde ZK eh OVERKILL

1. Simples verificacao de dados (analytics, logs)

Você quer provar que cumpriu SLA (uptime > 99%). Gera prova ZK.

Problema: SLA eh informacao publica anyway. Privacidade nao importa. Voce so precisa de assinatura + timestamp.

Uso de ZK: zero value. Custo: 100x a solucao simples.

2. Dados que nao sao secretos

You want to prove "tenho US$100 em saldo". Voce pode... só mostrar o saldo on-chain (é publica anyway pra todo mundo).

ZK seria: gero prova que "tenho saldo > $100" sem revelar exato. Bonito? Sim. Necessario? Nao.

A menos que a privacidade importe (e aqui nao importa).

3. Coisas sem necessidade de verificacao trustless

Exemplo: você quer provar que terminou um course (Udemy, Coursera).

Tradicional: Udemy emite certificado (assinado digitalmente). Pronto, verificavel.

ZK: você gera prova de "completei course" sem revelar dados do course.

Valor: quase nenhum. Coursera assinatura ja e verificavel.

4. Performance nao e a limitacao

App que faz 1 transacao por segundo. ZK adicionaria 20 segundos de overhead.

Sem ZK: 13s (1 bloco). Com ZK: 10s (prover) + 13s (bloco) = 23s total.

Piora a UX por zero ganho. Nao use.

Stacks atuais (2026)

Se voce decidiu que ZK faz sentido, qual escolher?

Stack	Linguagem	Output	Tempo prova	Caso
Risc Zero	Rust	EVM	20-60s	Off-chain compute
SP1	Rust	EVM	30-120s	Off-chain compute
Circom + Snarkjs	Circom	EVM	2-10s	Custom proofs
Noir	Noir lang	EVM, non-EVM	5-30s	General purpose
zkSync	Solidity	zkSync chain	N/A (rollup)	Full chain
StarkNet	Cairo	StarkNet chain	N/A (rollup)	Full chain

Risc Zero: melhor se seu prover eh programa Rust complexo (IA, simulacoes). Executa qualquer Rust.

SP1: melhor se ja usa Rust, quer simplicidade. RISC-V architecture.

Circom + Snarkjs: melhor se prova e "simples" (3-5 constraintos). Learning curve acentuada.

Noir: mais novo, menos proven, mas syntax amigavel.

Escolha: comece com Risc Zero ou SP1 (mainstream 2026).

Fluxo típico: implement um ZK proof (pseudocodigo)

1. Identifica o que voce quer provar
   Exemplo: "tenho saldo > $1000 em USDC"

2. Define o "circuit" (funcao que sera provada)
   Input privado: seu saldo exato
   Input publico: limite ($1000)
   Output: true/false

3. Implementa circuit em Rust (Risc Zero) ou Circom
   
   // Pseudocodigo Rust
   pub fn prove_balance(balance: u256, limit: u256) -> bool {
       balance >= limit
   }

4. Compila pra "constraints" (formato que zk-prover entende)

5. Executa prover locally
   Input: balance=5000, limit=1000
   Output: proof (bytes aleatorios de ~200 bytes)

6. Usuario manda prova on-chain
   Smart contract verifica
   contract.verifyBalance(proof, publicLimit=1000)
   → retorna true se proof valido

7. Contract executa logica se true
   "você passou, pode continuar"

Cada passo tem overhead. Total: semanas de desenvolvimento pra algo "simples".

Custo real de rodar ZK em 2026

Prover cost

Hardware: GPU (NVIDIA A100 ideal, custo ~$4/hora cloud).

Exemplo:

• Risc Zero: US$0.50-2 por prova (dependendo da complexidade)
• SP1: US$0.20-1 por prova
• Circom: US$0.01-0.10 por prova (mais simples)

Volume: 10k provas/dia = US$5k-20k/dia = US$150k-600k/mes.

Viavel se: seu app ronda volumão e usuarios pagam fee que cobre. Nao viavel se usuario espera gratis.

On-chain verify cost

Verification on-chain custa ~50k-150k gas (dependendo do scheme).

Em Arbitrum (barato): ~US$0.10-0.50 por verificacao.

Em Mainnet Ethereum: ~US$2-10 por verificacao (ouch).

Isso eh por prova setada on-chain. Se voce batches 10k provas em 1 prova, custa 1x (US$0.10-10 dependendo chain).

Pseudocodigo: ZK proof simples em Rust (Risc Zero)

// risc0/examples/prove_saldo.rs
use risc0_zkvm::guest::env;

pub fn prove() {
    // Input privado
    let saldo_usuario: u256 = env::read();
    let limite: u256 = env::read();

    // Logica
    let prova = saldo_usuario >= limite;

    // Output (publico)
    env::commit(&prova);
}

Host side (seu computador):

use risc0_zkvm::Client;

fn main() {
    let client = Client::new();
    
    // Private input
    let saldo = 5000u256;
    let limite = 1000u256;
    
    let receipt = client.prove(
        PROVE_ID,
        vec![saldo, limite]
    ).unwrap();
    
    // Receipt eh a prova
    println!("Prova: {:?}", receipt);
}

On-chain (Solidity):

pragma solidity ^0.8.0;

interface IVerifier {
    function verify(bytes calldata proof) external view returns (bool);
}

contract BalanceGate {
    IVerifier public verifier;

    function entrarSeRico(bytes calldata proof) external {
        require(verifier.verify(proof), "Prova invalida");
        // Usuario passou, permite entrada
    }
}

Real? Sim, Risc Zero fornece ABI pra contracts automáticamente.

Checklist: decide se ZK faz sentido pro seu app

• Meu problema eh escala (10k+ transacoes/batch)?
• Ou privacy crítica (identidade, voto, dados pessoais)?
• Ou off-chain compute que precisa verificacao?
• Ou light client (blockchain sem rodar node full)?
• Se todas respostas sao NAO, ZK provavelmente eh overkill.
• Se sim em alguma, quantifique custo: prover + on-chain verify.
• Compara com alternativa simples (assinatura, Oracle, etc).
• Se ZK custa 10x a alternativa, reconsidere.

"ZK é o martelo que parece pregar em tudo. Mas nem todo problema é prego." — Realidade de quem viu US$500k em prover cost pra economia de US$10k em gas.

O futuro de ZK (2026+)

Hardware acelera (GPUs, ASICs customizados).

Risc Zero anunciou que prover tempo cai 100x em 2026-2027 (hardware dedicated).

Isso muda a equacao: se provar custar US$0.001, aplicacoes antes-impossíveis viram viavel.

Mas por enquanto: use ZK onde REALMENTE importa.

---

Na Alienhub, ajudamos com decisoes de ZK. Se seu produto genuinamente precisa (off-chain compute, privacy, scaling), buildamos. Se é "cool to have", falamos a verdade.