### Terms and Conditions
- [x] I agree to the [Grant Agreement](https://9ba4718…c-5c73-47c3-a024-4fc4e5278803.usrfiles.com/ugd/9ba471_f81ef4e4b5f040038350270590eb2e42.pdf) terms if funded
- [x] I agree to [Provide KYC information](https://9ba4718c-5c73-47c3-a024-4fc4e5278803.usrfiles.com/ugd/9ba471_7d9e73d16b584a61bae92282b208efc4.pdf) if funded above $50,000 USD
- [x] I agree to disclose conflicts of interest
- [x] I agree to adhere to the [Code of Conduct](https://forum.zcashcommunity.com/t/zcg-code-of-conduct/41787) and [Communication Guidelines](https://forum.zcashcommunity.com/t/zcg-communication-guidelines/44284)
- [x] I understand all milestone deliverables will be validated and accepted by their intended users or their representatives, who will confirm that the deliverables meet the required quality, functionality, and usability for each user story.
- [x] I agree that for any new open-source software, I will create a `CONTRIBUTING.md` file that reflects the high standards of Zcash development, using the [`librustzcash` style guides](https://github.com/zcash/librustzcash/blob/main/CONTRIBUTING.md#styleguides) as a primary reference.
- [x] I understand when contributing to existing Zcash code, I am required to adhere to the project specific contribution guidelines, paying close attention to any [merge](https://github.com/zcash/librustzcash/blob/main/CONTRIBUTING.md#merge-workflow), [branch](https://github.com/zcash/librustzcash/blob/main/CONTRIBUTING.md#branch-history), [pull request](https://github.com/zcash/librustzcash/blob/main/CONTRIBUTING.md#pull-request-review), and [commit](https://github.com/zcash/librustzcash/blob/main/CONTRIBUTING.md#commit-messages) guidelines as exemplified in the `librustzcash` repository.
- [x] I agree to post request details on the [Community Forum](https://forum.zcashcommunity.com/c/grants/33)
- [x] I understand it is my responsibility to post a link to this issue on the [Zcash Community Forums](https://forum.zcashcommunity.com/c/grants/33) after this application has been submitted so the community can give input. I understand this is required in order for ZCG to discuss and vote on this grant application.
### Application Owners (@Octocat, @Octocat1)
Mharris40
### Organization Name
Maranda Harris
### How did you learn about Zcash Community Grants
Through the Zcash community forum and GitHub, and by following Zcash ecosystem updates and developer discussions.
### Requested Grant Amount (USD)
$25,000
### Category
Research & Development
### Project Lead
```project-lead.yaml
Name: Maranda Harris
Role: Project Lead
Responsibilities:
Maranda Harris will be responsible for overseeing the full design, implementation, documentation, testing, and delivery of the project. This includes cryptographic design, Zcash-aligned proof construction, library and CLI development, documentation, and open-source release management.
```
### Additional Team Members
```team-members.yaml
Name: Satyam Singhal
Role: Lead Developer
Responsibilities:
Willbe responsible for the full design, implementation, documentation, testing, and delivery of the project. This includes cryptographic design, Zcash-aligned proof construction, library and CLI development, documentation, and open-source release management.
```
### Project Summary
ZProof is an open-source, Zcash-native cryptographic library that enables developers to generate and verify privacy-preserving proofs of data existence and integrity without revealing the underlying data.
### Project Description
ZProof is an open-source, Zcash-native cryptographic library designed to provide developers with a simple, reusable primitive for proving data existence and integrity in a privacy-preserving manner.
Many applications built on privacy-focused systems require a way to demonstrate that a piece of data existed at a specific point in time and has not been modified, without revealing the data itself. Today, Zcash developers often rely on ad-hoc hashing approaches or external systems to achieve this, which increases complexity, fragments tooling, and can weaken privacy guarantees.
ZProof addresses this gap by delivering a lightweight proof primitive that allows developers to generate and verify cryptographic proofs that attest to:
• the existence of data at or before a given Zcash block height, and
• the integrity of that data over time,
without exposing the underlying data, metadata, or private context.
The project focuses exclusively on cryptographic proof generation and verification. It does not implement application logic, workflows, policies, or higher-level systems. Instead, ZProof is intended to serve as a foundational building block that developers can integrate into wallets, applications, research projects, or experimental tools within the Zcash ecosystem.
ZProof will be delivered as a developer library with a reference command-line interface (CLI), documentation, and test vectors. The library will allow developers to:
• locally generate proofs of data existence and integrity,
• optionally bind proofs to Zcash block references,
• independently verify proofs using open-source tooling.
All work will be released under a permissive open-source license and developed transparently in public repositories. The primary goal of ZProof is to strengthen the Zcash developer ecosystem by providing a clear, reusable, and privacy-preserving proof primitive that reduces the need for custom implementations and supports experimentation with trust-minimized applications on Zcash.
### Proposed Problem
Zcash developers currently lack a simple, standardized, privacy-preserving way to prove that data existed at a specific point in time and has not been altered, without revealing the data itself.
As a result, developers often rely on ad-hoc hashing schemes, external timestamping services, or custom verification logic. These approaches increase complexity, fragment tooling across the ecosystem, and can weaken privacy guarantees by requiring unnecessary disclosure or reliance on third-party systems.
Without a reusable, Zcash-native proof primitive for data existence and integrity, developers must repeatedly re-implement similar logic, slowing experimentation and increasing the risk of implementation errors. This gap limits the ability to build trust-minimized applications and research tools that require verifiable integrity while preserving Zcash’s privacy properties.
ZProof addresses this problem by providing a focused cryptographic primitive that developers can reuse across applications, reducing duplication and strengthening privacy-preserving development on Zcash.
### Proposed Solution
ZProof solves this problem by providing a lightweight, Zcash-native cryptographic library that enables developers to generate and verify privacy-preserving proofs of data existence and integrity without revealing the underlying data.
The library allows data to be committed locally using cryptographic hashing, after which a proof is generated attesting that the data existed at or before a specific Zcash block height and has not been modified. These proofs can be independently verified using open-source tooling, without requiring access to the original data, private keys, or trusted third parties.
ZProof is intentionally designed as a narrow, reusable primitive rather than a full application or framework. It focuses exclusively on proof generation and verification and does not include application logic, workflows, or higher-level systems. Developers can integrate the library into their own tools, experiments, or applications as needed.
By delivering a standardized proof primitive and reference implementation, ZProof reduces the need for custom ad-hoc solutions, improves developer ergonomics, and supports experimentation with trust-minimized, privacy-preserving applications within the Zcash ecosystem.
### Solution Format
ZProof will be delivered as an open-source software project with the following components:
• Cryptographic Library:
A Zcash-native library that provides functions for generating and verifying privacy-preserving proofs of data existence and integrity.
• Command-Line Interface (CLI):
A reference CLI tool that demonstrates proof creation and verification workflows for developers and researchers.
• Proof Specification & Test Vectors:
Documentation describing the proof format, verification requirements, and example test vectors to support reproducibility and independent validation.
• Documentation & Examples:
Developer-focused documentation, including usage examples and integration guidance.
All deliverables will be released publicly under a permissive open-source license and developed transparently in a public repository.
### Dependencies
ZProof has minimal external dependencies and is designed to be developed as a self-contained, open-source project.
Technical Dependencies:
• Zcash protocol documentation and public specifications
• Standard cryptographic libraries compatible with Zcash (e.g., hashing, commitment schemes)
• Common open-source development tooling (e.g., Rust toolchain, testing frameworks)
Resource Dependencies:
• Public code repository for development and issue tracking
• Local development and testing environment
• Standard CI/testing setup for open-source projects
Collaborations:
• No formal dependencies on external teams or organizations
• Optional community feedback from Zcash developers during development and review
ZProof does not require proprietary software, paid third-party services, private datasets, or exclusive partnerships to complete the project.
### Technical Approach
ZProof will be implemented as a lightweight open-source library with a reference CLI, focused strictly on cryptographic proof generation and verification for data existence and integrity.
Methodology:
1. Local Commitment Creation
• Input data is processed locally to compute a cryptographic digest (hash) and commitment.
• No raw data is published or transmitted.
2. Time Binding to Zcash
• Proofs will be bound to a Zcash time reference (e.g., block height or block hash) to support “existed at or before time T” claims.
• Where appropriate, an optional anchoring mechanism may be provided to associate commitments with Zcash chain references.
3. Proof Artifact Generation
• ZProof will generate a compact proof artifact containing the commitment, time reference, and verification metadata.
• Proof artifacts will be designed to be versioned and reproducible.
4. Verification Tooling
• A verifier will validate the proof artifact deterministically using open-source logic.
• Verification will not require the original data, private keys, or trusted third parties.
5. Testing & Reproducibility
• Unit tests and test vectors will be developed to validate proof generation and verification.
• CI will be used to ensure deterministic verification across environments.
Tools / Implementation Stack (planned):
• Rust for the core library and CLI
• Standard open-source cryptography libraries (hashing/commitment utilities)
• GitHub for open development, issues, and releases
• Automated testing and CI for reproducibility
ZProof will remain narrowly scoped to the proof primitive and developer tooling only, with all deliverables released under a permissive open-source license.
### Upstream Merge Opportunities
ZProof does not require forking or modifying upstream Zcash repositories in order to deliver its core functionality. The project is intentionally designed as an external, Zcash-native library and CLI that operates independently of consensus code and wallet internals.
Upstream repositories to fork/modify:
• None required (no planned forks of zcashd, librustzcash, or wallet repositories).
Planned changes:
• No direct changes to upstream Zcash software are required for implementation.
Potential upstream merge value (optional):
If maintainers are interested, the project may propose optional upstream contributions such as:
• Documentation improvements or developer guidance related to proof primitives
• Reference examples or test utilities that could help Zcash developers
• Reusable helper modules (if appropriate and maintainable)
These would be submitted only if they are clearly beneficial and acceptable to maintainers.
Coordination with upstream maintainers:
• Not required for project delivery.
• Any optional upstream contributions would be coordinated through standard GitHub PR processes and maintainer feedback.
Timeline considerations:
• No upstream merge dependencies exist.
• Any optional upstream PRs would occur after the initial release and stabilization of ZProof, based on maintainer interest and community feedback.
### Hardware/Software Costs (USD)
$1,000
### Hardware/Software Justification
This covers standard development hardware usage, local testing environments, and basic open-source tooling required to build, test, and release the library and CLI. No specialized hardware, proprietary software, or paid third-party services are required.
### Service Costs (USD)
0
### Service Costs Justification
The project does not require paid external services, consultants, proprietary APIs, audits, or third-party platforms. All work will be completed using open-source tools and self-managed infrastructure.
### Compensation Costs (USD)
$24000
### Compensation Costs Justification
Compensation funds will be used to support the time and effort required to design, implement, test, document, and release the ZProof library and CLI.
The project will be primarily executed by the Project Lead, with limited supporting development assistance as needed.
• Project Lead (Maranda Harris):
Responsible for overseeing the cryptographic design, core library implementation, CLI development, testing, documentation, and project delivery.
Estimated effort: approximately 20 hours over the project duration, at an effective blended rate consistent with open-source research and development work.
• Senior Developer (Satyam Singhal):
Responsible for developing and implementing the cryptographic design, core library implementation, CLI development, testing, documentation, and project delivery. Estimated effort: approximately 200 hours over the project duration, at an effective blended rate consistent with open-source research and development work.
The compensation amount reflects a reasonable rate for specialized cryptographic and systems development work and represents the majority of the project effort. No funds are allocated for executive compensation, marketing, or non-technical activities.
### Total Budget (USD)
$25000
### Previous Funding
No
### Previous Funding Details
None
### Other Funding Sources
No
### Other Funding Sources Details
_No response_
### Implementation Risks
1. Cryptographic Design Complexity
Designing privacy-preserving proof primitives requires careful selection of cryptographic approaches and thorough validation to avoid errors.
Mitigation:
The project will rely on well-understood cryptographic primitives and conservative design choices. Proof logic will be clearly documented and validated with test vectors and unit tests.
⸻
2. Scope Creep
There is a risk of expanding beyond a simple proof primitive into higher-level application logic.
Mitigation:
The scope is intentionally limited to proof generation and verification only. Application workflows, policy logic, and system integrations are explicitly out of scope.
⸻
3. Time Estimation Risk
As a solo-led project, unexpected complexity could affect delivery timelines.
Mitigation:
Milestones are structured conservatively, and the project avoids experimental or protocol-level changes. Progress will be tracked publicly to ensure transparency.
⸻
4. Developer Adoption Uncertainty
Adoption may be limited if the tooling is unclear or difficult to integrate.
Mitigation:
Clear documentation, examples, and a reference CLI will be provided to lower the barrier for developers.
### Potential Side Effects
1. Misinterpretation of Proof Guarantees
Users may assume that proofs generated by ZProof provide guarantees beyond data existence and integrity (e.g., correctness of external processes or application logic).
Mitigation:
Documentation will clearly define the scope and limitations of the proofs and emphasize that ZProof only attests to existence and integrity, not broader system behavior.
⸻
2. Improper Use of Proofs
Proof artifacts could be reused or presented out of context if not properly scoped.
Mitigation:
Proof formats will include explicit metadata such as versioning and time references to reduce misuse or ambiguity.
⸻
3. Added Complexity for Developers
Introducing cryptographic tooling may increase complexity for developers unfamiliar with proof systems.
Mitigation:
ZProof will provide simple APIs, clear examples, and a reference CLI to minimize integration difficulty.
⸻
4. Overextension Beyond Intended Scope
There may be interest in extending ZProof beyond its intended primitive use.
Mitigation:
The project will maintain a narrow scope and clearly document which features are intentionally out of scope.
### Success Metrics
The success of ZProof will be evaluated based on the following criteria:
• Functional Delivery:
The library and CLI successfully generate and verify proofs of data existence and integrity as described in the project scope.
• Reproducibility:
Proof verification is deterministic, with published test vectors and passing automated tests.
• Documentation Quality:
Clear, complete documentation and usage examples are published and sufficient for independent developer use.
• Open-Source Release:
All code, documentation, and specifications are released publicly under a permissive open-source license.
• Milestone Completion:
All project milestones are completed on time and within the approved budget.
• Community Feedback (Optional):
Feedback or engagement from Zcash developers indicating the tooling is understandable and usable.
### Startup Funding (USD)
$0
### Startup Funding Justification
No startup funding is required to begin this project. Initial design, planning, and repository setup can be started without additional upfront costs using existing resources and open-source tooling.
All substantive development, implementation, testing, documentation, and release activities are scoped to occur after grant approval and are fully covered by the requested grant amount. This approach ensures that grant funds are used exclusively for funded project execution rather than reimbursing pre-existing work or expenses.
### Milestone Details
```milestones.yaml
Milestone 1 — Cryptographic Design & Specification
Duration: 3 weeks
Budget: $5,000
User Stories:
• As a Zcash developer, I want a clear specification of the proof model so I can understand what guarantees ZProof provides.
• As a cryptography reviewer, I want the proof design and threat model documented so I can assess correctness and privacy assumptions.
• As a contributor, I want a well-defined scope so the project remains focused on a single cryptographic primitive.
Deliverables:
• Cryptographic design document describing the proof model
• Proof of existence and integrity specification
• Threat and privacy model
• Initial repository structure and documentation
Acceptance Criteria:
• Design and specification documents are published in the public repository
• Proof scope, assumptions, and limitations are clearly documented
• Threat and privacy model is complete and accessible
⸻
Milestone 2 — Core Library Implementation
Duration: 6 weeks
Budget: $12,000
User Stories:
• As a developer, I want to generate proofs of data existence and integrity using a simple library API.
• As a verifier, I want to independently verify proofs without access to the original data.
• As a researcher, I want deterministic proof behavior with test vectors to validate correctness.
Deliverables:
• ZProof core library implementing proof generation
• Proof verification logic
• Versioned proof format
• Unit tests and test vectors
Acceptance Criteria:
• Proofs can be generated deterministically
• Proofs can be verified independently using the library
• Automated tests and test vectors pass successfully
• Code is publicly available under an open-source license
⸻
Milestone 3 — CLI, Documentation & Release
Duration: 3 weeks
Budget: $8,000
User Stories:
• As a developer, I want a CLI to easily create and verify proofs without writing code.
• As a new user, I want clear documentation and examples to understand how to use ZProof.
• As the Zcash community, I want a stable, documented public release.
Deliverables:
• Command-line interface (CLI) for proof creation and verification
• Developer documentation and usage examples
• Public release of ZProof
• Final project report
Acceptance Criteria:
• CLI successfully creates and verifies proofs
• Documentation enables independent developer usage
• Public release is tagged and accessible
• Final report is submitted to Zcash Community Grants
```
### Supporting Documents
```files.yaml
- ZProof - Design & Scope Whitepaper
Design and scope overview for ZProof, describing the project goals, in-scope and out-of-scope functionality, high-level architecture, planned deliverables, and milestones for a Zcash-native cryptographic proof primitive.
https://docs.google.com/document/d/1QAgZMTo_eKJu-tKfejMkInWdp3BvhcKM/edit?usp=drivesdk&ouid=101981973527074375732&rtpof=true&sd=true
```
,
Grant proposal: