[Proposal setup] Proposal title

Please provide your proposal title

Private Meritocratic DAO Voting Framework

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

Token-based governance fails by prioritizing capital over expertise (plutocracy). Merit-based voting requires secure, private proof of qualifications (VCs), impossible without programmable privacy.

[Proposal Summary] Project Dependencies

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

No

Describe any dependencies or write 'No dependencies'

No 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

open source (Apache 2.0)

[Theme Selection] Theme

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

Governance

[Campaign Category] Category Questions

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

The Merito Compact DApp delivers essential utility within the Decentralized Finance (DeFi) and Governance vertical, specifically for DAO Treasury and Risk Management. It addresses the critical need to shift decision-making from token-weight to expertise-weight, securely and privately.

Utility in DeFi/DAO Governance

The primary utility of Merito is the implementation of Privacy-Preserving Meritocracy for high-stakes governance decisions.

Core Problem Solved in DeFi

• Plutocracy and Risk: Current DeFi DAOs rely on token-weighted voting, allowing "whales" to vote on complex treasury withdrawal or collateral ratio changes without proving they possess any relevant financial, legal, or architectural expertise. This introduces systemic risk.

• Merito Solution: Merito uses Midnight's Private State to enable the creation of Expert-Only Voting Committees where eligibility is based on verifiable credentials, not coin count, thus increasing decision quality and reducing systemic risk.

Technical Utility and Output

• Expert Gatekeeping: The DApp allows a DAO to define a strict, privacy-enhanced prerequisite for voting on critical actions.

  • Example Governance Category: DAO-Treasury-Withdrawal

  • Required VCs (Example): Proof of a Master's Degree in Financial Engineering (off-chain VC) AND Proof of a Cardano DRep Badge (on-chain VC).

• Verifiable Expertise (Zero-Knowledge Proofs): The voter generates a ZKP proving they meet all criteria without revealing their name, specific degree, or wallet balance. They only prove the result: "I am eligible, and my vote weight is 2x."

Concrete Developer Outputs

The utility is provided as a reusable technical framework, not a final user product.

• Meritocratic Weighting Compact Contract Entrypoint:

compact_contract::vote_weight_engine::verify_and_calculate(proof_input: ZKProof, category_id: u64) -> Result

• Reusable TypeScript SDK Component:

merito_sdk.proof.generateMeritProof(userCredentials: Array, publicFormula: string) -> Promise

• Test Command for Integration:

npm run test:sdk -- --module=proofgen (Tests the successful generation of a ZKP given simulated VC inputs).

Architecture

The core mechanism is shown below:

1. Private State: User's VCs and Identity Linkage are stored locally.
2. Local Computation: The TypeScript SDK runs the ZK circuit, taking VCs and the DAO's public formula as input.
3. Output: A ZKP is generated and sent to the Compact Contract.
4. Public Verification: The Compact Contract verifies the ZKP and updates the DAO vote tally without ever seeing the private VC data.

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.

The Merito Compact DApp is necessary to advance governance beyond token-weighting by providing a set of indispensable data-protection patterns that are impossible on public-by-default blockchains.

Data Protection Pattern & Mapping

• Problem: Plutocracy/Poor Decisions (Expertise is not verifiable).
  • Pattern: Selective Disclosure (SD) for Merit and Expertise. The DApp privately calculates the user's vote weight based on their VCs and only discloses the final, verifiable weight ($W$) and the proof of eligibility.
• Problem: Sybil Attacks (1 user controlling many votes).
  • Pattern: Private Identity Linking for Sybil Resistance. The DApp uses the Private State to store the cryptographic linkage between a user's DIDs and a single verified real-world identity, ensuring only one vote is cast per person.

Necessity of Midnight + Compact

1. Private State: Required to securely store the sensitive DID-to-Identity linkage hash (Sybil proof) and the user's raw Verifiable Credentials (VCs). This private storage is critical to avoid exposing real-world identity.
2. Compact Language / ZKPs: Required to execute the Meritocratic Weighting Formula over the private VCs. This verifiable computation on private data cannot be achieved on public ledgers without exposing the VCs.

What Exactly We Build

We will build the Merito Compact DApp, a focused Proof-of-Concept (PoC) comprising the core contract, a reusable SDK, and a demonstration UI.

1. Compact Contract(s) and Key Functions

We will implement a single, core Compact Contract for maximum efficiency.

• Contract Name: MeritoWeightingEngine.compact
• Key Public Function:

verify_and_cast_vote(proof_input: ZKProof, proposal_id: u64) -> Result

- **Purpose**: Takes the ZK proof generated locally by the user. Verifies the proof's integrity and its assertions regarding unique identity and weighted score ($W$). If verified, the DAO contract is updated with the final weighted vote of $W$.

• Underlying Proof Assertions: The contract verifies the ZKP proves the following three assertions are TRUE simultaneously:
  • Proof of unique identity (Sybil resistance).
  • Proof of possessing all required VCs for proposal_id.
  • Proof that the calculated weight ($W$) matches the public Meritocratic Formula.

2. Demo UI Flow & Wallet Integration

The user interface will be a browser-based PoC built with TypeScript/React, demonstrating the end-to-end privacy-preserving flow.

• Lace (Midnight) Wallet Integration: Used for initial DID connection and to trigger the final transaction signing required to submit the ZK proof and the final vote to the public ledger.
• Demo UI Flow:
  1. Identity Linkage (Private State): User inputs 2FA code; the UI executes the private identity linking and stores the cryptographic hash locally (in the simulated Private State).
  2. VC Upload: User uploads their local VC files.
  3. Proof Generation: User selects a proposal. The SDK internally runs the ZK circuit using the VCs and the linked identity hash. The UI displays the calculated, non-public weighted score (W).
  4. Vote Submission: User clicks "Vote." The DApp sends the final ZK proof to the verify_and_cast_vote entrypoint on the Compact Contract for verification.

3. Basic Test Plan

The basic test plan focuses on the two critical components where correctness is paramount:

• Compact Contract Tests (TS/Compact):
  • Focus: Testing the verify_and_cast_vote function with both valid and invalid mock ZK proofs to ensure the contract correctly accepts proofs that pass all three assertions (Identity, VCs, and Calculation) and rejects those that fail even one.
• TypeScript SDK Tests (TypeScript):
  • Test Command: npm test -- --suite=proof_generation
  • Focus: Testing the reliability of the ZK proof generation module. Specifically, ensuring that given a fixed set of VCs, the function always produces a valid, reproducible proof and the correct calculated weighted score ($W$), and throws errors when required VCs are missing.

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

The Merito Compact DApp is designed as a code-first, privacy-enhancing reference implementation specifically engineered to accelerate development on Midnight by providing essential, reusable building blocks.

1. Developer Value and Personas

The Merito project directly benefits key developer personas by solving complex privacy challenges and offering functional tooling.

• Identified Developer Personas:

  • DApp Developers (The Builders): Need functional SDKs to build applications without becoming ZK experts.
    • Value: Merito provides the TypeScript SDK and clear API for easily incorporating private identity checks and weighted scoring into any DApp (e.g., a restricted forum, a KYC-gated market).
  • ZK Integrators (The ZK-Curious): Seek practical, real-world examples of ZK circuits integrated with the Compact language.
    • Value: Merito's Compact Contract is a working template for verifiable computation over multiple private inputs (VCs + Identity Hash).
  • Governance Architects (The Visionaries): Need proven patterns for advanced DAO mechanics.
    • Value: Merito provides the complete architectural blueprint for implementing Sybil-resistant, merit-based voting on a privacy-first ledger.

• Attraction and Measurable Signals:

  • Clarity and Reusability: The modular design of the SDK and Compact Contract will attract new builders by simplifying complex privacy concepts.
  • Measurable Signals: Success is measured by observable developer interest in the outputs:
    • Forks & Stars: High volume indicates relevance and foundational utility.
    • Issues & PRs: Active developer engagement demonstrates the code's integrability and real-world use.
    • Downstream Examples: Mentions in community forums of projects utilizing the Merito SDK (e.g., for private whitelisting) confirms reusability.

2. Repository Reuse and Learning

The repository structure and documentation are meticulously designed to ensure immediate utility and learning opportunities for the community.

• Repository Structure (merito-dao-poc/):

  • compact/: Contains the MeritoWeightingEngine.compact source files and Rust test suite.
  • sdk-ts/: Contains the reusable TypeScript SDK source files for ZKP generation and utility functions.
  • ui-poc/: Contains the minimal PoC demonstration front-end code.
  • docs/: Contains tutorials and architectural diagrams.

• README Contents (The First Entrypoint):

  • Architectural Overview: Simple diagram showing the data flow from Private State to the Compact Contract.
  • Prerequisites and Setup: Clear instructions for installing Rust/Compact toolchains and Node.js.
  • "Quick Start" Guide: Instructions for running the full end-to-end PoC flow using mocked data.

• Docs/Tutorials (Deep Dive Learning):

  • Tutorial 1: "Implementing the Private Identity Linkage Pattern" (Focus on the 2FA/Private State logic).
  • Tutorial 2: "Integrating the TypeScript SDK for Private Credential Proving."
  • Developer Guide: Detailed documentation for the SDK API methods and object structures.

• Test Instructions (Verification and Extension):

  • Compact Contract Verification: Instructions to run verification tests: cargo test -- package merito_contract
  • SDK Verification: Instructions to run SDK unit tests: npm test --suite=proof_generation
  • Extension Points: Developers are encouraged to modify the governance logic. Test Plan Goal: Ensure that any modification to the Compact Contract's Meritocratic Formula breaks existing tests, forcing the developer to update the corresponding ZK circuit assertions.

3. Extension Points (How to Rebuild)

The project is architected for maximum modularity and reusability:

• Compact Contract: The governance logic in MeritoWeightingEngine.compact is defined as a highly abstract, parameterized function, allowing developers to copy and easily change the Meritocratic Formula for new DAO types.
• TypeScript SDK: The SDK provides clear entrypoints for replacing the identity-linking logic with other SSI/DID solutions, making the generateMeritProof API flexible for future integration.
• Proof Assertions: The ZK circuit design is broken down into separate assertions (e.g., proof_is_unique_id, proof_has_required_vc), allowing ZK-curious developers to easily add or remove custom data constraints.

[Your Project and Solution] Solution

Please describe your proposed solution and how it addresses the problem

The Merito Compact DApp is an open-source Reference DApp designed to solve the critical challenges of plutocracy and Sybil attacks in decentralized governance. It provides a foundational framework for implementing merit-based (shāyesteh-sālārī) voting, where a voter's influence is weighted not by token balance, but by their privately verifiable expertise, qualifications, and unique identity.

Merito operates entirely on the Midnight Blockchain, leveraging its core architecture specifically the Private State and the Compact Contract language to enable verifiable computation over private data.

1. The Core Innovation: Computation Over Private State

The primary technical innovation of Merito is the secure and private execution of three critical tasks that are impossible on a public blockchain:

1. Unique Identity Verification: Linking a real-world identity (via 2FA/National ID) to multiple Decentralized Identifiers (DIDs) or wallets, and storing this linkage privately to achieve Sybil resistance.
2. Verifiable Credential (VC) Possession Proof: Running the governance logic (the Meritocratic Weighting Formula) over the user's private, locally stored VCs. 3. Selective Disclosure of Vote Weight: Generating a Zero-Knowledge Proof (ZKP) that proves eligibility and vote weight without disclosing the actual credentials or private identity link used in the calculation.

2. Technical Components of the Merito DApp

The Merito framework is composed of three interconnected components:

1-

• Component: Local User Interface (UI) and Storage
• Function: Manages the user's locally stored Verifiable Credentials (VCs). Handles the cryptographic 2FA identity linking process. Calculates the vote weight using the private local data and the public formula.
• Midnight Feature Used: Local Storage, Midnight Lace Wallet Integration, Off-chain Proof Generation

2-

• Component: Meritocratic Compact Contract (Weighting Engine)
• Function: Defines the core governance logic, including the required VC metadata for each governance category and the Meritocratic Weighting Formula. This contract is publicly auditable but executed over the user's private inputs.
• Midnight Feature Used: Compact Language, Public State (for formula/metadata definition)

3-

• Component: Private State Proof Generator
• Function: The most critical component. It takes the VC inputs, the unique identity proof, and the publicly defined formula, and generates a zero-knowledge proof that satisfies the required criteria.
• Midnight Feature Used: Private State, ZK-Proof Circuitry

3. Detailed Technical Flow: The Private Voting Process

The DApp flow is designed to ensure the user's private data never leaves their local machine and is only ever attested to by a ZK-proof generated within the Private State environment.

A. Private Identity Verification (Sybil Resistance)

1. Registration: A new user connects their Midnight Lace Wallet. They initiate a Private Identity Verification step.
2. 2FA/National ID Attestation: The user inputs their national ID/phone number. A time-sensitive code is sent to the phone number on file for that ID. This proves temporary control over a real-world identity.
3. DID Linkage: The DApp uses the result of this 2FA step to create a cryptographic hash linking the user's current DID to this validated real-world identity. This hash and the underlying proof data are stored exclusively in the Private State.
4. Sybil Check: Any subsequent DIDs used by the same person must pass the same 2FA step, confirming they belong to the same underlying identity. The DApp logic can then ensure that only one vote is cast per real-world identity, regardless of the number of DIDs they control.

B. VC Management and Governance Metadata Retrieval

1. VC Upload: The user uploads their VCs (e.g., University Degree, Cardano DRep Badge, Passport ID data) to their local, encrypted storage via the UI.
2. Metadata Retrieval: When the user accesses a DAO governance system integrated with Merito, the DApp fetches the metadata for the proposal's category (e.g., Treasury Management). This metadata contains:
   • List of Required VCs (e.g., VC: Finance Degree, VC: Financial Decision Making Badge).
   • The Meritocratic Weighting Formula for that category
   • (e.g., VoteWeight = (BaseWeight * DRepMultiplier) + (FinanceVCMultiplier)).

C. ZK Proof Generation and Voting (Selective Disclosure)

1. Local Calculation: The Merito DApp locally runs the Compact Contract's logic against the VCs stored in the user's Private State. The result is two-fold:
   • Boolean Check: Is this individual eligible to vote in this category? (Yes/No)
   • Vote Weight Calculation: What is their final weighted vote value, W?
2. Proof Generation: The DApp generates a Zero-Knowledge Proof (ZKP) that asserts:
   • "I am a unique, verified-identity (anti-Sybil)";
   • "I possess the VCs required by the public formula";
   • "My resulting calculated vote weight is W";
3. Public Vote: The ZKP and the final weighted vote value (W) are submitted to the DAO's public smart contract. The public contract verifies the ZKP, proving the voter's credentials and eligibility without ever seeing their personal data, national ID, or specific VCs.

4. How Merito Addresses the Problem

1-

• Problem Addressed: Plutocracy (Token-Weighted Failure)
• Solution Implemented by Merito: Replaces token-weighting with a merit-based formula defined in a public, auditable Compact Contract, prioritizing verifiable expertise over capital.
• Midnight Technology Essentiality: Compact Language allows complex, audited merit formulas to be executed privately.

2-

• Problem Addressed: Sybil Attacks (1 User = 100 Votes)
• Solution Implemented by Merito: Implements a Private Identity Linkage system (2FA) to cryptographically ensure that multiple DIDs are collapsed into a single, real-world identity for voting purposes.
• Midnight Technology Essentiality: Private State is the only place to store the sensitive DID-to-ID linkage hash securely, enabling Sybil checks without exposing real-world identity.

3-

• Problem Addressed: Privacy Compromise
• Solution Implemented by Merito: Uses Zero-Knowledge Proofs to prove eligibility and vote weight. The voter only discloses the final calculated weight and a proof of possession, achieving Selective Disclosure.
• Midnight Technology Essentiality: ZK-Proof Circuitry within the DApp ensures that the personal VCs and identity proofs remain permanently on the user's private machine.

5. Reusable Outputs and Developer Experience

In line with the Project Catalyst requirement for reusable tooling, Merito will deliver highly valuable open-source components:

• TypeScript SDK for Private Credential Management: A library providing a standard interface for loading, querying, and submitting locally stored VCs to the ZK-Proof generation engine. This will be immediately useful for any developer building a private-data-dependent Compact DApp.
• Reference Compact Contract: A fully documented Compact contract containing the logic for VC parsing and the Meritocratic Weighting Engine. This serves as the blueprint for how others can define and execute complex governance rules on Midnight.
• Sybil-Resistance Pattern: The specific cryptographic design for the 2FA-based, Private State identity linkage provides a crucial, reusable pattern for any Midnight DApp requiring proof of unique user identity (e.g., private air-drops, restricted service access).

Merito thus serves not only as a functional governance tool but as a crucial Reference DApp that elevates the entire ecosystem by demonstrating how programmable privacy unlocks the next generation of decentralized, equitable, and expert-driven governance systems.

[Your Project and Solution] Impact

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

Value to the Midnight Ecosystem

The success of the Merito Compact DApp will bring significant value to the Midnight ecosystem by establishing a foundational and reusable solution for governance that is technically impossible on public-by-default blockchains.

• Enabling New Primitives: Merito unlocks the ability to build truly meritocratic and Sybil-resistant DAOs. This capability is a fundamental primitive necessary to attract high-value decentralized applications (DApps) and institutions that require auditable expertise or identity checks without compromising user privacy (e.g., decentralized lending protocols, certified expert committees, or confidential voting systems).
• Reference Architecture for Privacy: The DApp serves as a high-fidelity Reference Architecture for complex data privacy patterns. It specifically demonstrates the critical flow of:

1. Securely linking real-world data (2FA/National ID) to on-chain identity in the Private State.
2. Executing verifiable computation (the Meritocratic Weighting Formula) over this private data using the Compact Language.
3. Generating Zero-Knowledge Proofs (ZKPs) for Selective Disclosure.

• Enhancing Developer Experience (DX): By providing a reusable, open-source TypeScript SDK component for private identity and VC proof generation, Merito lowers the barrier to entry for other developers building solutions that require unique identity or credential verification on Midnight.

Impact Measurement

Focus of the impact measurement shift to early validation and foundational developer interest rather than long-term adoption metrics.

Key Impact Goals

The successful completion of the Merito Compact DApp within three months will be measured by its technical quality, its utility as a Reference DApp, and the immediate interest it generates within the developer community.

• Technical Success & Quality:
  • Full Compact Contract Deployment: Successful deployment and continuous availability of the Meritocratic Weighting Compact Contract on the Midnight Testnet by the end of Month 3.
  • End-to-End Proof Generation: Successful execution of the full private voting flow (DID linking $\rightarrow$ VC proving $\rightarrow$ ZKP generation $\rightarrow$ public contract verification) in the Proof-of-Concept (PoC) DApp.
  • Code Review Quality: Achieving a positive rating in a final technical code review (internal or external) confirming adherence to best practices for ZK-proof circuitry and Midnight's Compact language.
• Developer Experience (DX) & Tooling Reusability:
  • GitHub Engagement: The GitHub repository for the DApp and the reusable TypeScript SDK achieves at least 10 stars by the end of Month 3, demonstrating foundational developer interest.
  • Documentation Completion: Publishing complete and auditable documentation, including tutorials for integrating the ZK/VC proving SDK, by the end of Month 3.
• Ecosystem Engagement:
  • Unique Tester Wallets: Recording over 5 unique testnet wallet interactions with the Merito PoC UI, demonstrating community validation of the DApp's functionality.
  • Community Feedback: Successful submission of the DApp's code and documentation to the Midnight Foundation's developer channels for direct technical feedback and future funding consideration.

Outputs and Opportunities

The outputs of this project will be shared proactively and transparently to maximize utility for the entire Midnight developer community and ecosystem partners.

• Open Source & Licensing:

All final code, including the Merito Compact Contract and the TypeScript SDK, will be immediately pushed to a dedicated GitHub repository under the Apache 2.0 License. This ensures maximum reusability and commercial adoption potential.

• Documentation and Tutorials:

We will publish a detailed technical tutorials and blog posts explaining the implementation of the core privacy patterns:

• How to build a ZK circuit for VC verification.

• The mechanism for Private State Sybil-Resistance (DID-to-ID linking).

• Integrating the Merito SDK into a third-party DAO front-end.

• Workshops and Engagement:

We will offer at least one live technical presentation or workshop focused on using the Merito framework. This will be shared with the Midnight Foundation for promotion to their community channels.

Active participation in the Midnight Discord/Forum to provide direct support, answer questions, and solicit feedback on the Merito codebase.

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

Our team is uniquely suited to deliver a governance-focused Reference DApp due to our ongoing and self-funded commitment to solving real-world governance challenges:

• Active CIP-1694 Development: We are actively developing and iterating on GovCircle, a decentralized governance solution based on CIP-1694. This work involves combining mechanisms from Cardano, Polkadot OpenGov, and Ethereum DAOs to refine decentralized decision-making.
• Contextual Understanding: As an active DRep and participant in governance, Omid possesses an intimate understanding of the shortcomings (plutocracy, Sybil attacks) that Merito is designed to solve. This ensures the output is not merely a technical exercise but a pragmatic, useful tool for future DAOs.
• Technical Readiness: The existing software architecture expertise (Omid) combined with core development strength (Sadegh) provides the agility needed to tackle the project's complex requirements, especially the integration of the ZK-proof generation logic and the reusable TypeScript tooling.

Fund Management and Accountability

We understand that trust and transparency in financial management are paramount for Project Catalyst. While this is our first funded Catalyst proposal, we commit to delivering the project and managing the budget with the highest level of fiduciary responsibility.

Fund Management Process

Our process ensures every dollar of the requested $USDM is accounted for and directly tied to project delivery:

• Transparent Tracking: We will maintain a shared digital spreadsheet accessible to the team. This ledger will track the hourly burn rate of developer time and maintain clear records, including linked receipts for any external costs (e.g., necessary infrastructure or auditing services).
• Zero-Based Budgeting: Funds will be allocated directly toward the three planned milestones (M1, M2, M3), primarily covering the compensation for the two developers for their specialized architectural, ZK, and engineering work over the three-month period.

Milestone Verification for Trust

Funding will be released strictly upon the verifiable completion of each of the three defined milestones, providing the community and the Midnight Foundation with clear, auditable proof of work.

• Public Proof of Work: For each requested funding tranche, we will provide a public submission package that includes:
  • GitHub Commits: Direct links to the relevant, verified code commits on the public repository.
  • Demo Video: A clear, concise video demonstrating the functionality achieved in that milestone (e.g., M1: the functional private identity linkage UI; M2: the ZK proof generation process).
  • Written Report: A formal report, signed off by both team members, detailing the work completed, any challenges encountered, and a brief plan for the subsequent milestone.

This rigorous process ensures the requested funds are disbursed only in exchange for tangible, fully completed, open-source deliverables.

[Final Pitch] Budget & Costs

Please provide a cost breakdown of the proposed work and resources

The $9,000 USDM budget is precisely calculated to cover the full-time dedication of both the Software Architect and the Software Engineer for three months, ensuring rapid and focused delivery of the high-complexity Compact DApp.

• Total Requested Budget: $9,000 USDM
• Personnel Cost Structure: The entire budget covers personnel cost for two full-time specialists:
  • Cost per Person per Month: $1,500 USDM
  • Total Monthly Cost (Team): $3,000 USDM (2 people @ $1,500 USDM each)
• Time Commitment: The cost directly corresponds to 3 months of full-time work necessary to deliver the Merito Compact DApp, ensuring high velocity and minimal scope creep.
• Eligible Costs: 100% of the funds are allocated to essential personnel costs, which are fully eligible under the Project Catalyst Fund Rules.

Cost Breakdown by Milestone (Equal Distribution)

Funding is distributed equally across the three milestones, with each payment covering the monthly cost of the two full-time team members.

1. M1: Foundation: Core Logic and Identity Linking

Deliverables Focus: Compact Contract V1, Private Identity Prototype, Initial Repo.

Personnel Cost: Covers full-time cost for Omid Ajourlou and Sadegh Ghoroghi.

Cost (USDM): $3,000

Percentage: 33.33%

Progress: 40%

2. M2: Integration: ZK Proofing and SDK Tooling

Deliverables Focus: ZK Proof Module, TypeScript SDK V1, Testnet Deployment.

Personnel Cost: Covers full-time cost for Omid Ajourlou and Sadegh Ghoroghi.

Cost (USDM): $3,000

Percentage: 33.33%

Progress: 80%

3. M3: Final Delivery, Demonstration, and Close-out

Deliverables Focus: Final PoC Video, Complete Testing Suite, Final Documentation, Report.

Personnel Cost: Covers full-time cost for Omid Ajourlou and Sadegh Ghoroghi.

Cost (USDM): $3,000

Percentage: 33.33%

Progress: 100%

Fund Management Summary

• Tracking: Costs will be tracked via the shared spreadsheet, confirming the dedicated full-time work hours contributed by both team members each month.
• Verification: Each $3,000 USDM tranche payment is strictly dependent on the successful completion and public verification of the associated milestone's Evidence of Completion (commits, demo video, report).
• Total Project Cost: $9,000 USDM (3 months * $3,000 USDM/month)

[Final Pitch] Value for Money

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

The Merito Compact DApp represents an exceptionally strong use of funds ($9,000 USDM) because it directly funds the creation of a foundational governance primitive that is technically impossible on public ledgers and provides immediate, reusable tooling for the Midnight developer community.

The project offers maximum utility and high Return on Investment (ROI) by leveraging the unique capabilities of the Midnight architecture to solve a critical, high-value problem in Web3 governance.

High-Value Deliverables Unlocked

The $9,000 USDM budget directly purchases three months of dedicated, specialized labor necessary to deliver these critical assets:

• Unlocking Meritocracy: Merito provides the first auditable, privacy-preserving framework to transition DAOs from token-weighted plutocracy to merit-based governance. This raises the quality and trustworthiness of decision-making for future Midnight-based protocols and enterprises.

• Essential Reference Architecture: The DApp serves as the essential blueprint for complex privacy patterns, teaching developers how to combine core features:

  • Private Identity Linking: The pattern for Sybil-resistance using the Private State is critical for any unique-user-required service.

  • ZK-Proof Logic: A working, documented example of generating ZK-proofs over multiple private inputs (VCs) and running complex calculations (the Meritocratic Formula) that are verified by a Compact Contract.

• Reusable Tooling: The project's main deliverables are modular and immediately reusable: the open-source TypeScript SDK and the MeritoWeightingEngine Compact Contract. This reduces the future development time and cost for all builders on the Midnight network.

Cost Efficiency Justification

The cost of $9,000 USDM for this project represents an extraordinary value proposition for the Midnight ecosystem, given the complexity of the required ZK/privacy engineering:

• High ROI on Personnel: The budget funds two specialized individuals (Software Architect and Software Engineer) for a full, focused three-month commitment ($3,000 USDM per month). This is an extremely low cost for specialized blockchain engineering talent required to deliver a secure, production-grade reference DApp.

• Focused Scope: The tight, 3-month timeline and fixed budget force a high-velocity, code-first PoC approach. Funds are not wasted on marketing, unnecessary features, or long-term operational overhead, but are channeled directly into functional software and reusable code.

• Foundational Investment: By solving a core, foundational problem (governance/identity) with a reusable pattern, the Merito DApp enables dozens of future projects and saves the ecosystem significant collective development time and costs. This single $9,000 investment accelerates the entire Midnight development landscape.

[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