Verona 백서

Verona

원문

bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 54쪽 중 2쪽

erona network (Previously $XION). Used for staking, governance, and on-chain settlement (denom `uxion`). End users typically experience **gasless** flows when applications sponsor fees via Treasury contracts; see [Treasury contracts](/en/build-on-verona/accounts/getting-started/treasury-contracts). | | **Revenue Share** | Agreements where application or verification revenue can flow back to the protocol. Specific figures should only be published after marketing and legal approval. | # Truth Engine Zero-knowledge verification — verify once, reuse everywhere ### The Truth Engine The **Truth Engine** is Verona's verification stack. It turns internet data into **provable facts**, stores them on the decentralized network the user owns, and lets any authorized agent or service **reuse** them without ever holding the data underneath. **Verify once · Reuse everywhere · Expose nothing.** #### Why verification matters Traditional applications cannot verify external data without trusting a centralized authority or requiring users to hand over sensitive information. Want income for a lease? Upload bank statements. Want reputation from another platform? Share login credentials. Every new app re-verifies; every broker stores another copy. Zero-knowledge verification changes this. Your application receives cryptographic proof that a claim is true without accessing the data behind it. The user cannot fabricate or tamper with the proof. One verification becomes a **durable, user-owned attestation** reusable across the network. This enables applications that were previously impossible or impractical: * Loyalty and reputation portable across platforms without source cooperation * Lending and underwriting on income ranges without exact figures * Enterprise decisions on cryptographically verified records—non-custodial, no document storage * Agent workflows that act on provable facts without becoming data custodians * User-controlled sharing of verified attributes instead of raw exports #### How it works (high level) The flow is consistent across all Truth Engine modules: 1. **User generates proof.** The user's device creates a zero-knowledge proof from a data source (website, email, passport, or mobile app). Raw data stays on the device. 2. **Proof is verified on-chain.** The proof is submitted to the Verona network and verified by the protocol. Valid claims are recorded as attestations bound to the user's Meta Account. 3. **Application or agent reads the attestation.** Your contract, API, or agent runtime queries the attestation and receives a scoped answer—not the underlying record. 4. **Action and settlement.** Based on the verified claim, your logic unlocks access, triggers an agent action, adjusts pricing, issues credentials, or settles on chain. #### The four verification surfaces | Surface | Module | Data source | Example claim | | ------------- | -------------------- | -------------------------- | ----------------------------------------------- | | **Websites** | **zkTLS** | TLS-encrypted web sessions | Uber rating above 4.5, balance in range | | **Email** | **zkEmail** (DKIM) | DKIM-signed email | Payroll notification, purchase receipt | | **Passports** | **zkPassport** | Identity documents | Age or citizenship without copying the document | | **Apps** | **App Attestations** | Mobile app state | Fitness activity, delivery history | Developer integration guides today cover [zkTLS](/en/about-verona/verification-infrastructure/zktls), [zkEmail (DKIM)](/en/about-verona/verification-infrastructure/dkim-module-zkemail), and [App Attestations](/en/about-verona/verification-infrastructure/app-attestations). zkPassport is part of the Truth Engine roadmap; contact the team for early access patterns. #### Developer integration pattern All modules follow the same high-level integration pattern: ``` // Pseudocode: Generic verification flow // 1. Your frontend requests a proof from the user const proofRequest = { module: "zk_tls" | "dkim" | "zk_passport" | "app_attestation", claim: "uber_rating_above_4.5", // Module-specific parameters }; // 2. User generates proof client-side (raw data never leaves their device) const proof = await userGenerateProof(proofRequest); // 3. Proof is submitted and verified on-chain const attestation = await submitProofOnChain(proof); // 4. Your smart contract or agent reads the attestation // query the attestation registry for the user's verified claim // execute logic based on the result ``` Specific integration guides, SDKs, and example contracts: [Build on Verona — Verification](/en/build-on-verona/verification). #### Composability Proofs compose. A user can combine attestations from different surfaces into a rich, verified profile—Uber rating (zkTLS) + income range (zkEmail) + identity attribute (zkPassport) + fitness activity (App Attestation)—with zero sensitive data exposed. Applications require any combination of proofs before granting access or triggering agent logic. That composability powers privacy-preserving underwriting, multi-factor reputation, and cross-platform loyalty on one network. # zkTLS ### Zero-Knowledge Verification for the Web In a world where trust is fragmented across countless platforms, zkTLS gives users and applications the power to verify real-world data from any website — **without ever exposing the underlying information**. zkTLS is a core component of Verona's **Truth Engine**, the verification infrastructure that turns internet data into reusable, provable facts. It enables cryptographic proofs over TLS-encrypted web sessions, allowing users to prove specific claims (e.g., "my Uber rating is above 4.5" or "I have an active premium subscription") while keeping everything else completely private. This isn't about sharing screenshots, logging into third-party services, or trusting centralized oracles. It's about mathematical truth that smart contracts can rely on directly. #### Why zkTLS Matters Traditional verification creates impossible trade-offs: * **Privacy vs Utility**: Users must surrender sensitive data or credentials to prove even simple facts. * **Cooperation vs Innovation**: Building cross-platform features requires partnerships with every data source (Uber, banks, LinkedIn, etc.). * **Centralization vs Trust**: Applications depend on intermediaries that can be manipulated, go offline, or change their policies. zkTLS breaks these constraints entirely. By leveraging the existing TLS infrastructure that secures virtually the entire internet, it lets users generate **provable claims** from any HTTPS website. The result? Applications can make intelligent, trust-based decisions while users retain full control over their data. This unlocks entirely new categories of applications: * Loyalty programs that recognize your status on competitor platforms without their cooperation * Advertising systems that verify real humans and high-value users without invasive tracking * Financial products that assess risk based on real banking data without seeing balances * Marketplaces where reputation travels seamlessly across ecosystems * Data marketplaces where users truly own and monetize their verified attributes The marketing promise is simple: **Build applications that understand their users as deeply as the big tech platforms — but with user consent and cryptographic guarantees.** #### How zkTLS Works The flow is designed to be seamless from the user's perspective: 1. **Claim Selection**: The application (or user) requests a specific verifiable claim, such as "Uber rating ≥ 4.5" or "LinkedIn tenure > 2 years at current role." 2. **Client-Side Proof Generation**: Using the user's authenticated browser session or secure connection to the target website, a zero-knowledge proof is generated **entirely on the user's device**. The raw website data, cookies, or session details never leave the device. 3. **On-Chain Verification**: The compact proof is submitted on chain. The protocol verifies it cryptographically and mints an on-chain **attestation** — a permanent, queryable record bound to the user's Meta Account. 4. **Programmable Action**: Any smart contract or application can read this attestation to trigger logic: unlock rewards, adjust pricing, grant access, personalize experiences, or combine it with other proofs. The entire process happens with Web2-like simplicity thanks to Verona's abstraction layer — users never see gas fees, private keys, or complex network interactions. #### What Can Be Verified with zkTLS Because it works with any TLS-protected website, zkTLS covers an enormous surface area of the internet. Here are some of the most compelling categories: **Identity & Reputation** * Platform ratings and reviews (Uber, Airbnb, DoorDash, Yelp) * Social media metrics and engagement (followers, verification status, influence) * Professional credentials and tenure (LinkedIn, company career pages) * Community standing and forum reputation **Financial Trust Signals** * Bank or investment account balance ranges (without revealing exact figures) * Creditworthiness indicators and spending patterns * Investment portfolio existence or account types * Transaction history patterns (e.g., consistent on-time payments) **Commerce & Loyalty** * Purchase history and spending tiers from major retailers * Subscription status, tier, and renewal patterns * Loyalty program membership and benefits level * Review authorship and feedback credibility **Access & Membership** * Account existence and activity on premium platforms * Geographic or eligibility-based claims from account settings * Age or demographic verification from authenticated services * Membership status for clubs, professional organizations, or exclusive communities The power lies in **selective disclosure** — prove exactly what is needed, nothing more. #### Privacy and Security by Design zkTLS is built on principles that put users first: * **Data stays local**: Raw information from websites never leaves the user's device. * **Selective & Minimal**: Only the requested claim is proven; everything else remains hidden. * **Non-transferable**: Attestations are cryptographically bound to a user's Meta Account. * **Tamper-proof**: Mathematical guarantees prevent fabrication or modification of claims. * **No browsing history exposure**: No cookies, no session data, no behavioral profiling is revealed to applications. This creates a new standard of privacy-preserving verification that respects user sovereignty while delivering the trust signals applications need. #### zkTLS in the Truth Engine zkTLS doesn't work in isolation. It forms one pillar of Verona's comprehensive verification system: * **zkTLS** for web and platform data * **zkEmail (DKIM)** for authenticated email content * **App Attestations** for mobile application state Together, they enable **composable verified profiles**. A user can combine an Uber rating (zkTLS), employment confirmation (DKIM), and fitness milestones (App Attestation) into a rich, privacy-first identity that any application can query with permission. This composability, anchored to Meta Accounts, is what grounds verified intelligence for applications and agents on the network. #### Get Started with zkTLS Ready to build applications that understand real users without invading their privacy? Head to [Build on Verona — Verification](/en/build-on-verona/verification) to explore integration patterns, SDKs, example contracts, and live demos. **The internet is full of valuable signals. zkTLS lets you use them — privately, portably, and programmatically.** # zkEmail ### Verify Email Contents Cryptographically Without Exposing Inbox Data The DKIM Module is one pillar of the **Truth Engine** on the Verona network. It enables zero-knowledge proofs over email contents by leveraging DKIM (DomainKeys Identified Mail) signatures that email providers already attach to outgoing messages. #### How the DKIM Module Works Every major email provider (Gmail, Outlook, Yahoo, corporate email servers) attaches a DKIM signature to outgoing emails. This signature cryptographically proves that the email content has not been modified since it was sent by the originating server. The DKIM Module uses these existing signatures as the basis for zero-knowledge proofs: 1. **Email Selection.** The user selects an email in their inbox that contains the data they want to prove (e.g., a purchase receipt from Amazon, an employment verification from their company, a payment confirmation from a bank). 2. **DKIM Verification.** The module verifies the email's DKIM signature to confirm it is authentic and unmodified. 3. **Selective Disclosure.** The user specifies which fields or claims to prove from the email. Only those specific data points are included in the proof. 4. **ZK Proof Generation.** A zero-knowledge proof is generated that attests to the selected claims while revealing nothing else from the email. 5. **On-Chain Verification.** The proof is submitted on chain and verified. A valid proof creates an on-chain attestation. #### Why DKIM Is Powerful DKIM signatures provide a unique advantage: the cryptographic proof of authenticity comes from the email provider itself, not from the user. This means: * The user cannot forge an email from Amazon, their bank, or their employer, because they do not control the DKIM signing key. * The proof is anchored to an institutional authority (Google, Microsoft, the employer's mail server) without requiring that institution's cooperation or knowledge. * Emails are one of the richest sources of verified data: purchase confirmations, account notifications, salary information, medical records, legal communications, and more. #### What Can Be Verified **Commerce & Transactions** * Purchase receipts from any online retailer * Subscription confirmations and renewal notices * Payment confirmations from banks and payment processors * Shipping and delivery notifications **Employment & Income** * Payroll notifications confirming salary ranges * Employment verification emails * Offer letters and contract confirmations * Performance review notifications **Identity & Credentials** * Account creation confirmations (proving account ownership) * Two-factor authentication emails (proving account access) * Government communications (tax notices, benefit confirmations) * Educational notifications (enrollment, grades, degree completion) **Financial** * Bank transaction alerts (proving spending patterns without exact amounts) * Investment account statements * Credit card approval notifications * Loan approval or pre-qualification confirmations #### Security Model * **DKIM signatures are institutional.** The proof's integrity is anchored to the email provider's signing key, which the user does not control and cannot forge. * **Selective disclosure.** The proof reveals only the specified claim. The rest of the email (sender address, other content, attachments, timestamps) is not exposed. * **No email access required.** Your application never accesses the user's inbox. The proof is generated on the user's device from a locally stored email. * **Tamper detection.** Any modification to the email content invalidates the DKIM signature, making it impossible to create a valid proof from a forged email. # App Attestations ### Verify Mobile Application Data with Cryptographic Proofs App Attestations are a **Truth Engine** module on the Verona network. They enable zero-knowledge verification of data from mobile applications—rideshare ratings, fitness metrics, delivery history, and more—without exposing underlying app credentials or full datasets. #### How App Attestations Work 1. **App Data Access.** The user's mobile device accesses the relevant data from a target application through authenticated API calls or secure enclave access. 2. **Attestation Generation.** The attestation framework creates a cryptographic proof of the specific data point the user wants to verify. This proof is generated in a secure execution environment on the device. 3. **Claim Extraction.** The proof extracts only the specific claim (e.g., "Strava weekly mileage above 20 miles") without including any other app data. 4. **On-Chain Verification.** The attestation is submitted on chain and verified. A valid attestation creates an on-chain record. #### What Can Be Verified **Rideshare & Delivery** * Driver/rider ratings on Uber, Lyft, DoorDash, etc. * Trip count and frequency * Account age and standing * Preferred destinations (category-level, not exact addresses) **Health & Fitness** * Step counts and activity levels from health apps * Workout frequency and type from Peloton, Strava, etc. * Sleep patterns and duration ranges * Calorie tracking adherence **Streaming & Entertainment** * Watch history patterns (genres, frequency) from Netflix, Spotify, etc. * Subscription tier and duration * Listening habits and preferences * Content creation metrics **Finance & Banking** * Banking app balance ranges * Transaction frequency patterns * Investment app usage and account type * Payment app transaction history **Social & Communication** * Messaging app activity levels * Social media engagement metrics * Community membership and participation * Account age and verification status #### Security Model * **Secure execution.** Proofs are generated within the device's secure enclave or trusted execution environment. * **App-authenticated data.** The attestation verifies data from authenticated API sessions, not user-provided screenshots or manually entered values. * **Minimal disclosure.** Only the specific claim is included in the proof. No app credentials, full data sets, or account identifiers are exposed. * **Device binding.** Attestations are bound to the user's device and Meta Account, preventing proof transfer or replay. # How the Network Works Protocol-level abstraction — accounts, gas, payments, and more ### Protocol-Level Abstraction That Makes the Network Invisible > **Note:** This section was previously titled "Generalized Chain Abstraction." The abstraction layer is broader than cross-chain interoperability. It encompasses every functional barrier that prevents mainstream adoption: accounts, signatures, gas, payments, devices, and interoperability. The term "Generalized Abstraction" reflects this full scope. **Verona** is the intelligence-layer brand for this network. Generalized Abstraction is embedded directly in that network's protocol—unlike application-layer solutions that add complexity on top of existing chains. Every application built on the network automatically inherits full abstraction without additional development effort. #### Why Protocol-Level Abstraction Matters Every blockchain interaction today involves friction points that prevent mainstream adoption: * Users must create and manage wallets * Users must acquire native tokens to pay gas fees * Users must understand transaction signing * Users must secure seed phrases * Users must use specific devices or browser extensions * Users must navigate bridging and cross-chain complexity Application-layer solutions can mitigate some of these issues, but they add dependencies, increase attack surface, and create inconsistent experiences across different apps. Verona's underlying network solves this at the protocol level, meaning every application built on Verona automatically inherits full abstraction without additional development effort. #### The Six Abstraction Layers **1. Account Abstraction (Meta Accounts)** Meta Accounts replace traditional crypto wallets with protocol-level smart contract accounts that support modular authentication methods. * Users log in with email, FaceID, passkeys, or social login * No seed phrases, no private key management, no wallet downloads * Accounts are smart contracts with programmable permissions * Session keys enable time-limited access for specific operations
프로젝트로 돌아가기