PyMidnight – Reference DApp & Python SDK for Midnight

[Proposal setup] Proposal title

Please provide your proposal title

PyMidnight – Reference DApp & Python SDK for 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?

Python developers lack a clear Reference DApp and simple SDK to connect to Midnight and call Compact contracts, making it hard to start building privacy-preserving dApps.

[Proposal Summary] Supporting Documentation

Supporting links

• https://github.com/ADA-BAMBOO/pymidnight.git
,
• https://t.me/Cardano_ECO_VN

[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

This project is publicly available under the Apache License 2.0, which gives you the freedom to use, copy, modify, and distribute the source code, including for commercial purposes.

[Theme Selection] Theme

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

Developer Tools

[Campaign Category] Category Questions

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

This project is primarily a Reference DApp + developer tool, rather than a production application for a single industry. However, the underlying privacy pattern is relevant for:

• Finance / DeFi / private credit: Storing and selectively revealing transaction metadata, credit notes, or claims.
• Governance / feedback / voting: Recording notes such as votes, feedback, or claims in a privacy-preserving way.
• Innovative & Novel Concepts: The “private note / selective read” pattern can be reused across many privacy-enabled products.

The primary goal is to demonstrate a data-protection pattern (selective access / programmable privacy) on Midnight, not to build a full vertical solution.

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: MinimalSelectiveNote (Compact TypeScript), Purpose:

A small, clear contract that demonstrates:

• How to define Compact entrypoints.
• How to apply programmable privacy for selective access.

Core idea: Users can store a note identified by noteId with protected metadata and later selectively reveal or prove access to it. Key entrypoints (tentative):

1. StoreNote(proof, noteId, encryptedMeta)

• Proof: evidence that the sender meets a simple access policy (e.g., belongs to an allowed group or role).
• NoteId: an identifier for the note or metadata.
• EncryptedMeta: protected metadata related to a financial, governance, or identity-related note.

1. EvealNote(authProof, noteId)

• Only parties with a valid authProof can read or obtain information about the note identified by noteId.

1. The contract will use Compact primitives and Midnight’s privacy-enhancing features to:

• Avoid exposing raw sensitive metadata on the public ledger.
• Demonstrate programmable privacy and selective disclosure in practice.

The logic is intentionally kept simple and focused on the access-control pattern, in line with the “small but technically complete” Reference DApp philosophy.

PyMidnight – Lightweight Python SDK. Goal:

1. Provide a small, readable SDK for Python backends to:

• Configure network access.
• Perform health checks.
• Prepare and submit requests/transactions to Compact contracts.

1. SDK structure (planned):

• pymidnight/config.py - NetworkConfig: base URL, network ID, timeouts, environment configuration.
• pymidnight/client.py - MidnightClient with:

• get_health() – calls a health endpoint or CLI.

• submit_tx(rawTx) – sends a prepared transaction.

• call_contract(entrypoint, args) – helper for invoking Compact contract entrypoints (storeNote, revealNote).

• pymidnight/tx.py - Transaction: a minimal data model for the demo (e.g., sender, noteId, metadata, network, fee).
• pymidnight/cli.py - CLI commands for quick testing and onboarding:

• pymidnight health.

• pymidnight demo-store-note.

• pymidnight demo-reveal-note.

This SDK is deliberately small and focused on developer experience, aiming to be easy to read and extend.

Backend (backend/app.py) - A simple REST API or CLI-based backend that wires PyMidnight to the Compact contract:

• POST /note → maps to storeNote.
• GET /note/{id} → maps to revealNote.

UI - Minimal UI with two main screens:

• Post Note screen:

• Connect Lace (Midnight).

• Input noteId and a demo note/metadata value.

• Submit → triggers a backend call → PyMidnight prepares a transaction → Lace signs and submits.

• Read Note screen:

• Connect Lace.

• Request revealNote for a given noteId.

• Display the (decrypted or selectively revealed) result.

Lace Wallet Integration - Use the official dApp connector to:

• Connect/disconnect Lace.
• Retrieve the active address.
• Request signatures for transactions created using PyMidnight.

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

Planned repository layout:

/README.md, /LICENSE (Apache-2.0), /docs/, /pymidnight/, /contracts/, /backend/, /ui/, /tests/, /scripts/

README & docs content:

1. What it does – summary of the use case and privacy pattern.
2. Why privacy matters – why Midnight is the right fit.
3. How to run locally:

• Install dependencies (Python, Compact/Midnight toolchain).
• Run tests: pytest.
• Deploy the Compact contract demo.
• Run backend and UI, connect Lace.

1. Key files & suggested extensions:

• Guide developers on where to extend or fork the example.

How other developers will learn and reuse:

• DApp developers: Use the contract + UI pattern for their own selective-disclosure applications.
• Python backend developers & integrators: Use PyMidnight for their own Midnight-connected services.
• zk-curious developers: Inspect the Compact contract to understand how programmable privacy is modeled.

Measurable impact:

• GitHub stars, forks, issues, pull requests.
• Downstream projects referencing or reusing PyMidnight.
• Usage in documentation, workshops, or community examples around Midnight.

[Your Project and Solution] Solution

Please describe your proposed solution and how it addresses the problem

The proposed solution is PyMidnight – a combination of a small, focused Reference DApp and a Python SDK for Midnight, designed to clearly demonstrate how to build privacy-preserving dApps with Compact in an end-to-end flow.

The solution consists of four main components:

1. Compact Contract – MinimalSelectiveNote

Implemented in Compact TypeScript, providing a minimal selective access pattern:

• storeNote(proof, noteId, encryptedMeta) allows storing a “note” or protected metadata together with an access proof.
• revealNote(authProof, noteId) only allows parties with a valid authProof to read or obtain information about the note.

The contract uses Midnight privacy primitives to avoid exposing raw data on the ledger and highlights programmable privacy, not just public business logic.

2. Python SDK – pymidnight

Provides a simple abstraction layer for Python backends:

• NetworkConfig for Midnight network configuration.
• MidnightClient with get_health, submit_tx, and call_contract.
• A minimal Transaction model for the demo.
• CLI commands: pymidnight health, pymidnight demo-store-note, pymidnight demo-reveal-note.

Goal: give Python developers a clear entry point to connect to Midnight and call Compact contracts, without having to build integration logic from scratch.

3. Demo Backend

A small FastAPI/Flask-style service acting between the UI and Midnight:

• POST /note → maps to storeNote.
• GET /note/{id} → maps to revealNote.

The backend uses PyMidnight to prepare and send requests/transactions to a Midnight node.

4. Minimal UI + Lace (Midnight) wallet integration

A simple web UI implementing two flows:

• “Post Note”: connect Lace, input noteId and demo data, send to the backend to create a transaction.
• “Read Note”: connect Lace, request to read a note by noteId, display the result.

Integrates the Lace dApp connector to obtain the user address and request transaction signatures.

Overall, the solution delivers a small but technically complete Reference DApp plus a Python SDK with documentation and tests. Midnight developers – especially Python developers – can clone the repo, run the demo, understand the privacy flow, and easily fork/extend it for use cases such as financial claims, anonymous feedback, or sensitive metadata that must be selectively disclosed.

System Structure:

Usefulness – Patterns & Necessity

1. Problem → data-protection pattern mapping

• Problem: there is no clear example for Python developers on how to implement selective access / programmable privacy patterns on Midnight.
• This Reference DApp demonstrates:
  • Sending protected notes/metadata.
  • Restricting read-access via proofs (authProof) on Midnight.

2. Why Midnight + Compact, not a public ledger alone?

• Public ledgers expose metadata, making it difficult to combine privacy with verifiability.
• Midnight with Compact TypeScript:
  • Supports ZKPs and policy-based access.
  • Is designed for use cases like KYC proof, private notes, confidential flows, and compliant privacy.

3. Benefiting developer personas

• DApp developers on Midnight – looking for a clear example of a data-protection pattern.
• Python backend developers & system integrators – wanting to connect existing Python systems to Midnight.
• zk-curious / privacy-focused builders – exploring Compact contracts and privacy-preserving flows.

4. Value delivered

• A fully working, minimal but complete Reference DApp.
• A readable, extensible Python SDK for Midnight.
• Clear documentation and tests, making it simple to onboard and fork.

5. Who benefits?

• Python developers exploring Midnight.
• Teams building privacy-preserving dApps who need concrete reference patterns.
• The broader Cardano & Midnight ecosystem, which gains both a Reference DApp and a Python SDK.

6. Importance for Midnight

• Expands Midnight’s reach beyond TypeScript-first developers.
• Strengthens the library of Reference DApps with a small, well-scoped, technically complete example.

Demonstrates Midnight’s unique positioning: programmable privacy rather than generic smart contracts.

[Your Project and Solution] Impact

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

The project has had significant positive impacts, including:

• Provides a concrete example of privacy-preserving design that can be used in Documentation/ Tutorials/Hackathon starter kits.
• Lowers the barrier for Python developers to contribute to Midnight and, by extension, the Cardano ecosystem.
• Offers a foundation for future production dApps and tools built on top of Midnight.

We are committed to sharing results in a transparent and accessible way:

• A Compact contract.
• A Python SDK.
• A backend.
• A UI + Lace demo, in a single repo focused on developer experience.

[Your Project and Solution] Capabilities & Feasibility

What is your capability to deliver your project with high levels of trust and accountability? How do you intend to validate if your approach is feasible?

The Bamboo Team represents the optimal combination of deep technical expertise and extensive experience within the Cardano/Midnight ecosystem, making us the most suitable team to execute this project:

•Stake pool operators: With over two years of running the BBO stake pool, more than one year operating a Midnight testnet pool, and developing multiple on-chain data-collection bots, we are fully capable of retrieving on-chain data and delivering accurate API services.

• Technical leadership with strong AI/ML capability: Our technical lead has advanced expertise in AI/ML, capable of deploying end-to-end model lifecycles using Python, R, TensorFlow, PyTorch, and LightGBM — from designing data pipelines (SQL, GraphQL, Docker) to deploying on cloud platforms (AWS/Azure/GCP). With many years of management experience in major financial institutions, he also possesses deep knowledge of Basel compliance, regulatory frameworks, and automated underwriting systems at leading banks (TPBank, VietCredit, OCB).

• Catalyst experience: We have successfully completed two proposals in Fund 11 (1100034) — a Concept prototype for a mobile on-chain data collection app — and one proposal in Fund 13 (1300003) for an open-source AI chatbot for Cardano governance.

• Midnight ecosystem engagement: We have built a community of more than 1,300 members dedicated to sharing insights about the Cardano/Midnight ecosystem (https://t.me/Cardano_ECO_VN)..) We also share about Midnight in the events we organize/participate in.

                            Cooperate with Cardano Vietnam to organize an event to share about Cardano and Midnight

Speakers introducing Cardano/Midnight at Bitget X Cardano: Saigon Ledger Night event

Feasibility - Scope is intentionally small and focused:

• One Compact contract.
• One lightweight Python SDK.
• One minimal backend + UI + Lace integration.

· Timeline matches the 3-month, 3-milestone requirement.

Validation approach:

• Automated tests:
  • pytest for the Python SDK and integration flows.
  • Contract tests for MinimalSelectiveNote with sample inputs/outputs.
• End-to-end demos:
  • CLI demo: store and reveal a note.
  • UI demo: connect Lace, post note, read note.
• Public repository:
  • Clear README and docs so others can clone and reproduce the demo.

[Final Pitch] Budget & Costs

Please provide a cost breakdown of the proposed work and resources

Milestone 1 – SDK & Contract Skeleton (Month 1)

Scope: Public repository with Apache-2.0 license, PyMidnight SDK skeleton (config, client, tx, CLI), basic tests, Compact contract skeleton.

Work & resources:

1. Development: ~60 hours × 30 USD/hour = 1,800 USD

Tasks:

• Implement NetworkConfig, MidnightClient (mocked), and Transaction model.
• Implement CLI skeleton (pymidnight health).
• Set up initial test suite (test_client.py, test_tx.py).
• Create minimal-selective-note.compact.ts skeleton (entrypoints, basic structure).
• Project setup with Poetry, pytest, initial README.

2. Infrastructure & tools (CI + basic cloud setup): 250 USD

Milestone 1 total: 2,050 USD

Milestone 2 – Contract Logic + Backend + CLI Demo (Month 2)

Scope: Working Compact logic (storeNote / revealNote), backend integration, CLI demos, contract/integration tests.

Work & resources:

1. Development: ~90 hours × 30 USD/hour = 2,700 USD

Tasks:

• Implement MinimalSelectiveNote logic in Compact.
• Build backend service (backend/app.py) with endpoints /note (POST) and /note/{id} (GET).
• Wire backend to PyMidnight (MidnightClient).
• Implement CLI flows (pymidnight demo-store-note, pymidnight demo-reveal-note).
• Extend tests: test_contract.py, test_integration.py.

2. Infrastructure & tools (runtime & integration testing) - Additional CI and cloud usage (node access / test environment): 300 USD

Milestone 2 total: 3,000 USD

Milestone 3 – UI + Lace Integration + PoC Release (Month 3)

Scope: Minimal UI with Lace wallet integration, end-to-end flow, documentation, PoC release, and light post-PoC maintenance.

Work & resources:

1. Development (UI + Lace + polishing): ~70 hours × 30 USD/hour = 2,100 USD

Tasks:

• Build minimal React/Vite UI (ui/) for Post Note and Read Note flows.
• Integrate Lace dApp connector (connect, get address, sign transactions).
• Final technical cleanup of PyMidnight SDK and backend.
• Finalize documentation (getting-started.md, architecture.md).
• Prepare PoC release (v1.0.0-poc) and demo assets.

2. Light post-PoC maintenance (approx. 6 months): ~20 hours × 30 USD/hour = 600 USD

Tasks:

• Respond to issues and bug reports.
• Apply minor updates if Midnight APIs/tooling change.
• Support early adopters / forking teams at a minimal but reliable level.

3. Infrastructure & tools (final month + demo hosting / storage): 250 USD

Milestone 3 total: 2,950 USD

Total Project Cost: 8,000 USD

[Final Pitch] Value for Money

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

Estimated budget:

• Development (3 months, ~220–240 hours * 30 USD/hour): ≈ 6,600–7,200 USD.
• Infrastructure & tools (6 months) - Small VPS/test node, CI, optional domain: ≈ 600 USD.
• Light maintenance for 6 months post-PoC (24 hours * 25 USD/hour): 600 USD.

Total requested: 8,000 USD

(within the 2,500–10,000 USD range for Midnight Compact DApps).

Value to Cardano & Midnight ecosystem- For a modest budget, the ecosystem gains:

• A fully working Reference DApp that showcases a real privacy pattern.
• A Python SDK for Midnight that can serve as a starting point for many other tools and services.
• Documentation and tests that improve the overall developer experience and reduce onboarding friction for new builders.

[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