[Proposal setup] Proposal title

Please provide your proposal title

VeriMeZK | Zero-Knowledge Identity Proof Toolkit

[Proposal Summary] Time

Please specify how many months you expect your project to last

3

[Proposal Summary] Translation Information

Please indicate if your proposal has been auto-translated

Yes

Original Language

en

[Proposal Summary] Problem Statement

What is the problem you want to solve?

Traditional identity verification forces users to share sensitive personal data (passport details, biometrics) with service providers, creating privacy risks and data breach vulnerabilities.

[Proposal Summary] Supporting Documentation

Supporting links

• https://verimezk.org/
,
• https://demo.verimezk.org/
,
• https://docs.verimezk.org/
,
• https://github.com/VeriMeZK

[Proposal Summary] Project Dependencies

Does your project have any dependencies on other organizations, technical or otherwise?

Yes

Describe any dependencies or write 'No dependencies'

Essential libraries: React, Tesseract.js (OCR), OpenCV.js (image processing), face-api.js (biometrics), MeshSDK (Cardano wallets). All MIT/Apache licensed open-source packages.

[Proposal Summary] Project Open Source

Will your project's outputs be fully open source?

Yes

Please provide here more information on the open source status of your project outputs

VeriMeZK will be fully open source under MIT License (OSI-approved). Public repository: https://github.com/VeriMeZK/VeriMeZK. All source code, documentation, and outputs will remain publicly accessible throughout the project lifecycle, allowing use, modification, and sharing.

[Theme Selection] Theme

Please choose the most relevant theme and tag related to the outcomes of your proposal

Identity & Verification

[Campaign Category] Category Questions

What is useful about your DApp within one of the specified industry or enterprise verticals?

Industry Vertical: Financial Services / DeFi Compliance

Usefulness:

• Privacy-preserving KYC for DeFi: Enables age/nationality verification without exposing passport data to third-party servers

• Regulatory compliance: Document validity checks meet AML/KYC requirements while maintaining user privacy

• Client-side processing: All biometric and document data stays in browser (src/utils/passportDetection.ts, src/lib/biometric/utils.ts)

• Zero-knowledge proofs: Verifiable on Midnight blockchain without revealing identity attributes

Technical Implementation:

• API Entrypoints: src/lib/zk/proof.ts::generateZKProof() - generates ZK proofs from MRZ data

• Document Processing: src/utils/passportDetection.ts - MRZ extraction via Tesseract.js OCR

• Biometric Verification: src/utils/faceMatching.ts - face-api.js for liveness detection

• Test Commands: npm run dev (port 3356), npm run build, npm run lint

• Architecture: Browser → Camera Capture → Local MRZ/OCR → Face Match → ZK Proof

Generation → Midnight Transaction

Key Files:

• Core verification flow: src/components/verification/VerificationFlow.tsx

• Proof generation: src/lib/zk/proof.ts

• Document scanning: src/components/scan/PassportWizard.tsx

• Midnight integration: src/lib/midnight/client.ts

What exactly will you build? List the Compact contract(s) and key functions/proofs, the demo UI flow, Lace (Midnight) wallet integration, and your basic test plan.

What exactly will you build?

Compact Contract(s) and Key Functions/Proofs

Contract: IdentityVerification (TypeScript/Compact)

• Function: verifyIdentityProof(proofHash: string, clauses: string[]) -> bool

  • Verifies ZK proof hash on Midnight network

  • Validates proof clauses (age, nationality, document validity)

  • Returns verification status without exposing identity data

• Key Proofs:

  • adult:true - Age >= 18 from DOB

  • country:{code}:true - Nationality verification

  • validity_6m:true - Document valid for 6+ months

  • facial_match:true - Biometric match score >= 0.95

• File: src/lib/zk/proof.ts::generateZKProof() - generates proof from MRZ data + face match

• Midnight Integration: src/lib/midnight/client.ts::initializeMidnightAPI() - connects to Midnight via @midnight-ntwrk/dapp-connector-api

Demo UI Flow

Entrypoint: src/pages/VerificationPage.tsx → src/components/verification/VerificationFlow.tsx

1. Connect Lace Wallet (src/components/wallet/ConnectWallet.tsx)

   • Detects Lace (Midnight) wallet via MeshSDK

   • Stores wallet address in VerificationContext

2. Document Capture (src/components/scan/PassportWizard.tsx)

   • Camera access → MRZ extraction via Tesseract.js (src/utils/passportDetection.ts)

   • OpenCV.js preprocessing (src/utils/imagePreprocessing.ts)

   • Anti-spoofing detection

3. Face Verification (src/components/verification/FaceCaptureStep.tsx → FaceMatchStep.tsx)

   • Face capture → Liveness detection via face-api.js

   • Biometric matching against passport photo

   • Threshold: 70% match required

4. Proof Generation (src/components/proof/ProofGenerator.tsx)

   • Calls generateZKProof() with MRZ + face match

   • Returns proof hash + verified clauses

   • No raw identity data in proof

5. Transaction Submission (src/components/proof/TransactionSigner.tsx)

   • Signs transaction via Lace wallet

   • Submits proof hash to Midnight network

   • Returns transaction hash

Lace (Midnight) Wallet Integration

• Detection: src/hooks/useWalletDetection.ts - checks for Lace wallet

• Connection: src/components/wallet/ConnectWallet.tsx uses @meshsdk/react::CardanoWallet

• Transaction: src/components/proof/TransactionSigner.tsx - MeshJS transaction builder

• Midnight SDK: src/lib/midnight/providers.ts - setupProviders() configures:

  • FetchZkConfigProvider (RPC: VITE_MIDNIGHT_RPC_URL)

  • httpClientProofProvider (proof generation)

  • indexerPublicDataProvider (contract state)

  • levelPrivateStateProvider (local state)

Basic Test Plan

Test Commands:

npm run dev # Start dev server (port 3356)

npm run build # Production build

npm run lint # TypeScript + ESLintTest Scenarios:

1. Wallet Connection: Verify Lace wallet detection and connection flow

2. MRZ Extraction: Test passport scanning with sample MRZ data (tests/mocks/)

3. Face Matching: Verify biometric matching threshold (70%)

4. Proof Generation: Validate ZK proof hash format and clauses

5. Transaction: Test Midnight transaction submission with proof hash

Mock Data: tests/mocks/ contains ICAO-standard MRZ samples for testing without camera

---

Usefulness (Pattern & Necessity)

Clear mapping from problem to data-protection pattern

Problem: Traditional KYC exposes full passport/biometric data to third-party servers, creating privacy risks and data breach vulnerabilities.

Pattern: Selective Disclosure for KYC compliance

• User proves identity attributes (age ≥18, nationality, document validity) without revealing:

  • Full passport number

  • Complete date of birth

  • Biometric face data

  • Personal identification details

• Only verified clauses (adult:true, country:CD:true) are disclosed

• Proof is cryptographically verifiable without exposing underlying data

• Implementation: src/lib/zk/proof.ts generates ZK proofs with selective clause disclosure

Why this requires Midnight + Compact versus a public ledger

Public Ledger Limitations:

• Identity data on public blockchain = permanent exposure risk

• Even hashed data can be correlated and deanonymized

• No selective disclosure - all data or nothing

• Regulatory non-compliance (GDPR, data protection laws)

Midnight + Compact Advantages:

• Confidential computing: Private state on Midnight ensures identity data never appears on-chain

• Selective disclosure: Compact contracts verify only required attributes (age/nationality)

• Regulatory compliance: GDPR-compliant - no personal data stored/transmitted

• Privacy-preserving verification: Proofs verifiable without exposing underlying MRZ/biometric data

• Essential for DeFi KYC: Enables age verification for DeFi protocols without centralized KYC servers

• Implementation: src/lib/midnight/client.ts connects to Midnight network for confidential verification

Novelty relative to existing examples; what new building block it adds

Novel Contributions:

1. Client-side ZK identity verification: First browser-native implementation combining MRZ OCR + biometric + ZK proofs entirely client-side

2. Midnight integration for KYC: First selective disclosure pattern for DeFi compliance on Midnight

3. No backend required: All processing (OCR, face detection, proof generation) in browser via WebAssembly

4. Reusable building block: Library (src/lib/zk/proof.ts, src/utils/passportDetection.ts) can be integrated into any DeFi/DAO app

5. Privacy-first KYC: Enables regulatory compliance without centralized identity servers

New Building Blocks:

• VeriMeZK npm package - drop-in ZK identity verification for dApps

• Compact contract template for selective disclosure verification

• Client-side MRZ extraction pipeline (Tesseract + OpenCV + face-api.js)

• Midnight integration pattern for confidential identity proofs

How will other developers learn from and reuse your repo? Describe repo structure, README contents, docs/tutorials, test instructions, and extension points. Which developer personas benefit, and how will you gauge impact (forks, stars, issues, remixes)?

Key files for reuse:

• src/lib/zk/proof.ts - Drop-in ZK proof generation
• src/utils/passportDetection.ts - MRZ extraction pipeline
• src/lib/midnight/providers.ts - Midnight SDK setup pattern
• src/hooks/useMidnight.ts - Reusable Midnight integration hook

README Contents

Comprehensive documentation:

• Quick Start: 5-step setup with environment config
• API Reference: generateProof() and verifyProof() with TypeScript types
• Use Cases: DeFi KYC, NFT gating, DAO governance, compliance
• Advanced Usage: Custom Halo2 circuits, custom check functions
• Error Handling: Table of errors with solutions
• Browser Compatibility: Version matrix
• Installation: npm/yarn/pnpm commands, Node.js 18+ requirement

Docs/Tutorials

Documentation structure:

• README.md - Main API docs with code examples
• SETUP.md - Step-by-step setup guide with project structure
• CONTRIBUTING.md - Development workflow, commit conventions
• SECURITY.md - Security policy, vulnerability reporting
• env.example - Environment variable template with comments

Tutorial content:

• Custom circuit creation (src/zk/custom-circuit.js template)
• DOM event integration for custom UIs
• Mock data usage (tests/mocks/ for testing without camera)
• Midnight provider configuration

Test Instructions

Test commands:ash

npm run dev # Start dev server (port 3356)

npm run build # Production build verification

npm run lint # TypeScript + ESLint validation

npm test # Jest test suite (80% coverage)Test approach:

• Mock MRZ data from ICAO standards in tests/mocks/
• Camera-free testing via mock data injection
• TypeScript compilation as test (tsc --noEmit)
• Component isolation via React Testing Library

Extension Points

1. Custom Proof Circuits (src/lib/zk/proof.ts)

• Extend generateZKProof() with custom Halo2 circuits
• File: src/zk/custom-circuit.js with buildCircuit() function
• Access claims: claims.name, claims.dob, claims.expiry

2. Custom Check Functions (TypeScript Check type)

• Implement { custom: (claims: Claims) => boolean }
• App-specific verification logic
• Example: Age ranges, document types, custom validity rules

3. Midnight Integration Hooks (src/hooks/useMidnight.ts)

• useMidnightClient() - Reusable Midnight client
• useContractState() - Contract state management
• Extendable provider pattern in src/lib/midnight/providers.ts

4. MRZ Processing Pipeline (src/utils/passportDetection.ts)

• Modular OCR → parsing → validation flow
• Replace Tesseract.js with alternative OCR
• Extend parseMRZAdvanced() for custom document formats

5. UI Components (src/components/verification/)

• Copy entire VerificationFlow.tsx as template
• Individual steps exportable (DocumentCaptureStep, FaceMatchStep)
• DOM events (verimezk:progress, verimezk:result) for custom UIs

Developer Personas and Benefits

1. DApp Developers (DeFi/DAO builders)

• Benefit: Drop-in KYC verification without backend
• Reuse: src/lib/zk/proof.ts + src/hooks/useMidnight.ts
• Integration: 3-line import: import { generateZKProof } from 'verime-zk'
• Use case: Age verification for DeFi protocols, citizenship proof for DAO voting

2. ZK-Curious Developers (learning zero-knowledge)

• Benefit: Complete client-side ZK implementation example
• Learn: MRZ → ZK proof pipeline, selective disclosure pattern
• Study: src/lib/zk/proof.ts shows proof generation flow
• Extension: Custom Halo2 circuits tutorial in README

3. Integrators (existing apps adding identity)

• Benefit: Modular components, no full app rewrite
• Reuse: Individual utils (passportDetection.ts, mrzParser.ts)
• Integration: DOM events for existing UI frameworks
• Flexibility: Use only MRZ extraction OR face verification OR ZK proofs

4. Midnight Developers (blockchain builders)

• Benefit: Reference implementation for Midnight + Compact integration
• Pattern: src/lib/midnight/providers.ts shows SDK setup
• Template: Compact contract verification pattern
• Extension: Custom contract integration via useMidnightClient() hook

Measurable Impact Signals

GitHub metrics:

• Forks: Developers copying repo for DeFi/DAO integration
• Stars: ZK-curious developers bookmarking reference implementation
• Issues: Integration questions, feature requests for new document types
• Remixes: Downstream projects using VeriMeZK in:
  • DeFi protocols (age-gated lending)
  • DAO governance (citizenship verification)
  • NFT platforms (identity-gated minting)
  • Compliance tools (regulatory KYC)

[Your Project and Solution] Solution

Please describe your proposed solution and how it addresses the problem

Your Project and Solution

How do you perceive the problem you are solving?

Traditional identity verification creates a fundamental privacy-security tradeoff: users must expose sensitive passport and biometric data to third-party servers to prove identity attributes (age, nationality, document validity). This centralized model creates:

• Data breach risks: Centralized KYC servers are high-value targets (Equifax, Experian breaches)
• Surveillance exposure: Full identity data stored indefinitely by verification providers
• Regulatory non-compliance: GDPR violations from unnecessary data collection
• DeFi adoption barrier: No privacy-preserving KYC solution for decentralized protocols
• User trust erosion: Users forced to choose between access and privacy

The core problem: Identity verification requires sharing more data than necessary. Users need to prove "I am 18+" or "I am from Country X" but must reveal full passport numbers, complete DOB, and biometric face data.

What are your reasons for approaching it in the way that you have?

Client-side processing + Zero-knowledge proofs + Midnight blockchain addresses the problem at its root:

1. Browser-native architecture (src/utils/passportDetection.ts, src/lib/biometric/utils.ts)

• All MRZ extraction, OCR, and face verification happens in browser via WebAssembly
• No backend servers = no data breach surface
• User's device is the only system that sees raw identity data
• Reason: Eliminates centralized data collection entirely

2. Zero-knowledge selective disclosure (src/lib/zk/proof.ts)

• Users generate cryptographic proofs proving identity attributes without revealing underlying data
• Verifier learns only required clauses (adult:true, country:CD:true)
• Full passport number, DOB, biometrics never exposed
• Reason: Cryptographic guarantee of privacy - mathematically impossible to extract raw data from proof

3. Midnight blockchain integration (src/lib/midnight/client.ts, src/lib/midnight/providers.ts)

• Proofs verifiable on Midnight's confidential computing network
• Private state ensures identity data never appears on-chain
• Selective disclosure pattern via Compact contracts
• Reason: Public ledgers expose even hashed data; Midnight's confidential computing provides additional privacy layer beyond ZK proofs alone

4. Modular, reusable library (exportable src/lib/zk/proof.ts, src/utils/passportDetection.ts)

• Drop-in integration for DeFi/DAO apps
• No vendor lock-in, no API keys, no per-verification fees
• Reason: Enable ecosystem adoption - every DeFi protocol can add privacy-preserving KYC without building from scratch

Who will your project engage?

Primary beneficiaries:

1. DeFi Protocol Developers - Age verification for lending/borrowing without centralized KYC servers
2. DAO Builders - Citizenship/nationality proof for governance voting while preserving voter privacy
3. NFT Platform Creators - Identity-gated minting based on verified attributes
4. Compliance Teams - Regulatory KYC compliance (AML, age restrictions) without data storage
5. End Users - Privacy-conscious individuals who want to access DeFi/DAO services without exposing full identity

Engagement approach:

• Open-source library (npm install verime-zk) for immediate integration
• Complete reference implementation showing full verification flow
• Documentation with API examples, custom circuit tutorials
• GitHub community for integration support, feature requests
• Measurable adoption: Forks (integration attempts), Stars (developer awareness), Issues (usage patterns)

What is unique about your solution?

Novel contributions:

1. First browser-native ZK identity verification - Complete MRZ OCR + biometric + ZK proof pipeline entirely client-side (no existing solution combines all three)
2. Midnight integration pattern - Reference implementation for selective disclosure on confidential computing blockchain
3. No backend required - Unlike Worldcoin, Civic, or traditional KYC providers, zero server infrastructure
4. Reusable building block - Not just a demo; exportable library (src/lib/zk/proof.ts) for ecosystem adoption
5. Privacy-first by design - Client-side processing + ZK proofs + Midnight confidential computing = triple-layer privacy

Differentiation from existing solutions:

• vs. Worldcoin: No biometric database, no centralized orbs, fully client-side
• vs. Civic/Onfido: No third-party servers, no data storage, zero-knowledge proofs
• vs. Public blockchain KYC: Midnight confidential computing prevents on-chain data exposure
• vs. Traditional KYC: GDPR-compliant, no data breach risk, user-controlled

Who will benefit?

Direct beneficiaries:

• DeFi users: Access age-restricted protocols without exposing full identity
• DAO participants: Vote in governance with citizenship proof while maintaining privacy
• NFT collectors: Identity-gated drops without revealing personal data
• Developers: Drop-in KYC library without building OCR/biometric/ZK infrastructure

Ecosystem impact:

• Midnight network: Demonstrates practical use case for confidential computing in identity
• Cardano ecosystem: Privacy-preserving compliance solution for regulated DeFi
• Web3 adoption: Removes privacy barrier preventing mainstream DeFi participation

Why this is important to Midnight

Strategic value for Midnight:

1. Demonstrates practical confidential computing - Real-world identity verification use case showing Midnight's privacy advantages over public ledgers
2. Selective disclosure pattern - Reference implementation for Compact contracts verifying identity attributes without exposing data
3. Ecosystem building block - Reusable library enabling other Midnight dApps to add privacy-preserving KYC
4. Regulatory compliance showcase - Proves Midnight can enable GDPR-compliant identity verification for regulated DeFi
5. Developer adoption driver - Attracts DeFi/DAO builders to Midnight by solving critical KYC privacy problem
6. Network effects - Each DeFi protocol integrating VeriMeZK becomes Midnight network participant

Midnight differentiation: Public blockchains cannot host identity verification without exposing data. Midnight's confidential computing + VeriMeZK's ZK proofs = first truly privacy-preserving on-chain identity verification, positioning Midnight as the privacy-first blockchain for regulated DeFi.

[Your Project and Solution] Impact

Please define the positive impact your project will have on Midnight ecosystem

Positive Impact on Midnight Ecosystem

Value to Midnight Ecosystem

1. Practical Confidential Computing Demo - Showcases Midnight's privacy advantages in real-world identity verification

2. Ecosystem Building Block - Reusable library (src/lib/zk/proof.ts) enables other dApps to add privacy-preserving KYC

3. Developer Adoption Driver - Attracts DeFi/DAO builders by solving KYC privacy problem

4. Regulatory Compliance Showcase - Proves GDPR-compliant identity verification for regulated DeFi

5. Compact Contract Pattern - Reference implementation for selective disclosure on Midnight

Impact Measurement

Quantitative: GitHub forks (20+ target), stars (30+), npm downloads (200+), remixes (10+), Midnight network transactions

Qualitative: Developer feedback, integration success stories, use case diversity, ecosystem impact stories

Timeline: Monthly GitHub metrics, weekly npm downloads, quarterly remix count and case studies

Output Sharing

Primary: Public GitHub repo (github.com/VeriMeZK/VeriMeZK), MIT licensed, complete source + docs

Distribution: npm package verime-zk for immediate integration

Documentation: API docs, tutorials, examples, docs.verimezk.org

Community: GitHub Discussions/Issues, contributing guide, responsive support

Education: Blog posts, video tutorials, conference talks, developer workshops

Partnerships: DeFi/DAO integration partnerships, Midnight community collaboration

Reporting: Quarterly impact reports with metrics and case studies

[Your Project and Solution] Capabilities & Feasibility

What is your capability to deliver your project with high levels of trust and accountability? How do you intend to validate if your approach is feasible?

Capabilities & Feasibility

What is your capability to deliver your project with high levels of trust and accountability? How do you intend to validate if your approach is feasible?

Capability to Deliver with High Levels of Trust and Accountability

Existing Capabilities

Uptodate Developers (uptodatedevelopers.com)

• 18+ developers, 5+ years blockchain experience (since 2020), deep Cardano ecosystem expertise

• Specialized in TypeScript, React, WebAssembly, ZK proofs, smart contracts, computer vision

• Proven track record delivering multiple Cardano projects

Live Production Projects

• AdaEx.app – Secure ADA ↔ Mobile Money exchange platform for Africa (operational since 2023, active users)

• DevCommunity.io – Developer community platform with 2,800+ members, 200k+ yearly views, hosting Cardano Developer Advocate Working Group

Professional Standards

• Complete documentation (README.md, CONTRIBUTING.md, SECURITY.md)

• MIT license, conventional commits, semantic versioning

• Security policy with 48-hour response commitment

• Established open-source workflows

Feasibility Validation

Working Prototype

• 200+ TypeScript files with complete verification flow

• Core technologies validated: Tesseract.js (MRZ), OpenCV.js (image processing), face-api.js (biometrics), ZK proofs, Midnight SDK

• Production-ready: Vite build, TypeScript, ESLint, modular architecture

Validation Approach

• Incremental milestones (3 months, 3 milestones)

• CI testing, community feedback, measurable deliverables with acceptance criteria

Fund Management & Trust

Transparent Processes

• Milestone-based funding with clear deliverables and acceptance criteria

• Public GitHub repository (all code visible)

• Regular reporting and community oversight

• No hidden costs

Professional Practices

• Conventional commits, semantic versioning, automated builds

• Security policy (48-hour response)

• Responsive issue resolution

Why Best Suited

• Unique combination: blockchain expertise + ZK cryptography + computer vision

• Full-stack proficiency with proven delivery track record

• Working prototype reduces technical risk

• Established open-source practices with active community engagement

Trust Indicators

1. Public code repository on GitHub (VeriMeZK/VeriMeZK)

2. Live projects: ADAEX (2023), Dev Community IO (2,800+ members)

3. 5+ years blockchain development experience since 2020

4. Functional prototype demonstrates technical feasibility

Commitment

We are committed to delivering VeriMeZK with transparency, accountability, and quality. Our proven track record, experienced team, and working prototype position us to deliver this zero-knowledge identity verification solution for the Midnight ecosystem.

[Final Pitch] Budget & Costs

Please provide a cost breakdown of the proposed work and resources

Cost Breakdown

Overview

Total Project Budget: $10,000 USD

Project Duration: 3 months (12 weeks)

Milestone-Based Funding:

• Milestone 1: $3,000 USD (Month 1)

• Milestone 2: $3,000 USD (Month 2)

• Milestone 3: $4,000 USD (Month 3)

---

Milestone 1: Core Document Processing & MRZ Extraction Foundation

Budget: $3,000 USD

Development Resources

• Project Leader & Blockchain Architect - 40 hours @ $50/hr: System architecture, Midnight SDK planning, core infrastructure ($2,000)

• DevOps Engineer & Full-Stack Architect - 60 hours @ $35/hr: Vite build system, TypeScript architecture, application routing ($2,100)

• Web3 Developer & Computer Vision Specialist - 50 hours @ $40/hr: OpenCV.js preprocessing, Tesseract.js MRZ extraction, ICAO parser ($2,000)

• Full-Stack Web3 Developer & UI/UX Specialist - 40 hours @ $30/hr: Document capture UI, mobile interface, state management ($1,200)

• COO & Security Lead - 30 hours @ $45/hr: Project coordination, security review, quality assurance ($1,350)

Other Costs

• Testing & QA: Cross-browser, mobile, and MRZ accuracy testing - $1,125

• Technology/Infrastructure: Development tools, testing infrastructure - $75

• Documentation: Architecture, API, setup guides - Included in development

Total: $3,000 USD (Development: 60%, Testing: 37.5%, Infrastructure: 2.5%)

---

Milestone 2: Face Verification & Proof Generation

Budget: $3,000 USD

Development Resources

• Web3 Developer & Computer Vision Specialist - 55 hours @ $40/hr: face-api.js integration, face matching, biometric optimization ($2,200)

• Project Leader & Blockchain Architect - 35 hours @ $50/hr: ZK proof framework, proof generation, clause system ($1,750)

• Full-Stack Web3 Developer & UI/UX Specialist - 45 hours @ $30/hr: Face capture UI, summary step, proof progress indicators ($1,350)

• DevOps Engineer & Full-Stack Architect - 25 hours @ $35/hr: Integration, state management, performance optimization ($875)

• COO & Security Lead - 20 hours @ $45/hr: Privacy review, milestone tracking, QA oversight ($900)

Other Costs

• Testing & QA: Biometric accuracy, edge cases, cross-device testing - $825

• Technology/Infrastructure: Face recognition model CDN - $75

• Documentation: Face recognition system, proof API docs - $100

Total: $3,000 USD (Development: 66.7%, Testing: 27.5%, Infrastructure: 2.5%, Documentation: 3.3%)

---

Milestone 3: On-Chain Submission & Final Integration

Budget: $4,000 USD

Development Resources

• Project Leader & Blockchain Architect - 50 hours @ $50/hr: Midnight SDK integration, transaction signing, on-chain verification ($2,500)

• Web3 Developer & Computer Vision Specialist - 30 hours @ $40/hr: Mesh SDK wallet connectivity, Cardano wallet integration ($1,200)

• Full-Stack Web3 Developer & UI/UX Specialist - 50 hours @ $30/hr: Verification dashboard, transaction history, completion flow ($1,500)

• DevOps Engineer & Full-Stack Architect - 40 hours @ $35/hr: End-to-end integration, production build, deployment ($1,400)

• COO & Security Lead - 35 hours @ $45/hr: Final security audit, comprehensive QA, project delivery ($1,575)

Other Costs

• Testing & QA: End-to-end flow, blockchain transactions, security audit - $1,450

• Technology/Infrastructure: Midnight network testing, deployment infrastructure - $50

• Documentation: Final architecture, user guides, API reference - Included in development

Total: $4,000 USD (Development: 62.5%, Testing: 36.25%, Infrastructure: 1.25%)

---

Total Project Budget Summary

| Category | Milestone 1 | Milestone 2 | Milestone 3 | Total |

|----------|-------------|-------------|-------------|-----------|

| Development | $1,800 | $2,000 | $2,500 | $6,300 |

| Testing & QA | $1,125 | $825 | $1,450 | $3,400 |

| Technology/Infrastructure | $75 | $75 | $50 | $200 |

| Documentation | Included | $100 | Included | $100 |

| Total | $3,000 | $3,000 | $4,000 | $10,000 |

---

Cost Justification

Technical Complexity: Integration of OCR, computer vision, blockchain, and ZK proofs requires specialized expertise at competitive market rates.

Quality Standards: Comprehensive testing (63% of total budget) ensures cross-browser, cross-device compatibility and security compliance.

Efficient Resource Allocation:

• Open-source tools (Vite, React, OpenCV.js, Tesseract.js) eliminate licensing costs

• Building on existing VeriMeZK codebase reduces initial development overhead

• Team expertise matches project requirements, minimizing learning curve

Milestone-Based Risk Management: Progressive allocation (M1: $3k, M2: $3k, M3: $4k) reflects increasing complexity and ensures quality at each stage.

---

Fund Management

Transparent Process: All costs itemized per milestone with role-based time tracking and clear justification.

Milestone-Based Disbursement: Funds released upon completion and acceptance of each milestone, ensuring accountability.

Financial Reporting: Quarterly reports detailing expenditure with transparent accounting and public repository showing progress.

[Final Pitch] Value for Money

How does the cost of the project represent value for the Midnight ecosystem?

Value for the Midnight Ecosystem

How does the cost of the project represent value for the Midnight ecosystem?

Foundation for Privacy-Preserving Identity Infrastructure

$10,000 USD for Production-Ready ZK Identity Solution

VeriMeZK provides a complete, open-source, production-ready zero-knowledge identity verification system. Creates reusable building blocks enabling hundreds of downstream applications (identity verification, age checks, nationality verification) while preserving user privacy through ZK proofs.

Ecosystem Impact:

• Complete reference implementation accelerating developer adoption

• Best practices for Midnight SDK integration and ZK proof workflows

• Open-source contribution creating compounding value as community grows

• Cost efficiency: eliminates $5,000-$50,000 annual licensing fees and infrastructure costs

Deliverables: 200+ TypeScript files, complete documentation, security-hardened client-side processing, cross-platform compatibility, comprehensive testing (63% of budget).

---

How does your project represent a good use of funds?

Addresses Critical Privacy Gap in Digital Identity

Problem: Traditional identity verification requires sharing sensitive data, creating privacy risks and breaches.

Solution: Users prove identity attributes (age ≥18, nationality, document validity) without revealing raw data. Client-side verification with only cryptographic proofs submitted to Midnight.

Impact: Enables trustless identity verification for age-restricted services, financial services (KYC), voting, healthcare, and employment.

Demonstrates Midnight's Unique Value

• Confidential Computing Showcase: Privacy-preserving applications with verifiability

• Developer Adoption Catalyst: Working example lowers barrier to entry

• Enterprise Credibility: Production-ready application demonstrates enterprise readiness

• Network Effects: Applications built on VeriMeZK patterns strengthen Midnight ecosystem

Strategic Investment with Measurable Outcomes

Milestone-Based Structure:

• M1 ($3,000): Core document processing foundation

• M2 ($3,000): Face verification and proof generation

• M3 ($4,000): On-chain integration—complete production-ready system

Each milestone delivers independently valuable components with working prototype, experienced team, and comprehensive testing.

Creates Lasting Value

• Immediate: Production-ready identity verification system

• Short-term: Reference implementation, educational resource, commercial foundation

• Long-term: Community-maintained open-source project, ecosystem growth, best practices

---

Value Creation for Midnight Ecosystem

Developer Tooling & Education

Complete reference implementation reduces developer onboarding from months to weeks, accelerating ecosystem growth with ZK proof workflow and Midnight SDK integration patterns.

Use Case Expansion

Modular architecture enables age verification, citizenship verification, document validity, and biometric matching—opening market segments in financial services, healthcare, e-commerce, voting, and employment.

Network Effects & Competitive Advantage

Provides proof of concept, performance validation, developer confidence, and enterprise credibility—demonstrating Midnight's confidential computing capability and strengthening network effect.

---

Conclusion

VeriMeZK represents exceptional value because it:

1. Solves critical privacy gap in digital identity

2. Demonstrates Midnight's practical utility for confidential computing

3. Accelerates developer adoption through lower barrier to entry

4. Creates multipliers through open-source foundation enabling unlimited downstream applications

5. Builds credibility with production-ready application demonstrating enterprise readiness

The $10,000 USD investment creates infrastructure worth far more through developer time savings, accelerated application development, network effects, and long-term community maintenance.

We're building infrastructure that enables hundreds of other projects and accelerates Midnight's growth as the premier confidential computing platform.

[Self-Assessment] Self-Assessment Checklist

I confirm that the proposal clearly provides a basic prototype reference application for one of the areas of interest.

Yes

I confirm that the proposal clearly defines which part of the developer journey it improves and how it makes building on Midnight easier and more productive.

Yes

I confirm that the proposal explicitly states the chosen permissive open-source license (e.g., MIT, Apache 2.0) and commits to a public code repository.

Yes

I confirm that the team provides evidence of their technical ability and experience in creating developer tools or high-quality technical content (e.g., GitHub, portfolio).

Yes

I confirm that a plan for creating and maintaining clear, comprehensive documentation is a core part of the proposal's scope.

Yes

I confirm that the budget and timeline (3 months) are realistic for delivering the proposed tool or resource.

Yes

[Required Acknowledgements] Consent & Confirmation

I Agree

Yes