Midnight na Prática

Casos de Uso, Arquitetura e Construção de dApps

Tainá Bugs

Aliit Fellow · Midnight

Erick Romero

Aliit Fellow · Midnight

Web3Experts Brazil 2026 · Workshop

Privacidade nos seus apps sem virar criptógrafo.

Você escreve código familiar. A criptografia complexa fica nos bastidores.

Parte A · Bloco 0

O formato

A~35 min

Teoria leve + casos de uso

por quê, o quê, e o modelo mental

B~85 min

Os repos e os contratos

código de verdade, lido e rodado na tela

Parte A · teoria

Parte B · mão na massa

Trouxe notebook? Dá pra acompanhar junto. Não trouxe? Funciona igual.

Parte A · Bloco 1

Transparente, mas exposto

Privado, mas opaco

A escolha que blockchain te obriga a fazer hoje. Nenhuma das duas serve.

Parte A · Bloco 1

O custo real

US$ 4,88M

custo médio de um data breach (2024)

38 TB

dados privados expostos pela Microsoft AI (2023)

US$ 2,1B

multas de privacidade na UE

Parte A · Bloco 1

Casos de uso

Privacidade cabe em quase tudo

Finanças

negociar grande sem mover o preço

provar solvência sem abrir a carteira

transferir sem expor valor e destino

Saúde

provar elegibilidade sem abrir o prontuário

entrar em pesquisa sem se identificar

trocar dado clínico sem vazar o paciente

Governança

votar sem revelar o voto

denunciar sem se expor

licitar sem brecha pra fraude

IA

treinar modelo sem ver os dados

agentes negociando sem vazar estratégia

vender dado provando a qualidade

exemplos reais, não uma lista fechada: onde existe dado sensível, cabe um app Midnight.

Parte A · Bloco 1

Agentes

Agentes autônomos, vivendo on-chain

Uma cidade de agentes de IA que transacionam, com identidade e privacidade própria, rodando na Midnight.

O futuro de muitas apps não é humano clicando, e sim agente negociando com agente. E agente também precisa de privacidade.

midnight.city

Parte A · Bloco 1

Quer mais ideias?

Um catálogo vivo de casos de uso

Request for Startups

~130 ideias reais de dApp: de DEX a saúde, governo e IA, atualizado pela Midnight

midnight.network/request-for-start-ups

Parte A · Bloco 2

ZK sem dor

Você prova que tem +18. Sem mostrar o RG.

Seu RG · fica com você

Nome oculto

Data de nascimento oculto

Endereço oculto

Foto oculto

ZK proof

✓

pode comprar

o caixa não vê mais nada

prova de que a regra foi cumprida, sem entregar os dados que a cumpriram.

Parte A · Bloco 2

O modelo mental

Privado de um lado, público do outro

PRIVADO · sua máquina

PÚBLICO · a chain

ESTADOonde o dado mora

existe só na sua máquina. Mais ninguém enxerga.

fica na chain, à vista de todo mundo.

COMPUTAÇÃOonde roda

seu código roda aqui, antes de qualquer coisa ir pra chain.

confere a prova e registra o que ficou público. nunca roda o seu código.

Parte A · Bloco 2

A chain verifica. Ela não executa.

SUA MÁQUINA privado

estado privado

1 roda o seu código aqui

2 gera a prova de que seguiu as regras

a prova
+ o resultado público

a única coisa que cruza

A CHAIN público

estado público

✓ verifica a prova

✓ registra o que ficou público

✗ não roda o seu código

seu estado privado NUNCA cruza essa linha

Parte A · Bloco 2

Os dois tokens

NIGHT gera DUST. DUST paga as taxas.

NIGHT

o ativo que você segura

escasso · transferível
governa a rede

GERA

só por você segurar

DUST

o combustível das transações

paga as taxas · se renova
não transfere

Você não queima o ativo pra transacionar, e o gasto de DUST fica desacoplado do seu saldo.

Parte B · Bloco 3

Os repositórios do workshop

Para que serve cada um

aprender o contrato

counterbulletin-boardtokens

você lê e roda os contratos, sem Docker nem wallet.

github.com/eddalabs/midnight-contracts

virar um app

frontendwalletdeploy

o mesmo counter, como app end-to-end.

github.com/eddalabs/midnight-starter-template

Parte B · Bloco 3

Dentro do midnight-contracts

Do contrato mais simples ao mais avançado

1countersó estado público, o mais simples

2bulletin-boardentra o dado privado

3unshielded-tokentokens públicos: mint, send, receive

4shielded-tokentokens privados: valor e dono escondidos

cada contrato traz .compactsimuladortestesdocs.md

e você testa a lógica em memória, sem Docker, sem wallet, sem proof server.

github.com/eddalabs/midnight-contracts

Parte B · Bloco 3

O próximo passo

O mesmo counter, agora end-to-end

contratoCLIfrontenddeploy

github.com/eddalabs/midnight-starter-template

Parte B · Bloco 4

O contrato inteiro · counter

Um contrato é estado + função

pragma language_version >= 0.23;

import CompactStandardLibrary;

// public state
export ledger round: Counter;

// transition function changing public state
export circuit increment(): [] {
  round.increment(1);
}

Sem witness, sem privacidade, ainda. É a base limpa, antes de adicionar o segredo.

Parte B · Bloco 4

A anatomia, linha por linha

cada linha é o modelo mental com palavras-chave.

pragma language_version >= 0.23;

import CompactStandardLibrary;

export ledger round: Counter;     // estado público

export circuit increment(): [] {  // vira um circuito ZK
  round.increment(1);              // muda o estado público
}

1ledger = o estado público: on-chain, todo mundo lê. Counter é um tipo da stdlib (tem .increment()), não um número solto.

2circuit, não function. É o "roda o seu código" do seu lado: a chain só verifica a prova, não executa. O [] = não devolve nada; existe pelo efeito no estado.

3round.increment(1) muda o estado público, é isso que a chain registra.

Parte B · Bloco 4

O que o compile gera

Compilar transforma o `.compact` em artefatos.

O mesmo counter que você leu linha por linha, agora compilado.

src/counter.compact

compact compile

src/managed/counter/

contract/API TypeScripté só isso que o teste usa

zkir/representação do circuito

keys/chaves ZK (prover / verifier)só no compile cheio

compiler/metadados do build

Fase 1 (hoje): teste em memória, nenhuma prova é gerada, usa só o contract/; por isso compact-fast basta. Fase 2 (Bloco 7): deploy de verdade; aí as chaves ZK entram. Esses artefatos não vão no repo (.gitignore), cada um gera os seus.

DEMO

cd counter-contract
npm run compact-fast
&& npm test

Agora com privacidade · bulletin-board

Um mural público, uma nota por vez

qualquer um posta, e só quem postou pode tirar.

Parte B · Bloco 5

Como fica anônimo

Anônimo, mas só o autor tira

Pra tirar, você refaz o carimbo com a mesma chave. Bate? então é você, sem o quadro nunca saber quem é.

Parte B · Bloco 5

O contrato inteiro

pragma language_version >= 0.23;
import CompactStandardLibrary;
// 1 · estado público
export ledger note: Opaque<"string">;
export ledger hasNote: Boolean;
export ledger authorCommitment: Bytes<32>;
// 2 · o segredo (a chave)
witness local_secret_key(): Bytes<32>;
// 3 · faz o carimbo
pure circuit compute_author_commitment(sk: Bytes<32>): Bytes<32> {
  return persistentHash<Vector<2, Bytes<32>>>([pad(32, "bboard:author:"), sk]);
}
// 4 · postar
export circuit postNote(content: Opaque<"string">): [] {
  assert(disclose(!hasNote), "Board is full");
  const sk = local_secret_key();
  const commitment = compute_author_commitment(sk);
  note = disclose(content);
  authorCommitment = disclose(commitment);
  hasNote = true;
}
// 5 · tirar
export circuit takeDown(): [] {
  assert(disclose(hasNote), "No note to take down");
  const sk = local_secret_key();
  const callerCommitment = compute_author_commitment(sk);
  assert(disclose(callerCommitment == authorCommitment), "Only the original author");
  hasNote = false;
}

as 5 partes

1

estado público

a nota, se tem nota, e o autor virado um hash

2

o segredo

a chave do autor, que nunca sai da sua máquina

3

faz o carimbo

o hash da chave, que esconde quem postou

4

postar

guarda a nota e o carimbo, se o quadro está vazio

5

tirar

só quem refaz o carimbo com a mesma chave

Parte B · Bloco 5

O estado público

// estado público: todo mundo lê
export ledger note: Opaque<"string">;        // o conteúdo da nota
export ledger hasNote: Boolean;               // se já tem nota no quadro
export ledger authorCommitment: Bytes<32>;    // o autor, escondido num hash

A nota é pública. O autor, não: vira um hash. E de onde vem esse hash?

Parte B · Bloco 5

witness: a porta do dado privado

declaração · .compact

// só declara que esse dado privado existe
witness local_secret_key(): Bytes<32>;

implementação · TypeScript

// witnesses.ts: roda na SUA máquina, fornece o segredo
type PrivateState = { secretKey: Uint8Array };

export const witnesses = {
  local_secret_key: (context) =>
    [context.privateState, context.privateState.secretKey],
};

Parte B · Bloco 5

Postar: conteúdo público, autor escondido

export circuit postNote(content: Opaque<"string">): [] {
  assert(disclose(!hasNote), "Board is full - someone already posted a note");

  const sk = local_secret_key();
  const commitment = compute_author_commitment(sk);

  note = disclose(content);
  authorCommitment = disclose(commitment);
  hasNote = true;
}

1lê a chave privada (witness)

2o commitment vem da chave, então também é privado

3escrever no ledger torna público, por isso o disclose

4isso já era público, não precisa de disclose

Parte B · Bloco 5

disclose: você autoriza o que vira público

privado

contenta nota que você digita

sksua chave

commitmento hash da chave (interno)

→

disclose() você autoriza ✓

→

público

o compilador exige disclose quando o dado privado vira observável:

escrito no estado público (note, authorCommitment)

retornado por um circuit exportado

usado na condição de um assert

note = disclose(content);             // a nota vira pública
authorCommitment = disclose(commitment);  // o carimbo, também

O compilador só rastreia de onde o dado veio, não a criptografia: ele cuida do caminho, e você responde pelo que é seguro revelar.

Parte B · Bloco 5

Provar autoria sem revelar a identidade

export circuit takeDown(): [] {
  assert(disclose(hasNote), "No note to take down");

  const sk = local_secret_key();
  const callerCommitment = compute_author_commitment(sk);
  assert(disclose(callerCommitment == authorCommitment), "Only the original author can take down the note");

  hasNote = false;
}

authorCommitment

guardado no quadro

==

callerCommitment

refeito com a sua chave

→

✓bateé o autor

A chave nunca sai da sua máquina: pra chain cruza só o sim/não. É o padrão commitment, publica o hash uma vez e prova depois recomputando.

Parte B · Bloco 5

export ledger note: Opaque<"string">;
export ledger hasNote: Boolean;
export ledger authorCommitment: Bytes<32>;

witness local_secret_key(): Bytes<32>;

export circuit postNote(content: Opaque<"string">): [] {
  assert(disclose(!hasNote), "Board is full");
  const sk = local_secret_key();
  const commitment = compute_author_commitment(sk);
  note = disclose(content);
  authorCommitment = disclose(commitment);
  hasNote = true;
}

Onde está cada uma das 5?

ledger
witness
circuit
assert
disclose

as cinco palavras-chave, todas vistas lendo um contrato de verdade, não num slide de definição. E o padrão que costura as cinco: o commitment.

Parte B · Bloco 5

framework de teste · simulador

Testar a lógica sem deploy

it("preserva a privacidade do autor", () => {
  const simulator = createSimulator();

  // user1 posta, tira, e posta de novo
  let ledger = simulator.as("user1").postNote("Nota 1");
  const commitment1 = ledger.authorCommitment;
  simulator.as("user1").takeDown();
  ledger = simulator.as("user1").postNote("Nota 2");
  expect(commitment1).toEqual(ledger.authorCommitment);

  // agora o user2 posta
  simulator.as("user1").takeDown();
  ledger = simulator.as("user2").postNote("Nota 3");
  expect(commitment1).not.toEqual(ledger.authorCommitment);
});

1o simulador roda o contrato localmente, sem deploy

2.as("user1") e .as("user2") trocam a chave privada de cada um

3mesmo autor, mesmo commitment; outro autor, commitment diferente

npm test, e a privacidade do slide anterior vira um teste que passa.

Parte B · Bloco 6

O plugin da Edda Labs

As cinco skills do plugin de Midnight

já vem ligado no repo do workshop: .claude/settings.json com "midnight@edda-labs-marketplace": true

/midnight-docs

busca a doc oficial ao vivo e cita a fonte (índice de 100+ páginas)

/midnight-docs-repos

base técnica dos 4 repos internos: ledger (Rust), midnight-js, wallet, zk

/midnight-contracts

contratos Compact anotados: .compact + walkthrough .md (inclui o bulletin board de hoje)

/midnight-examples

DApps oficiais de referência: zkloan, kitties, rwa (contrato, CLI e UI)

/midnight-starter

layout canônico do monorepo, build pnpm + Turbo, teste e deploy

cada skill é um slash-command no Claude Code. pergunta em português, a skill responde.

no seu projeto: /plugin marketplace add eddalabs/edda-marketplace · /plugin install midnight

Parte B · Bloco 7

Do contrato ao app

O mesmo contrato, agora como app

o app adiciona CLI, frontend e deploy.

counter.compact

midnight-starter-template

counter-contracto contrato que você leuidêntico

counter-clideploy e uso pelo terminal

frontend-vite-reacta tela com wallet que o usuário abre

Parte B · Bloco 7

Do contrato à rede

A infra por trás do deploy

o app orquestra os 4 pra deployar e usar o contrato; as provas ZK rodam local, no proof server.

DEMO

o mesmo counter que você leu, agora com tela, wallet e transação on-chain.

Parte B · Bloco 8

Os dois repos

eddalabs/midnight-contracts

ler e rodar contratos, sem Docker nem wallet

eddalabs/midnight-starter-template

o mesmo counter como app: CLI, frontend, wallet, deploy

Parte B · Bloco 8

Próximos passos

Midnight Academy

a trilha oficial da Midnight, 8 módulos.

academy.midnight.network

Parte B · Bloco 8

Próximos passos

Comunidade e conteúdo

Discord

a comunidade Midnight

discord.gg/midnightnetwork

Midnight Sessions

nosso canal, walkthroughs

youtube.com/@eddalabs

Aliit Fellowship

o programa que nós somos parte

midnight.network/aliit

Midnight Expert

skills de IA pra Compact (Aaron Bassett)

github.com/aaronbassett

Parte B · Bloco 8

Próximos passos

Build Club → NIGHT Sky

da ideia (2 meses) ao acelerador (10 semanas).

midnight.network/build-club

Build Club, idea-stage, 2 meses

midnight.network/night-sky-accelerator

NIGHT Sky Accelerator, acelerador, 10 semanas

Inscrições do NIGHT Sky abertas, fecham 15/jul/2026

Privacidade nos seus apps sem virar criptógrafo. Agora é com vocês.

marquem a gente no que construírem

@tainabugs · @ErickRomeroEdda · #MidnightNetwork

Foto da turma!

Midnight na Prática

O custo real

Privacidade cabe em quase tudo

Agentes autônomos, vivendo on-chain

Um catálogo vivo de casos de uso

Você prova que tem +18. Sem mostrar o RG.

Privado de um lado, público do outro

A chain verifica. Ela não executa.

NIGHT gera DUST. DUST paga as taxas.

Para que serve cada um

Do contrato mais simples ao mais avançado

O mesmo counter, agora end-to-end

Um contrato é estado + função

A anatomia, linha por linha

Compilar transforma o .compact em artefatos.

Um mural público, uma nota por vez

Anônimo, mas só o autor tira

O contrato inteiro

O estado público

witness: a porta do dado privado

Postar: conteúdo público, autor escondido

disclose: você autoriza o que vira público

Provar autoria sem revelar a identidade

Testar a lógica sem deploy

As cinco skills do plugin de Midnight

O mesmo contrato, agora como app

A infra por trás do deploy

Os dois repos

Midnight Academy

Comunidade e conteúdo

Build Club → NIGHT Sky

Compilar transforma o `.compact` em artefatos.