Proof of Life – Liveliness on Midnight.

[Proposal setup] Proposal title

Please provide your proposal title

Proof of Life – Liveliness on Midnight.

[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

No

Original Language

en

[Proposal Summary] Problem Statement

What is the problem you want to solve?

DAOs and online platforms face growing Sybil and bot abuse. Existing “proof of human” tools rely on centralized or opaque systems. Midnight lacks an example of identity with client-side liveness +ZKPs

[Proposal Summary] Project Dependencies

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

Yes

Describe any dependencies or write 'No dependencies'

Technical components (all open-source): Midnight stack (Compact contracts, TestNet, Lace wallet) React/TypeScript frontend face-api.js for liveness Small Node.js service for signature verification No centralized biometric or proprietary hardware dependencies.

[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

MIT

[Theme Selection] Theme

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

Authentication

[Campaign Category] Category Questions

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

Primary vertical: Governance (with applications to social & DAO systems).

Proof of Life provides a reusable pattern for Sybil-resistant governance:

• Civic / Community Governance: Municipal pilots, cooperatives, and associations can use Proof of Life’s pattern to enforce one-person-one-vote without exposing citizens’ biometric data to a central authority.

• DAO / Protocol Governance: DAOs can integrate proof-of-liveliness layer to mitigate multi-wallet Sybil attacks while keeping member identities private.

• Enterprise & Boards: Private organizations can run board or shareholder votes where participants are verifiably human and unique, but their biometric data never leaves their device.

By open-sourcing the full stack, the DApp becomes a reference template for any governance or access-control scenario that needs “unique humans, strong privacy, and verifiable proofs” on Midnight.

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.

We will build a single reference system composed of:

Compact Contract(s)

humanness.compact

Key responsibilities:

• Proposal management

  • Create proposals with metadata, proposer, and deadline

  • Track votes_for, votes_against, and execution status

• Credential-based voting

  • Verify a Schnorr signature over the liveness result from an authority key

  • Accept votes only if:

    • credential is valid,

    • credential has not been used before, and

    • proposal is still ACTIVE (before deadline)

• Anti-double-voting protections

  • Maintain registry of used credentials / identities

  • Prevent replay via nonce tracking

• Commenting

  • Allow verified users to attach comments to proposals (linked to their pseudonymous biometric hash)

  • Keep commenting open after vote close (except for rejected proposals)

Proofs & logic:

• Custom 15-byte protected Schnorr signature verification implemented in Compact (no standard primitive available yet).

• Zero-knowledge style flow where only the necessary proof/credential is revealed, not the raw biometric encoding.

Demo UI Flow (React + Vite)

1. Connect Lace (Midnight) wallet

2. Select/Create Proposal

3. Start “Prove You’re Alive”

   • Enable camera, load face-api models

4. Liveness Detection

   • Detect face

   • Ask user to blink & turn head left/right

   • Validate quality (size, position)

5. Generate Identity Encoding

   • Convert facial descriptor + landmarks into a deterministic identity hash with tolerance-based matching for cross-device consistency

6. Obtain Signed Credential

   • Send non-biometric hash and liveness result to the authority API

   • Receive a Schnorr-signed credential

7. Cast Vote

   • User signs transaction with Lace wallet

   • Submit credential to Compact contract (voteFor / voteAgainst)

8. View Results & Comments

   • Display live proposal status and user comments

Lace (Midnight) Wallet Integration

• Use Lace browser extension on Midnight TestNet for:

  • account connection,

  • transaction signing, and

  • contract interaction for board creation / proposal voting.

Basic Test Plan

Contract tests

• Verify Schnorr signature verification for valid/invalid signatures

• Ensure:

  • one credential cannot vote twice,

  • votes after deadline are rejected,

  • proposals change status from ACTIVE → PASSED / REJECTED correctly

• Test comment creation and linkage to proposal & credential

Frontend / API tests

• Unit tests for:

  • faceRecognition.ts (encoding & tolerance matching)

  • livenessDetection.ts (blink + head movement logic)

  • bboard-schnorr.ts authority signer

• Integration tests (manual + scripted):

  • Full “create proposal → prove liveness → cast vote → see results” flow on TestNet

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)?

Repo structure

• contract/ – Compact contract (humannes.compact) + witness generation + contract tests

• bboard-ui/ – React frontend with:

  • components/VotingBoard.tsx – main voting / proposal UI

  • components/SimpleFaceScan.tsx – camera + liveness flow

  • utils/faceRecognition.ts and utils/livenessDetection.ts – reusable biometric utilities

• api/ – Node.js authority service:

  • Schnorr signature implementation

  • Credential issuing endpoint

  • Configurable authority key

README & docs

The README.md will include:

1. Conceptual Overview

   • What “proof of liveliness” is and why privacy matters

   • Where Compact & zero-knowledge fit in

2. Quick Start

   • Requirements (Node, Lace, camera)

   • git clone, npm install, npm run build, npm run dev steps

3. Running the full stack locally

   • Start contract, UI, and authority API

   • Connect Lace wallet and perform a test vote

4. Technical Deep Dive

   • How face recognition and liveness work on the client

   • How identity hashes are generated and matched

   • How Schnorr signatures are verified inside Compact

5. Extension Points

   • Replace facial biometrics with other modalities

   • Swap governance logic (e.g., quadratic voting, weighted votes)

   • Integrate with other Midnight DApps for access control / whitelisting

6. Testing & CI

   • How to run contract and frontend tests

   • Suggested checks before deployment

Developer personas

• Smart contract developers: Learn how to implement Schnorr verification, credential gating, and anti-Sybil patterns in Compact.

• Frontend DApp developers: Copy the React + Lace wallet integration and camera flow as a template for other privacy-preserving DApps.

• Protocol / governance designers: See a practical pattern for one-human-one-vote governance with programmable privacy.

• Security / cryptography enthusiasts: Study a minimal, self-contained Schnorr implementation integrated with a ZK-style flow.

[Your Project and Solution] Solution

Please describe your proposed solution and how it addresses the problem

Proof of Life addresses the “bots vs humans” problem by moving liveness detection to the edge (the user’s device) and combining it with Midnight’s privacy-preserving smart contracts.

• Users prove they are alive and unique through client-side face + liveness checks.

• A minimal identity hash is derived from geometric facial features and descriptors, never revealing the actual face.

• An authority service signs this liveness result with Schnorr signatures, which are verified in a Compact contract.

• The contract then enforces one credential, one vote, recording the vote outcome while hiding biometric details.

This approach eliminates the need for centralized biometric databases or hardware attestation while still giving governance DApps strong protection against Sybil attacks.

[Your Project and Solution] Impact

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

• Reference for privacy-preserving governance: Provides a concrete, runnable example for any team wanting to build voting, polling, allowlists, or “proof of human” flows on Midnight.

• Demonstrates programmable privacy in practice: Shows how zero-knowledge and Compact can be used to separate verification from identity disclosure.

• Developer acceleration: Future builders can fork proof of life instead of re-implementing liveness + Schnorr + governance patterns from scratch.

• Ecosystem reputation: Positions Midnight as a serious platform for responsible AI / biometrics and human-centric governance, showing how advanced cryptography can protect users instead of exploiting them.

[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?

• The project team has prior experience with:

  • building React + TypeScript applications,

  • implementing cryptographic primitives (e.g., Schnorr signatures), and

  • writing and testing Compact / smart contracts.

    (All credentials will be linked via GitHub and LinkedIn in the proposal.)

• Trust & accountability

  • All work is done open-source under MIT from day one in a public repo.

  • Issues, milestones, and progress are tracked transparently in GitHub Projects.

  • We will provide regular updates and demos aligned with Catalyst reporting.

• Feasibility validation

  • A simplified prototype of the architecture already exists (see current Proof of Life repo).

  • Early contract and biometric flows will be tested on Midnight TestNet in Month 1.

  • We will validate:

    • successful end-to-end voting with liveness proofs,

    • robustness of detection across different devices / lighting conditions, and

    • resistance to simple spoofing attempts (recorded video, static photos).

Given the small but focused scope and existing groundwork, a three-month timeline is realistic.

[Final Pitch] Budget & Costs

Please provide a cost breakdown of the proposed work and resources

Total requested: USDM 9,000 (within the 2,500–10,000 prototype range).

• Milestone 1 – Core contract & minimal UI – USDM 3,000

  • 3–4 weeks of part-time engineering (Compact + React)

• Milestone 2 – Biometrics + Schnorr integration – USDM 3,000

  • 4 weeks of engineering on biometric pipeline, authority API, and contract integration

• Milestone 3 – Documentation, tests, packaging – USDM 3,000

  • 3–4 weeks of work on documentation, tests, polish, and release

No hardware purchases or third-party SaaS licenses are required beyond normal developer tooling.

[Final Pitch] Value for Money

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

For a modest prototype budget, the Midnight ecosystem receives:

• A fully open-source reference DApp that can be reused as:

  • a template for governance DApps,

  • a building block for Sybil-resistant access control, and

  • a teaching tool for Compact + zero-knowledge patterns.

• A battle-tested pattern for privacy-preserving liveness that avoids centralized biometric storage and proprietary TEEs.

• A well-documented codebase that lowers the barrier for new builders to experiment with advanced cryptography on Midnight.

Because the deliverable is intentionally small, focused, and MIT-licensed, any future project in governance, DeFi, social, or AI x identity can build on Proof of Life directly—multiplying the impact of this one-time grant across many future DApps.

[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