Last updated 3 months ago
Discovering quality Web3 projects is fragmented and noisy; users and builders lack a trusted, transparent, and up‑to‑date directory with consistent ratings, reviews, and basic due‑diligence.
DappScore is a privacy‑aware directory that aggregates Web3 projects, with wallet‑based submissions, curated metadata, on‑chain ratings, and transparent scoring for users and builders.
Please provide your proposal title
Veil Protocol - DappScore Verifiable Dapp Directory
Please specify how many months you expect your project to last
3
Please indicate if your proposal has been auto-translated
No
Original Language
en
What is the problem you want to solve?
Discovering quality Web3 projects is fragmented and noisy; users and builders lack a trusted, transparent, and up‑to‑date directory with consistent ratings, reviews, and basic due‑diligence.
Supporting links
Does your project have any dependencies on other organizations, technical or otherwise?
No
Describe any dependencies or write 'No dependencies'
No dependencies
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
Please choose the most relevant theme and tag related to the outcomes of your proposal
Community
What is useful about your DApp within one of the specified industry or enterprise verticals?
DappScore serves the “infrastructure and tooling” vertical by becoming a discovery and reputational layer for Web3 projects that leverage Midnight for privacy‑respecting transparency. Today, users trying to find trustworthy DeFi protocols, NFT platforms, or infrastructure tools must jump between many sources: social media threads, ad‑driven ranking sites, chain‑specific explorers, and private recommendation chats. Information is inconsistent, sometimes manipulated, and rarely privacy‑aware. Projects that build carefully and follow good security and governance practices are often buried beneath loud marketing, while low‑quality or abandoned projects can appear next to serious ones with no clear distinction. This noise increases user risk, slows adoption, and makes it harder for genuinely strong builders to stand out.
DappScore addresses this by providing a curated, cross‑chain directory where each project has a clearly structured profile and an evolving reputation signal. The DApp lets anyone browse projects by chain, category, and key characteristics (DeFi, NFT, infra, tooling, education, etc.), and see at a glance if a project appears active, documented, and well‑maintained. Ratings and reviews are anchored on‑chain, making them tamper‑evident and auditable over time, but they can still be submitted in a privacy‑respecting way using Midnight. This mix of transparent scoring and optional selective disclosure means users can trust that ratings cannot be silently edited or deleted, while reviewers retain control over how much of their identity or usage patterns they want to reveal.
For the DeFi and broader dApp verticals, DappScore functions as a discovery front‑end and a basic due‑diligence helper. Someone new to a chain such as Stellar, Aptos, Bahamut, Polkadot, or Solana can quickly find top projects, filter by type (DEX, lending, NFT marketplace, infra, etc.), and see a normalized “DappScore” along with qualitative tags like “docs present”, “open‑source verified”, “audited”, or “testnet only”. For builders, being listed with a clear profile and reputation helps attract more aligned users, collaborators, and auditors. For the Midnight ecosystem specifically, DappScore highlights projects that integrate Midnight or respect strong privacy practices, showcasing how data‑protection tools can coexist with transparency and accountability.
Because DappScore is itself an open‑source reference DApp, it also acts as a pattern for other vertical directories: for example, security‑focused registries, educational resource hubs, or domain‑specific marketplaces. The underlying model structured metadata + wallet‑gated submissions + on‑chain rating signals anchored on a privacy‑first chain—can be reused by many communities. In this way, DappScore is useful not only as a product that users will browse, but also as infrastructure that demonstrates how Midnight can power reputational and discovery tools across the wider multi‑chain ecosystem.
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 project will deliver a full‑stack, open‑source DappScore implementation anchored on Midnight, evolved from the existing Solana‑centric version into a cross‑chain, privacy‑aware directory. At the core is a Compact smart contract that stores canonical project entries and on‑chain rating aggregates. Each project record includes fields like project ID, name, primary chain, category, website, repository links, status flags (active, beta, deprecated), and a reference to richer metadata stored off‑chain. The contract also maintains rating aggregates (e.g., average score, rating count) and, where appropriate, separate scores for criteria such as UX, reliability, and documentation quality. Wallet‑based roles let admins approve or reject submissions, flag duplicates, and moderate spam, while regular users can submit ratings and reviews subject to one‑wallet‑one‑rating per project rules.
To prevent simple rating abuse, the contract will support a basic proof or eligibility mechanism (for example, requiring a minimal interaction token or role, or leveraging Midnight’s privacy capabilities so that uniqueness is enforced without exposing the entire history of a reviewer). This will be implemented in a way that can later be extended into more advanced ZK‑based reputation flows, but within the scope of this proposal the focus is on a concrete, reliable baseline that demonstrates how Midnight can anchor reputational signals with better privacy than fully transparent chains.
On the frontend, DappScore will provide a polished Next.js/React interface (ported and adapted from the existing implementation) with the following flows:
Project discovery page with filters by chain, category, tags, and activity signals.
Project detail view showing metadata, links, rating breakdown, review snippets, and social metrics (e.g., GitHub stars, last commit, X/Twitter presence) fetched from off‑chain APIs where possible.
Submission flow where a connected wallet can propose a new project by filling out basic fields; after an admin wallet reviews and approves, the entry becomes visible in the directory.
Rating and review flow where a user can score a project and optionally add a brief comment, with the rating being recorded on‑chain and the comment stored off‑chain but linked immutably via hashes.
Admin dashboard protected by wallet‑based roles, allowing maintainers to approve submissions, mark projects as deprecated or fraudulent, and manage categories and tags.
Lace wallet integration will be used on the Midnight side so that admin and rating actions are signed transactions anchored on a data‑protected network. At the UI and metadata level, while using Midnight as the trusted layer for scoring and governance.
The basic test plan includes unit tests for the Compact contract to ensure correct handling of project creation, updates, rating aggregation, and access control (admins vs regular users). Integration tests and scripts will simulate project submissions, approvals, ratings, and edge cases such as attempts to double‑rate, submit invalid data, or update unauthorized fields. Manual test scenarios will be documented so reviewers can reproduce the full flow on Midnight testnet: deploying the contract, running the web app, connecting a wallet, submitting a project, approving it as admin, and casting ratings.
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)?
DappScore is built explicitly as a reusable template for cross‑chain directories and reputation systems, so the repository will be organized to maximize clarity and adaptability. At the root level, the project will be split into clearly labeled sections such as contracts/ (Compact code and supporting logic), frontend/ (Next.js/React app), scripts/ (deployment and data tasks), and docs/. Within contracts/, the main directory contract and any auxiliary modules will include detailed comments explaining the data model (project records, rating aggregates), role system (admin vs user), and design decisions around privacy and off‑chain metadata storage. Developers wanting to understand how to anchor reputations on Midnight can start there.
The main README will provide a high‑level overview, a diagram of the architecture, and a quickstart that shows how to clone the repo, install dependencies, deploy the contract to Midnight testnet, configure environment variables, and run the frontend. It will link into more detailed documents in docs/, such as: “Project Submission and Approval Flow”, “Rating Model and Limitations”, “Connecting New Chains and Categories”, and “Integrating Additional Metrics (e.g., GitHub, social data)”. Tutorials will walk through common modifications, like restricting project submissions to certain roles, changing the rating scale, or adding new attributes such as security audits or KYC flags.
Test instructions will be straightforward: commands like npm run test:contract to execute unit tests and npm run test:integration or scripts for scenario‑level tests. For developers who want to verify behavior manually, the docs will include step‑by‑step guides with screenshots for deploying a fresh test instance, registering sample projects, and verifying that ratings are correctly aggregated and that admin actions behave as expected. This combination of automated and manual testing guidance turns DappScore into a learning lab for how to build more complex data products on Midnight.
Several developer personas stand to benefit. Web3 full‑stack developers can learn how to architect a multi‑chain directory with a privacy‑aware reputation layer on Midnight. Smart contract engineers get a concrete example of how to manage structured lists and aggregated scores in Compact while delegating heavy content to off‑chain storage. Product teams and growth engineers can see how directory UX, filtering, and rating flows can be implemented in a way that is familiar to Web2 users but backed by verifiable on‑chain data. Educators and hackathon organizers can use the project as a base for tracks around “trust and discovery in Web3”, asking participants to extend the model with new metrics, badges, or governance rules.
Impact will be measured using transparent signals: the number of forks and stars on the DappScore repository, the count of independent deployments (tracked via community feedback and references in other proposals or docs), and the number of external contributions such as issues, pull requests, or feature additions. Additionally, as projects request to be listed or integrated, that demand itself will show whether the directory is becoming a useful neutral utility for the ecosystem. Over time, the goal is for DappScore—or derivatives based on this codebase—to be seen as a standard entry point for discovering trustworthy projects on Midnight and connected chains.
Please describe your proposed solution and how it addresses the problem
The proposed DappScore solution is to turn your existing project directory work into a robust, Midnight‑anchored reference DApp for multi‑chain discovery and reputation. At its heart, DappScore combines a structured directory of Web3 projects with a transparent, on‑chain rating system and a pleasant, modern UI that feels familiar to Web2 users. Users can browse projects by network and vertical, search by name or tags, open a detail page with key links and metrics, and then express their view through a rating and optional review. Projects themselves are created either by the project team (via wallet‑gated submission) or by the community and then approved by admin wallets to filter out spam and obvious scams.
Midnight’s role is to anchor the integrity and privacy of the reputational layer. Instead of keeping ratings solely in a centralized database, which can be silently edited, censored, or lost, DappScore records rating aggregates and key events on‑chain. This makes it easy to prove that a project’s score has evolved according to the rules and that no one retroactively rewrote history. At the same time, sensitive information such as the full mapping between individual wallets and ratings, or any optional user identity data, can be handled via data‑protection features and off‑chain storage, reducing the risk of doxxing while still providing meaningful, auditable signals. The contract design enforces fairness constraints such as one rating per wallet per project, and can later be extended to more advanced reputation models that consider usage, volume, or other factors.
The user interface is designed for both newcomers and power users. Someone new to a chain sees a clean landing page with highlighted projects, filters for category and maturity (testnet, mainnet, experimental, audited), and quick access to project detail cards. Experienced users can drill down into specific metrics, sort by ratings, filter by recently updated projects, or search for a particular tool. For project teams, DappScore provides a simple way to keep a canonical profile up‑to‑date and to demonstrate activity and community feedback to potential users, partners, and even grant programs.
By publishing all of this as open source with clear docs, DappScore becomes more than a single website it becomes a template for bootstrapping trust and discovery on privacy‑aware chains. Other teams can fork it to create thematic directories (for example, educational resources, security tools, or DAO tooling), or integrate its scoring system into their own dashboards and wallets. The result is an ecosystem where reputational information is more consistent, harder to manipulate, and easier to build upon, while still respecting user privacy and giving project teams a fair, structured way to be evaluated.
Please define the positive impact your project will have on Midnight ecosystem
DappScore’s main impact on the Midnight ecosystem is to provide a trusted, neutral discovery and reputation layer that makes it easier for users, developers, and partners to identify credible projects quickly. As Midnight grows, more applications, tools, and cross‑chain integrations will compete for attention. Without a structured directory and consistent scoring system, it becomes hard for newcomers to know where to start and for serious teams to differentiate themselves from opportunistic forks or low‑effort deployments. DappScore mitigates this by offering a curated entry point where projects that meet basic quality and transparency standards are clearly visible, categorized, and evaluated in a consistent way.
For users, this reduces the cognitive load and risk associated with exploring new DApps. Instead of relying on search engines, scattered blog posts, or social recommendations, they can check DappScore to get a quick sense of which projects are active, how the community perceives them, and where to find official docs and code. For builders, the platform functions as a reputational surface: a strong DappScore backed by verifiable activity and positive ratings becomes a useful asset when attracting new users, contributors, and potential funders. Projects that invest in good practices—clear documentation, open‑source code, regular updates—are rewarded with better visibility, aligning incentives in a way that benefits the entire ecosystem.
For Midnight specifically, using the network as the anchor for rating data sends a powerful message: reputation and discovery can be built on a privacy‑respecting base. The directory can highlight projects that integrate Midnight directly, categorize applications by their use of data‑protection features, and even provide badges that indicate privacy‑aligned behaviors (such as selective disclosure patterns or strong consent flows). This helps position Midnight not just as another smart‑contract platform, but as the backbone for trustworthy Web3 infrastructure where users know their data is handled carefully.
Over time, DappScore can also become an indicator of ecosystem health. Metrics such as how many projects are actively maintained, how many receive consistent positive ratings, and how many new listings appear per quarter all provide concrete signals of growth. Grant programs, hackathons, and partnership initiatives can use DappScore as one input in their selection and monitoring processes, while still performing their own deep due diligence. In summary, the cost of building DappScore is leveraged into an ongoing increase in discoverability, trust, and accountability for every future project on Midnight and connected chains.
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 team behind DappScore already has experience shipping the initial version of the directory as a working Solana project, including a polished frontend, submission flows, and admin management. This existing codebase and product learning significantly de‑risk the Midnight version: many UI patterns, page layouts, and data structures are already validated with real users, and only need to be adapted to the new architecture and chain integration. On the technical side, the builder is comfortable with TypeScript/Next.js, smart contract patterns, and multi‑chain wallet integration, which means the focus in this proposal can be on porting and extending rather than learning basic technologies from scratch.
The roadmap is broken into clear milestones: first, design and deploy the Compact contract and data model on Midnight; second, adapt the frontend and admin flows to use Midnight as the rating anchor while retaining support for multiple external chains; third, finalize documentation, testing, and polishing the repository as a reusable template. Each milestone yields a demonstrable increment: after Milestone 1 the contract and basic CLI scripts allow project creation and rating on testnet; after Milestone 2 users can interact via a web UI; after Milestone 3 external developers have docs, tests, and extension guides. This staged delivery keeps the scope realistic for a 3‑month, 10k USDM budget and ensures that even if later enhancements are needed, a functional MVP exists early.
Feasibility will be validated through transparent, reproducible testing and community feedback. All code is open source under a permissive license, issues and milestones are tracked publicly, and the team will encourage other builders to deploy the DappScore stack to their own test environments. Automated tests for the contract and core frontend flows will run during development, and manual scenarios covering project submission, approval, rating, and browsing—will be documented so that reviewers and ecosystem partners can verify behavior themselves. This combination of prior experience, an existing base implementation, a realistic milestone structure, and open development practices provides strong evidence that the DappScore Midnight directory can be delivered reliably within the proposed timeline and budget.
Please provide a cost breakdown of the proposed work and resources
Requested: USDM 10,000 over 3 months.
Distribution: 3k (Milestone 1) + 3k (Milestone 2) + 4k (Milestone 3).
Justification: focuses purely on engineering, testing, and documentation; avoids non‑technical spending; produces a reusable reputational layer that many projects can benefit from, making the effective cost per project low as adoption grows.
How does the cost of the project represent value for the Midnight ecosystem?
The requested budget of USDM 10,000 over 3 months represents strong value for the Midnight ecosystem because it delivers a reusable, open‑source reputation and discovery layer that many future projects can leverage, rather than a one‑off application. Instead of multiple teams each spending similar or larger amounts to build and maintain their own project lists and rating systems, this grant funds a single, high‑quality DappScore implementation that can be forked, extended, and embedded into wallets, dashboards, and ecosystem portals at no additional cost to Midnight. Every new DAO, DeFi protocol, NFT marketplace, or tooling project that plugs into DappScore benefits from the same underlying infrastructure, so the effective cost per integrated project decreases over time as adoption grows.
The budget is tightly scoped to technical work Compact contract design, frontend engineering, admin and submission flows, integration with Midnight and external chains, testing, and documentation without large allocations to non‑engineering expenses. Milestone 1 (3k) covers the directory contract, rating model, role system, and deployment scripts. Milestone 2 (3k) funds the Next.js/React frontend, search and filter UX, wallet integration, and admin tools for curation and moderation. Milestone 3 (4k) is dedicated to documentation, test suites, and packaging the repository as a template that other teams can adopt, which is where much of the long‑term ecosystem value is created. This distribution ensures that core functionality is delivered early, while also properly resourcing the often‑underfunded work of tests and docs that make a project sustainable and trustworthy.
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
I Agree
Yes
Armando Medina - Compact Developer
More than 100 hackathons participated
Winner in Midnight Berlin Hackathon
Finalist Sweet 16 in Midnight Hackathon London
Giovanni Fu Lin - Frontend Developer
prev frontend gitcoin, ethglobal finalist, many hackathons participated