This topic is to discuss the proposal submitted by @highonrice.
Please see below for the details of the proposal and discussion.
5th February, 2025
Current status: Funded
Funding Note: This proposal is approved for funding. This aligns with the new focus areas (provable web2 data/zkTLS use cases) where we want the applications to be built.
27th January, 2025
Current Status: Under Consideration.
Opened for community discussion on: 27th January, 2025.
zkDonation is a zero-knowledge application (zkApp) built on the Mina Protocol that enhances privacy and transparency in charitable giving. By integrating APIs from major donation platforms (e.g., Every.org), zkDonation allows users to make donations to verified charities and generate cryptographic proofs of their donations without exposing personal or transactional details.
The platform ensures that donations are verifiable on-chain while maintaining donor privacy. It targets individuals, corporations, and organizations prioritizing privacy and transparency in their philanthropic activities.
While many Web3 users make donations to charities, there is no way to link verified donations to their on-chain identity. Also, traditional online donation services often compromise privacy and are centralized. Tax authorities require proof of donation for deductions, which typically involves sharing receipts and personal details. A blockchain-native donation verification solution is needed to:
zkDonation combines zero-knowledge technology with blockchain to:
It operates with four main components:
A typical user journey is as follows:
webhook_token.webhook_token.In the long term, zkDonation aims to become the standard for privacy-preserving donation systems, integrating with more donation APIs, and supporting global charities. It seeks to inspire similar zk applications across various sectors.
N/A - This is a new project
B62qrFsS1pLuqXvSSKReij7RKE6K5b2RLbztm2MoYyv7B62aNU5Xzw2
Posting this on behalf of @andrewferrone.
Is it possible to add a use case to the platform? Maybe a simple leaderboard where you climb the charts by registering your donations? I’d love to see some idea for attracting users once the platform is there.
Hey @highonrice and team! Juanjo from ZKON here.
First of all, I think this is a great idea and a nice use case for ZK privacy, congrats!
But I have a few questions about the implementation itself:
The API server, the one who receives the donation info via the webhook, will be maintained by you guys? And this will be the one running the ZKON SDK?
Also, about step 8 and 9, I’ve been checking the every.org API docs, but I don’t see an endpoint to get the information back using the chargeId field. Do you know if it exists? Or is there any other endpoint that we can use to retrieve the information from every.org and compare it to the webhook data? If that exists, then we can notarize the request to this endpoint using our SDK and generate a Zk proof of this.
Hi, thanks for suggesting a good idea! I can add a leaderboard once the basic features are all implemented. Maybe users can get badges based on their donation amount by leveraging MinaNFT.
Hi, thanks for the questions.
For the first question, yes the API server will be maintained ourselves and it will run the ZKON SDK.
For the second, maybe it is better to use Pledge.to API rather than Every.org API. If possible, could you look at Pledge API? I guess Pledge has better API than Every
Hi,
Yep, I think Pledge is more feasible, since they also have the webhook and an endpoint for getting the donations, and you can filter by id.
Awesome.
Great. Then I will use Pledge.to for this zkApp!
This proposal is approved for funding. This aligns with the new focus areas (provable web2 data/zkTLS use cases) where we want the applications to be built.
Looking forward to the update. Thanks!
Hi all, sharing the latest progress on zkDonation.
Over the past two weeks, we’ve laid the groundwork for zkDonation like UI design and prototyping smart contracts.
Here’s what we’ve been up to:
The UI is shaping up to be intuitive and accessible, ensuring donors can navigate the platform with ease. We’re finishing the design and expect to complete this phase by the end of next week. Regardless of the completion of the design, we will start building the app.
We’ve also made headway on the smart contract side of the project. Please refer to the code here. Our team has developed a prototype for the core smart contract logic that will power zkDonation. The code implements a zk donation system where donors can contribute amounts privately. It verifies donations without revealing sensitive details like the donation amount. The system uses a Merkle tree to track commitments (hashed values representing donation states) for each donor. Please note that this is a very primitive version of the work we will make, and we will keep progressing with the codes along the way.
export let ZkonProof_ = ZkProgram.Proof(mockZkProgram);
export class ZkonProof extends ZkonProof_ { }
class DonationPublicInput extends Struct({
donor: PublicKey,
oldCommitment: Field,
newCommitment: Field,
zkOnProof: ZkonProof,
}) { }
const DonationProgram = ZkProgram({
name: "DonationProgram",
publicInput: DonationPublicInput,
methods: {
proveDonation: {
privateInputs: [Field, Field, Field, Field, Field], // oldTotalAmount, oldRandomness, newDonationAmount, newTotalAmount, newRandomness
method: async (
input: DonationPublicInput,
oldTotalAmount: Field,
oldRandomness: Field,
newDonationAmount: Field,
newTotalAmount: Field,
newRandomness: Field
) => {
// Verify the old commitment
const computedOldCommitment = Poseidon.hash([oldTotalAmount, oldRandomness]);
computedOldCommitment.assertEquals(input.oldCommitment);
// Verify the new total amount
newTotalAmount.assertEquals(oldTotalAmount.add(newDonationAmount));
// Verify the new commitment
const computedNewCommitment = Poseidon.hash([newTotalAmount, newRandomness]);
computedNewCommitment.assertEquals(input.newCommitment);
// Ensure the new donation amount is positive
newDonationAmount.assertGreaterThan(Field(0));
// Verify the ZKON proof
await input.zkOnProof.verify();
},
},
},
});
class DonationProof extends Proof<DonationPublicInput, Void> {
static program = DonationProgram;
static publicInputType = DonationPublicInput;
static publicOutputType = Void;
}
class DonationEvent extends Struct({
donor: PublicKey,
}) { }
export class DonationZkApp extends SmartContract {
// TODO: this should be extended to incorporate various users and donations
@state(Field) treeRoot = State<Field>();
init() {
this.treeRoot.set(Field(0));
}
@method async donate(proof: DonationProof, witness: MerkleMapWitness) {
// Verify the ZK proof
proof.verify();
const input = proof.publicInput;
input.donor.assertEquals(this.sender.getUnconstrained());
const userKey = Poseidon.hash(input.donor.toFields());
const currentRoot = this.treeRoot.get();
this.treeRoot.get().assertEquals(currentRoot);
// Use the witness to verify the old commitment and compute the new root with the new commitment
const [computedRoot, key] = witness.computeRootAndKey(input.oldCommitment);
computedRoot.assertEquals(currentRoot);
key.assertEquals(userKey);
const [newRoot, _] = witness.computeRootAndKey(input.newCommitment);
this.treeRoot.set(newRoot);
// Event emission
this.emitEvent("donation", new DonationEvent({ donor: input.donor }));
}
}
Happy to receive feedback from the community.