Why Selective Disclosure Solves Blockchain's Oracle Problem for Identity

Traditional oracles like Chainlink or Pyth are designed for price feeds, not personal data. To verify a user's KYC, they must become custodians of the raw data, creating a massive liability and single point of failure.

• Data Breach Risk: Centralizes sensitive PII for millions.
• Regulatory Target: Becomes a licensed data processor under GDPR/CCPA.
• Architectural Mismatch: Forces a high-throughput system to handle low-frequency, high-stakes queries.

Instead of streaming raw data, a trusted issuer (e.g., a bank) signs a cryptographic attestation. The user generates a ZK-SNARK proof from it, revealing only the necessary claim (e.g., '>18 years old') to the smart contract.

• No Data Leakage: The oracle never sees or stores private user data.
• Minimal Liability: Issuer holds data; verifier only checks proof validity.
• Composable Trust: Leverages existing trust in issuers (banks, governments) without their on-chain participation.

Infrastructure like Aztec, zkSync Era, and Starknet provide the programmable privacy and efficient verification required. Projects like Sismo and Ontology are building the primitive layers.

• Scalable Verification: zkRollup circuits can verify thousands of identity proofs per batch for <$0.01.
• Portable Identity: A single proof can be reused across chains via bridges like LayerZero or Axelar.
• New Markets: Enables undercollateralized lending, compliant DeFi, and sybil-resistant governance without surveillance.

Current models require users to send raw, sensitive data (KYC docs, credit scores) to a centralized oracle. This creates massive honeypots and violates data minimization principles.

• Data Breach Risk: Centralized storage of PII for millions of users.
• No User Control: Users cannot prove a specific claim (e.g., age > 18) without revealing their entire identity document.
• Compliance Nightmare: GDPR and similar regulations make this model legally untenable at scale.

The stack shifts from data fetching to proof verification. Trusted issuers sign claims, users generate ZK proofs, and on-chain verifiers check the signature and proof logic.

• Selective Disclosure: Prove you're accredited without revealing your name or net worth.
• User-Custodied: Credentials are stored in a user's wallet, not a central DB.
• W3C Standard: Built on the interoperable Verifiable Credentials data model, enabling composability across chains and dApps.

Polygon ID provides an issuer node, a wallet SDK, and a verifier smart contract library. It uses Iden3's Circom ZK circuits and the Baby Jubjub elliptic curve for efficient proofs.

• Issuer Flexibility: Enterprises or DAOs can become issuers of verifiable credentials.
• Chain-Agnostic Proofs: Verification is cheap and portable, though initially deployed on Polygon.
• ~2-3 Second Proof Generation: Usable for real-world, interactive dApps.

These projects tackle the hardest part: initial credential issuance at global scale with Sybil-resistance.

• Worldcoin: Uses biometric hardware (Orb) to issue a global proof-of-personhood credential. The privacy argument hinges on ZK proofs of iris code uniqueness, not storing the biometric.
• zkPass: Uses MPC-TLS to let users generate a ZK proof from any HTTPS website data (e.g., a bank login). This turns existing web2 portals into unwitting credential issuers without API integrations.

The final layer is a decentralized network for proof verification and attestation publishing, similar to Chainlink but for privacy.

• P0x Labs (Manta): Building a zkSBT standard and a decentralized prover network to scale verification.
• Sismo: Specializes in ZK Badges—non-transferable attestations derived from aggregated web2/web3 data sources. Enables privacy-preserving reputation and sybil-resistant governance for protocols like Aave and ENS.

Selective disclosure isn't just a privacy feature; it's the key to on-chain credit, compliant DeFi, and enterprise adoption.

• On-Chain Credit: Prove a credit score >700 without revealing your history or SSN. Goldfinch and Maple could underwrite loans without oracles seeing raw data.
• Compliant DeFi: Automated, privacy-preserving KYC/AML checks for permissioned pools.
• The Oracle Shift: Chainlink and Pyth dominate data feeds; this stack creates a new category for verified identity claims, moving from price = $50,000 to claim = is_accredited = true.

Traditional identity verification forces a trade-off: trust a centralized oracle (like Chainlink or a KYC provider) with raw PII, or stay off-chain. This creates a single point of failure and liability.

• Vulnerability: A breach at the oracle leaks 100% of user data.
• Cost: Manual verification processes cost $5-15 per check and take days.
• Friction: Users abandon flows requiring full document uploads.

Platforms like Sismo, zkPass, and Polygon ID enable users to prove attributes (e.g., 'I am over 18', 'I am accredited') without revealing the underlying document or wallet address.

• Selective Disclosure: Prove only the required predicate, not the source data.
• Reusable Attestations: A single credential can be used across dApps, DAOs, and DeFi protocols.
• User Sovereignty: Credentials are stored client-side; no central database to hack.

ZK credentials become a primitive. A proof of 'humanity' from Worldcoin can be combined with a proof of 'credit score > 700' from a verifier to access undercollateralized loans without either party seeing the full profile.

• Network Effects: Each issued credential increases the utility of the entire ecosystem.
• Regulatory Arbitrage: Enables compliance (e.g., Travel Rule, MiCA) without mass surveillance.
• Market Size: Unlocks the ~$1T on-chain RWA and institutional DeFi market.

Current model: applications pull full user data. New model: users push minimal, context-specific proofs. This inverts the security model and aligns with ERC-4337 account abstraction and intent-based architectures.

• Reduced Attack Surface: No central honeypot of user data.
• User Experience: One-click verification across ecosystems, similar to UniswapX's intent flow.
• Developer Leverage: Integrate complex compliance logic with a few lines of code, using verifiers like Verax or EAS.