[Proposal setup] Proposal title

Please provide your proposal title

Privacy-Preserving Crypto Receipts for Small Merchants

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

Small businesses lack privacy-preserving crypto payments. Marketplaces force them to reveal unnecessary data or build custom systems, making crypto adoption impractical for small merchants.

[Proposal Summary] Supporting Documentation

Supporting links

• https://github.com/foxytanuki
,
• https://midnight-devtools.vercel.app/
,
• https://github.com/foxytanuki/midnight-devtools
,
• https://github.com/foxytanuki/midnight-sandbox
,
• https://github.com/NextMed-main/Main

[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 Status: This project will be fully open source from day one. All code including smart contracts, frontend, matching logic, tests, and documentation will be published in a public GitHub repository.

License Type: The project will use the MIT License because it is permissive, easy to reuse, and aligns with the goal of providing a clear reference implementation for the Midnight ecosystem.

[Theme Selection] Theme

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

E-commerce

[Campaign Category] Category Questions

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

Industry: Commerce / Small Business / Online marketplaces

• Current crypto payments reveal full purchase metadata to platforms, payment processors, or analytics providers, making crypto adoption impractical for small shops.
• Small merchants lack privacy-preserving tooling and cannot afford to build custom encrypted-order pipelines.
• The proposed DApp introduces a reusable pattern: merchants issue encrypted receipts, buyers submit only totals, and verifiers confirm payments without item disclosure.
• This directly supports commerce, logistics, ticketing, donation systems, and gig services where item confidentiality matters.
• It enables small businesses to integrate crypto without leaking sales data, SKU patterns, customer habits, or inventory signals.
• As a compact, minimal reference implementation, it lowers the barrier for developers to build privacy-preserving commerce apps 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.

Compact Contract(s)

• Contract: EncryptedReceipt
• Store encrypted receipt commitment (hash of encrypted payload).
• Store public fields: total amount, timestamp, merchant ID.
• Store buyer address and merchant address.
• Verify a buyer-submitted receipt hash matches the merchant-issued commitment.
• Enforce selective-disclosure flow: contract never sees item details.

Key Functions / Proofs

• commit_receipt(commitment) – merchant registers encrypted receipt.
• submit_receipt(commitment, total) – buyer submits matching commitment.
• verify_match() – proof that two commitments correspond, without exposing item content.
• Optional: ZK-friendly hashing supported by Compact.

Demo UI Flow

• Merchant page: create order → encrypt items → push commitment to chain.
• Buyer checkout: view encrypted summary → approve → submit selective disclosure.
• Verifier page: confirm totals without accessing item details.

Wallet Integration (Lace Midnight)

• Connect wallet for receipt submission.
• Merchant uses Lace for signing receipt commitments.
• End-to-end flow executed fully through Lace.

Test Plan

• Unit tests for hashing, commitment consistency, encryption helpers.
• Contract tests for receipt creation/verification flows.
• Integration tests: UI ↔ contract ↔ Lace.
• End-to-end scenario: merchant issues receipt → buyer submits → verifier checks

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

• /contracts/EncryptedReceipt.mjs – Compact contract + comments
• /src/crypto/ – encryption helpers (AES-GCM placeholder)
• /src/ui/ – demo UI pages (merchant, buyer, verifier)
• /tests/ – unit tests, contract tests, integration tests
• /docs/ – patterns, diagrams, tutorials, extension notes

README Contents

• How the selective-disclosure commerce pattern works
• Step-by-step setup instructions
• Contract API reference
• UI walkthrough screenshots
• Developer guide for extending the pattern (donations, ticketing, marketplaces)

Tutorials & Docs

• “How to build encrypted receipts on Midnight”
• “How to use commitments + selective disclosure in Compact”
• “Add Lace integration to your DApp in 10 steps”

Developer Personas Benefiting

• DApp developers building e-commerce, procurement, ticketing, donation flows
• zk-curious developers learning selective disclosure patterns
• Integrators who need minimal, auditable examples

Measurable Impact (forks, stars, remixes)

Adoption will be measured through concrete OSS signals. Within 3–6 months after release, we target:

• 5+ forks developers experimenting with private matching flows

[Your Project and Solution] Solution

Please describe your proposed solution and how it addresses the problem

Small merchants struggle to adopt crypto payments because existing tools expose unnecessary purchase details or require building complex off-chain logic. Our solution is a privacy-preserving “encrypted receipt module” built with Compact contracts, showing how Midnight can support commerce without leaking sensitive item data.

Merchants generate encrypted item-level receipts off-chain using a small TypeScript library. Buyers receive these encrypted receipts in their wallet and submit a Compact proof on-chain that reveals only the total amount and merchant ID. Merchants or verifiers can later confirm payment authenticity via selective disclosure without ever accessing item contents.

The Reference DApp includes:

• Compact contract for posting encrypted receipts and verifying payment totals
• Minimal marketplace-style UI for merchants and buyers
• Off-chain encryption helper library and workflow (cart -> encrypt -> buyer wallet -> submit proof)
• Test plan showing multiple purchase flows and selective disclosure examples
• Documentation and repo structure demonstrating how other developers can reuse the pattern

This provides a clear, forkable demonstration of encrypted commerce flows on Midnight.

[Your Project and Solution] Impact

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

Small merchants currently avoid crypto payments because existing solutions leak sensitive purchase data to marketplaces or require building custom payment logic. This module provides a reusable privacy-preserving pattern: merchants issue encrypted receipts off-chain, buyers submit them on-chain with only totals revealed, and verifiers can confirm payments without accessing item details.

This lowers the barrier to adopting crypto for small shops, online creators, local services, and niche marketplaces.

As a Reference DApp, it becomes a blueprint for crypto commerce tooling on Midnight of donations, subscriptions, procurement, ticketing, and merchant integrations. It establishes a minimal, forkable, well-documented template developers can extend.

[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 more than six years of professional TypeScript experience, along with hands on development across multiple blockchain architectures including EVM, Solana, ICP canisters, and Cosmos SDK. This background gives me a deep understanding of smart contract design, state models, and privacy oriented or zero knowledge aware workflows. Combined with production experience in Go and Solidity, I am well suited to deliver a technically complete Compact reference DApp.

My experience with Midnight is practical and recent. I participated in the Midnight London Summit Hackathon, where our team built NextMed, a privacy-preserving medical data prototype that won the Midnight Club Award. During the event, I also created lightweight developer tools for the Midnight network, including an RPC Explorer, an Indexer Explorer, and a wallet connection verification tool. Building these gave me hands-on familiarity with Compact development flows, RPC interactions, indexer queries, and the real-world behavior of the current Midnight toolchain. This direct experience significantly reduces project risk and accelerates implementation.

To ensure feasibility:

• All Compact modules will be developed and tested locally using the Midnight test environment
• Encrypted receipt logic will be implemented as a standalone TypeScript library with clear interfaces
• The UI will demonstrate the full flow with mocked merchant data, then integrate real Compact interactions
• A full test suite will validate the contract logic, proof generation, and disclosure flow
• Documentation will describe repo structure, tutorials, and extension points for other developers

This proposal is intentionally small in scope but technically complete, aligning with expectations for a Reference DApp and ensuring a deliverable that developers can run, extend, and learn from.

[Final Pitch] Budget & Costs

Please provide a cost breakdown of the proposed work and resources

The total requested budget covers the developer’s time required to design, implement, test, and document a fully functional reference DApp within the three-month timeline. No external services or subcontractors are used; all work is completed by a single developer.

Estimated time commitment

10–12 hours per week x 12 weeks

Total: ~120–140 hours

Hourly rate

Based on typical independent blockchain engineering rates and my experience across multiple chains (EVM, Solana, Cosmos, ICP) and six years of TypeScript development, an hourly rate of $70–$85 is reasonable for specialized Compact/Midnight work.

Cost allocation by milestone

• Milestone 1: Contract + Repository (20%)
  • $2,000 (contract design, coding, initial tests, repo setup, documentation)
• Milestone 2: UI + Lace Integration (30%)
  • $3,000 (UI development, wallet integration, integration tests, developer docs)
• Milestone 3: Full PoC, Test Suite, Video, Report (50%)
  • $5,000 (end-to-end system completion, full testing, final README, video, report)

Total Requested Budget: $10,000

Justification

This budget reflects the full development effort required to deliver a technically complete, reusable, open-source reference DApp that demonstrates the selective-disclosure matching pattern on Midnight. All deliverables map directly to the expected outputs defined for this category: contract, UI, wallet integration, tests, documentation, PoC demonstration, and final report.

[Final Pitch] Value for Money

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

The requested budget represents strong value because it produces a complete, open-source Reference DApp that demonstrates a new selective-disclosure pattern on Midnight. All costs map directly to hands-on engineering work: Compact contract development, UI and Lace integration, full test coverage, and clear documentation.

By delivering a reusable technical blueprint under a permissive license, this project lowers the barrier for future builders and accelerates ecosystem growth. The scope is efficiently executed by a single experienced developer, making the investment both cost-effective and high-impact for the Midnight ecosystem.

[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