[Proposal setup] Proposal title
Please provide your proposal title
ECOID: Decentralized SSO Identity Layer Powered by 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?
The global South lacks a unified, secure digital ID. 650M undocumented, 400M unbanked, fragmented systems, $10B lost to fraud. No private, portable SSO—creating a continental trust & access bottleneck
[Proposal Summary] Supporting Documentation
Supporting links
[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
We will release the project under the Apache 2.0 License. This license is enterprise-friendly, permissive, provides strong patent protection, and is widely used in blockchain and ZK identity tooling—ensuring the ECO ID compact dApp can be safely reused, integrated, and extended across the Midnight developer ecosystem.
[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?
Catalyst-Ready Answer: Usefulness of the ECO ID Compact dApp Across Industry & Enterprise Verticals
The ECO ID Compact dApp delivers high-value, sector-wide utility by providing a confidential, decentralized SSO identity layer anchored on Midnight. Its usefulness across key verticals is outlined below:
Fintech & Financial Inclusion
- Enables instant, privacy-preserving KYC powered by decentralized identifiers.
- Reduces fraud and onboarding costs while unlocking financial access for underserved populations.
- Provides a verifiable on-chain identity standard for neobanks, lenders, and mobile money operators.
Government & Public Sector
- Establishes a unified digital identity rail for secure access to e-government services.
- Supports verification for social programs, digital permits, and cross-border AfCFTA processes.
- Ensures compliance and data sovereignty through Midnight’s confidential computation.
ESG, Sustainability & Impact Reporting
- Supplies tamper-proof identity for individuals and organizations participating in ESG and SDG programs.
- Strengthens data integrity for reporting frameworks by ensuring that all actors are verified and authenticated.
- Enables accountability for climate actions, community programs, and sustainability-linked incentives.
SMEs, Informal Trade & Commerce
- Provides portable IDs for informal workers and microenterprises lacking formal documentation.
- Enables trust, traceability, and market access for Africa’s $1T informal economy.
- Supports verifiable business identities for trade, supply chains, and digital marketplaces.
Healthcare & Education
- Allows secure, privacy-controlled access to health records, learning platforms, and digital credentials.
- Streamlines onboarding into hospitals, telehealth services, schools, and online academies.
- Protects sensitive personal data using Midnight’s zero-knowledge privacy model.
Enterprise Security & Compliance
- Establishes a standardized SSO layer that reduces identity fragmentation and credential fraud.
- Helps enterprises satisfy data protection mandates (NDPR, GDPR) without centralizing identity data.
- Strengthens security posture through decentralized verification instead of traditional database lookups.
Developer & Infrastructure Ecosystems
- Provides a scalable, plug-and-play identity API so developers can integrate secure identity without building it from scratch.
- Enables compact, confidential workflows that suit enterprise-grade identity requirements.
- Supports rapid ecosystem growth through reusable identity modules across platforms.
Why This Fits the Midnight Compact dApp Category
ECO ID leverages Midnight’s confidential smart contracts to deliver exactly what Compact dApps are designed for:
- High privacy, low-data exposure identity workflows
- Efficient, selective-disclosure interactions
- Regulatory-grade compliance without centralization
- Enterprise integration through reusable, compact identity components
The result is a cross-sector identity foundation that is practical, secure, and immediately valuable to real African markets.
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.
1) Compact contract set (what we’ll deploy)
Each contract is a small, composable Midnight Compact contract focused on a single responsibility.
DIDRegistry
CredentialIssuer
- Purpose: issue verifiable credentials (VCs) as compact attestations.
- Key functions:
- issueCredential(did, credentialHash, issuerSig, schemaID) → mints attestation pointer.
- batchIssue(credentials[]) → for bulk community-validated issuance.
- Proofs:
- ZK proof that issuer holds authority and credential content matches schema (selective disclosure compatible).
SelectiveDisclosureManager
- Purpose: enable selective disclosure / ZK proof requests and verifications.
- Key functions:
- createDisclosureRequest(appID, requiredClaims, nonce, ttl) → creates request template.
- verifyDisclosureProof(did, proofBlob) → verifies ZK proof server-side via Midnight verifier.
- Proofs:
- App-specific ZK circuit proofs proving possession of required claims without revealing raw data.
RevocationRegistry
- Purpose: track credential revocation and revocation proofs.
- Key functions:
- revokeCredential(credentialID, revokerSig)
- isRevoked(credentialID) → boolean.
- Proofs:
- Merkle inclusion/exclusion proofs for fast revocation checks.
SSOBroker
- Purpose: issue SSO session tokens anchored to verified proofs and DID.
- Key functions:
- requestSSOToken(did, proofBlob, appID) → mints time-limited session token (signed).
- validateToken(token) → on-chain lightweight validation.
- Proofs:
- ZK proof included in token that the user satisfied disclosure request.
AuditLog (confidential)
- Purpose: append encrypted audit events (consent, token issuance) — privacy-preserving.
- Key functions:
- appendEvent(did, encryptedEvent)
- queryEvents(did, accessProof) (requires proof to decrypt pointers).
- Proofs:
- Proof of non-repudiation: signed events by issuers/verifiers.
2) Key functions & proof flows (sequence view)
DID creation
- Client generates keypair → signs registerDID → transaction anchors DID.
- On-chain verifies wallet signature.
Credential issuance
- Verifier collects proof (doc OCR, community attestations) off-chain → generates credential payload and issuer signs → issueCredential stores credential pointer and commitment.
Selective disclosure (user-driven)
- App requests disclosure via createDisclosureRequest.
- User wallet generates ZK proof from stored credential (client-side ZK circuit) proving satisfaction of required claims without revealing raw fields.
- verifyDisclosureProof validates proof. If valid, requestSSOToken issues session token.
SSO flow
- App receives token → calls validateToken with token to confirm authenticity & TTL.
- User is authenticated; token contains only necessary claims.
Revocation & audits
- Issuer may call revokeCredential. Verifiers check isRevoked with Merkle proof included in verification flow.
- Consent events appended to AuditLog (encrypted).
3) Demo UI flow (end-to-end; minimal MVP)
Goal: show a complete SSO login from user onboarding → credential issuance → SSO into partner app.
Landing / Sign up
- User clicks “Create ECO ID”.
- Option: Connect Lace wallet OR create local key + guided backup.
DID registration
- Wallet signs DID registration transaction.
- UI shows "DID created — pending confirmation".
Document upload & lightweight verification
- User uploads ID doc (photo of NIN/passport or community attestation).
- UI performs client-side OCR and displays extracted fields for confirmation.
- Admin/Pod or light verifier reviews via simple verifier dashboard.
Credential issuance
- Verifier issues credential → user receives notification in UI/wallet.
- Credential stored encrypted in the user’s wallet or secure off-chain store; only commitment on chain.
App SSO demo
- User clicks “Login to Demo Partner App”.
- Partner app initiates disclosure request (required claims shown).
- Wallet prompts user: “Share: [Claim A — yes/no]” and displays proof being generated.
- Wallet generates ZK proof and returns to partner app.
- Partner app exchanges proof for SSO token via SSOBroker.
- App validates token and logs user in.
Revoke / View audit
- Admin revokes credential → user sees revocation notice.
- User can view consent logs (decrypted with wallet key).
4) Lace (Midnight) wallet integration (concrete steps)
We will integrate via Lace SDK / Midnight wallet APIs with deep-linking and web3 RPC where applicable.
Integration pieces
Wallet connection
- Use Lace web SDK / WalletConnect-like flow to present connection modal.
- Methods: connect(), getPublicKey(), signMessage(msg), sendTransaction(tx).
Key operations via wallet
- DID registration: sign DID payload with signMessage, then sendTransaction the registerDID call.
- Credential attestation: wallet stores encrypted credential blobs in local secure storage or encrypted IPFS pointer; wallet signs issuance acceptance.
- ZK proof ops: wallet triggers local ZK proof generation process (or calls a locally-bundled WASM prover). Wallet API returns proof blob to dApp.
Session & token storage
- SSO token stored in wallet secure storage or session memory; token refresh via requestSSOToken.
UX specifics
- Permission screens for each disclosure request (claim list, TTL, app identity).
- Clear recovery flows: wallet seed phrase backup + social / custodial recovery for low-friction users.
Developer hooks
- onProofGenerated(proofBlob) callback.
- onTransactionConfirmed(txHash) and onTokenReceived(token) events.
Notes
- If Lace supports native ZK prover integration, use it; otherwise embed WASM ZK circuits into the wallet/web client.
- Prefer user-side proof generation to avoid exposing raw data.
5) Basic test plan (MVP-first, pragmatic)
Short cycles, testnet-first, privacy-first.
Unit tests (contracts)
- DIDRegistry: register/resolve/update/rotate tests.
- CredentialIssuer: issue, batch issue, re-issue.
- RevocationRegistry: revoke & isRevoked checks, Merkle path tests.
- SelectiveDisclosureManager: verifier accepts valid proofs, rejects tampered ones.
Integration tests (end-to-end)
- On Testnet (Midnight testnet): full flow from wallet DID registration → credential issuance → proof generation → SSO token → app validate.
- Simulate 1,000 users with scripted flows (account creation, credential issuance, login).
Security & Privacy tests
- Smart contract audit checklist (static analysis + manual review).
- Penetration tests for off-chain components (OCR server, verification APIs).
- Privacy threat model: ensure no raw PII stored on-chain or in plaintext off-chain.
- ZK proof soundness: test circuits against edge-case claim sets.
Performance & Load tests
- Load test verifyDisclosureProof endpoint to 200 qps for MVP.
- Token issuance throughput tests (e.g., 100 tokens/sec).
Usability & Acceptance
- 2-day usability sessions with ECO Pod ambassadors (20 users) to surface friction in onboarding and consent UI.
- Accessibility checks (low-bandwidth, low-spec phones).
Compliance & Audit
- NDPR/GDPR mapping document and plan.
- Prepare audit package for third-party review (to be budgeted later).
Success criteria (MVP)
- Contracts pass unit tests and audit checklist.
- 1,000 unique testnet ECO IDs created and at least 500 successful SSO logins.
- ZK proofs verify on-chain/testnet in <2s (goal) or <5s (acceptable).
- No raw PII written to chain; audit log events encrypted.
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)?
Repository, README & Reuse Strategy
Repo Structure
- contracts/ — All Midnight smart-contracts (DIDRegistry, CredentialIssuer, SelectiveDisclosureManager, RevocationRegistry, SSOBroker, AuditLog)
- frontend/ — Web UI (React) for onboarding, verification, SSO flows
- wallet-integration/ — Code/scripts for Lace wallet connection, proof generation, deep linking
- backend/ — Lightweight API server for verification engine, credential issuance orchestration
- docs/ — Documentation: architecture overview, developer guide, API reference, ZK circuit description
- tests/ — Unit & integration test suites (contract tests, ZK proof tests, UI-flow tests)
- scripts/ — Deployment & migration scripts (Midnight testnet, mainnet)
- examples/ — Sample partner app integration (SSO flow implementation)
README Contents
- Project overview: “ECO ID – Privacy-Preserving SSO for Africa on Midnight”
- Getting Started: prerequisites, how to spin up testnet, local dev environment
- Directory structure explanation (as above)
- Smart contract summary: purpose & high-level functions
- Wallet integration guide: listing supported wallets (e.g., Lace), how to connect, how to trigger proof flows
- Demo UI walk-through: steps from onboarding → issuance → SSO
- How to run tests: npm test / forge test / CI commands
- Extension points: how other developers can build on top
- Contributing guidelines & license
Docs/Tutorials
- Developer tutorial: “Build a partner app and integrate ECO ID SSO”
- Walk-through of writing a new selective‐disclosure request schema
- Tutorial on customizing ZK circuit for new use-case (e.g., health credentials)
- API reference for backend endpoints (issueCredential, requestSSOToken, verifyProof)
- Deployment tutorial: moving from Midnight testnet to mainnet
Test Instructions
- Step-by-step: run contracts local/testnet, deploy UI, connect wallet, simulate onboarding → issuance → login
- Running CI pipeline: contract build → contract tests → UI tests → proof flow simulation
- How to add new test cases: e.g., new credential types, partner apps, wallet providers
- Performance checks: stress test script in scripts/load-test.js
Extension points
- Schema-registry for new credential types
- Partner-SDK for apps to plug into SSO model
- Wallet plugin support beyond Lace (e.g., other Midnight wallets)
- Localisation for African languages & integration with national ID systems
- Plugin for analytics/audit logs (privacy-preserving)
Developer Personas That Benefit
- Blockchain engineers: integrate contracts, extend selective-disclosure circuits
- Web/mobile devs: build partner apps using the SSO SDK
- Identity solution architects: adapt ECO ID for particular sectors (fintech, gov-tech, health)
- DevOps/infrastructure: deploy Midnight DApp, manage testnet → mainnet pipeline
Impact Metrics for Reuse
- Number of forks of the repo (shows developers building on top)
- Stars on GitHub (community recognition)
- Issues opened and resolved (active community usage)
- Pull requests from external devs (ecosystem growth)
- SDK adoption: number of partner apps integrating SSO
- Downloads or usage metrics: number of deployed apps, total logins via ECO ID
[Your Project and Solution] Solution
Please describe your proposed solution and how it addresses the problem
ECO ID is a privacy-preserving SSO identity system for Africa, built as a Compact dApp on Midnight, enabling:
Core Capabilities
- Decentralized Identity (DID) issuance anchored on Midnight
- Advanced selective disclosure (share only what is required)
- Privacy-preserving verification using Midnight’s confidential computation
- Multi-source identity fusion (NIN, BVN, Passport, Community Validation)
- Universal SSO for:
- The ECO Platform (partners + ambassadors)
- Financial inclusion applications
- ESG data systems
- Gov-tech onboarding
- SME / informal sector verification
Why Midnight
- ZK-powered confidential smart contracts
- Compliant with regulatory-grade privacy
- Ideal for identity workflows requiring selective, confidential verification
- Native support for Compact DApps
- Strong alignment with the global south data sovereignty agenda
[Your Project and Solution] Impact
Please define the positive impact your project will have on Midnight ecosystem
ECO ID brings a high-value, real-world identity use case to Midnight, accelerating ecosystem adoption and strengthening Midnight’s position as the leading privacy-preserving blockchain for regulated, data-sensitive applications. The project delivers impact across four strategic layers:
Expands Midnight’s Real-World Utility Across Africa
- Introduces Midnight to a 1.4B-person market with massive identity, fintech, and gov-tech needs.
- Demonstrates how confidential smart contracts solve regulatory-grade identity challenges across the global south.
- Establishes Midnight as the preferred chain for identity, access control, compliance, and secure data verification in emerging markets.
Demonstrates a Flagship Compact dApp Use Case
- ECO ID becomes a reference implementation for building privacy-preserving identity systems using Compact contracts:
- DID issuance
- Selective disclosure
- Confidential verification
- Revocation
- SSO tokenization
- This becomes a blueprint other developers can fork, extend, or replicate—accelerating adoption of the Compact dApp model.
Drives Developer Growth & Extensibility
By open-sourcing the entire stack, ECO ID provides:
- A reusable identity SDK for Midnight
- Sample UI flows, ZK proof workflows, and wallet integration patterns
- A composable set of identity contracts usable for fintech, health, education, ESG, and gov-tech
- This significantly lowers the barrier for developers who want to build confidential identity, KYC, login, or credentialing systems on Midnight.
Strengthens the Midnight Wallet & UX Ecosystem
Integrating ECO ID directly with the Lace (Midnight) wallet:
- Provides a real example of ZK-based selective disclosure inside the wallet
- Drives daily wallet usage through SSO logins
- Provides user feedback loops that improve privacy UX across the network
- This positions the Midnight wallet as the default identity agent for African and global use cases.
Accelerates Enterprise & Government Adoption
ECO ID demonstrates Midnight’s capability to serve:
- Banks & fintechs (KYC, onboarding)
- Governments (digital ID, service portals)
- Corporations (ESG/SDG reporting)
- NGOs & social programs (beneficiary verification)
- This opens the door for enterprise integrations and future partnerships where Midnight is the underlying trust layer.
Builds Network Effects for Long-Term Growth
As ECO ID scales, it brings with it:
- More partner apps integrating Midnight SSO
- More DIDs anchored on Midnight
- More verifiable credentials linked to the chain
- Higher transaction volume from proof verifications
- A growing identity “graph” built on compact contracts
This strengthens Midnight’s economic activity and long-term developer adoption.
Positions Midnight as the Privacy Layer for Africa’s Digital Economy
ECO ID directly aligns with Africa’s push for:
- Data sovereignty
- Privacy-by-design infrastructure
- Trust-based fintech
- ESG & regulatory transparency
Midnight becomes the chain powering Global south new trust infrastructure—extremely rare, extremely strategic, and extremely impactful.
[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?
I have a proven track record delivering identity, data, and civic-tech solutions across the global south, backed by active operations in five countries, an established verification network (The ECO PALs), and an accountable leadership framework (ART & ACT). My capability spans system design, verified data pipelines, and multi-stakeholder governance, ensuring transparency, responsibility, and operational rigor.
Feasibility is validated through a structured MVP on Midnight testnet, real-world user testing via The ECO Platform, OCR+manual verification trials, stress testing of DID and selective disclosure circuits, third-party reviews, and continuous measurement of SSO usage, developer adoption, and partner integrations. This ensures both technical and market feasibility in a controlled, evidence-driven manner.
[Final Pitch] Budget & Costs
Please provide a cost breakdown of the proposed work and resources
- Smart Contracts (DID + Selective Disclosure) — $3,500
Deliverables:
DID registration
Privacy-preserving selective disclosure
Credential revocation registry
Midnight testnet deployment
Documentation
Why essential:
This is the backbone of ECO ID on Midnight. No identity layer = no project.
- Backend + Lightweight Verification Service — $2,000
Deliverables:
Minimal verification engine
Document submission API
Basic OCR validation
Wallet ↔ Midnight contract integration
Why essential:
Allows MVP user verification without full biometric stack.
- ECO ID SSO (Web) — $2,000
Deliverables:
Web-based onboarding flow
Login-with-ECO middleware
OAuth-style SSO for ECO Platform
SDK for partners
Why essential:
This is the “visible” product — the authentication layer.
- Frontend (Web) — $1,000
Deliverables:
Simple web interface for creating ECO ID
Document upload
Wallet connection
Testnet-friendly UX
Why essential:
User-facing component enabling adoption.
- Testing + Audit Lite — $1,000
Deliverables:
Functional testing
Contract review
Basic security checks
Performance on 2,000 simulated accounts
Why essential:
Ensures quality without paying for a full audit.
- Project Management + Reporting — $500
Deliverables:
Weekly Catalyst updates
Milestone tracking
Final documentation
Why essential:
Compliant execution under Catalyst governance.
[Final Pitch] Value for Money
How does the cost of the project represent value for the Midnight ecosystem?
The project delivers a full decentralized identity and selective-disclosure SSO stack on Midnight for only $10k—far below typical DID/ZK development costs. It provides reusable smart contracts, wallet integrations, and developer tooling that other builders can adopt immediately, accelerating Midnight’s technical maturity.
By piloting ECO ID in the global south 1.4B-person market, the project drives real-world adoption and establishes Midnight as the preferred confidential identity layer for fintech, ESG, and gov-tech use cases.
[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