Pre-Event

Event

ZK Podcast

Founder

Anna Rose

Iqlusion

Zaki Manian

Geometry Research

Researcher

Nico Mohnblatt

Gauntlet.xyz

Founder & CEO

Tarun Chitra

zkSecurity

David Wong

Pluto

Tracy Livengood

HashCloak is hiring!

Mikerah

Aleo

Executive Director

Alex Pruden

ZKP2P

Richard Liang

penumbra 🌘

Henry de Valence

Lagrange Labs

Ismael Hishon-Rezaizadeh

Fenbushi Capital

Yuki Yuminaga

Celestia

Engineer

Connor O'Hara

1k(x)

Research Partner

Wei Dai

ZK Hack

Team member

Gaylord Warner

RISC Zero

Nuke

Rami

Sasha

Waylon

Gevulot

Tuomas Mäkinen

Polygon

Héctor Masip Ardevol

Brian Seoung

Roger Taulé i Buxadera

Ignasi Ramos

NovaNet

Wyatt

o1Labs

Gar Walsh

Yoni Mekuria

Martin Minkov

Aligned

Patrick Stiles

zkVerify

Giacomo

ZK Hack Montréal

Thanks to our Prize Partner **ZKV**, the best projects (aka *Top 3*), the project selected by the participants (aka *Hacker's Choice*), and the best technical project (aka *Chewing Glass*) will share a prize amount of $20,000.

Prizes for Top 3, Hackers' Choice & Chewing Glass

Plonky3: Plonky3 is a next-generation ZK proving system toolkit for building use-case specific zk systems, zkVMs and zkEVMs. It offers flexibility with its configurable finite fields and hash functions, enabling optimization across various dimensions, including target hardware and proof efficiency.

**Resources**:

- [https://github.com/Plonky3/Plonky3/tree/main](https://github.com/Plonky3/Plonky3/tree/main)
- A simple Fibonacci implementation using Plonky3: [https://github.com/BrianSeong99/plonky3_fibonacci](https://github.com/BrianSeong99/plonky3_fibonacci)
- Plonky3 Examples of Keccak Air circuits proved and verified using different fields, hash functions: [https://github.com/Plonky3/Plonky3/tree/main/keccak-air](https://github.com/Plonky3/Plonky3/tree/main/keccak-air)

**Requirements**:

Create innovative applications or solutions utilizing the Plonky3 stack. Your project can leverage any aspect of Plonky3, including its support for multiple finite fields and hash functions, high-speed proof generation, and optimization for different hardware. Ideally the solution is actually solving a problem that exists in the industry.

**Criteria**:

Best use of Plonky 3 libraries will be rewarded based off of this criteria; creativity, solution architecture and pitch.

Get plonky with Polygon Plonky3

The zkEVM leverages eSTARK as its proving system to verify the correctness of a batch of Ethereum transactions. Then, it uses proof recursion and aggregation to combine multiple batch proofs into a single proof. This aggregated proof is then sent to an Ethereum SC for verification.

**Resources**:

eSTARK implementation: [https://github.com/0xPolygonHermez/pil-stark/tree/main/src](https://github.com/0xPolygonHermez/pil-stark/tree/main/src)
Introduction to proof recursion: [https://docs.polygon.technology/zkEVM/architecture/zkprover/stark-recursion/](https://docs.polygon.technology/zkEVM/architecture/zkprover/stark-recursion/)
zkEVM proof recursion: [https://github.com/0xPolygonHermez/zkevm-techdocs/blob/main/docs/proof-recursion.pdf](https://github.com/0xPolygonHermez/zkevm-techdocs/blob/main/docs/proof-recursion.pdf)
Circuits:
Recursive:[https://github.com/0xPolygonHermez/zkevm-proverjs/tree/main/recursive](https://github.com/0xPolygonHermez/zkevm-proverjs/tree/main/recursive)
BN128: [https://github.com/0xPolygonHermez/pil-stark/tree/main/circuits.bn128](https://github.com/0xPolygonHermez/pil-stark/tree/main/circuits.bn128)
Goldilocks: [https://github.com/0xPolygonHermez/pil-stark/tree/main/circuits.gl](https://github.com/0xPolygonHermez/pil-stark/tree/main/circuits.gl)

**Requirements**:

Read and understand zkEVM’s proof recursion documentation. Note that the verifier is initially written in Circom and later transpiled to PIL.
Rewrite the verifier directly in PIL. This can be approached either with a monolithic design (one PIL for the entire verifier) or by writing separate pieces of the verifier and merging them using lookups/permutations.

**Criteria**:

This is very straight forward, team's to complete this challenge in it's entirety will be rewarded the bounty. If multiple winners, the bounty will be evenly distributed amongst teams.

eSTARK Verifier

This is for using the zkEngine with privacy enabled. PRIVACY CENTRIC use-case.

**Requirements**:

Need to build a working zkWasm app that uses the privacy features of the zkEngine.

**Criteria**:

Best app that uses NovaNet's zkEngine for a  privacy use-case.

**Resource**:
[https://github.com/ICME-Lab/zkEngine_dev/tree/main](https://github.com/ICME-Lab/zkEngine_dev/tree/main)

Privacy

This is for using the zkEngine without privacy enabled for local verifiable compute. Use-case such as DePin, signatures (zkBLS), gaming.

**Requirements**:

Need to build a working zkWasm app that uses the zkEngine without privacy enabled.

**Criteria**:

Best apps that do not involve privacy.

**Resource**:
[https://github.com/ICME-Lab/zkEngine_dev/tree/main](https://github.com/ICME-Lab/zkEngine_dev/tree/main)

Local Verifiable Compute

The best app built using the zkEngine.

**Requirements**:

Create an amazing app with NovaNet's zkEngine.

**Criteria**:

Best app!

**Resource**:
[https://github.com/ICME-Lab/zkEngine_dev/tree/main](https://github.com/ICME-Lab/zkEngine_dev/tree/main)

Grand prize

Complete o1js Tutorial 1:
[https://docs.minaprotocol.com/zkapps/tutorials/hello-world](https://docs.minaprotocol.com/zkapps/tutorials/hello-world)

First 10 people will earn $100 in MINA each.

**Requirements**:

Be one of the first to complete our hello world tutorial. 

**Criteria**:

- Submit a Github repo with this completed tutorial 
- Cannot have existed before ZK Hack dates 
- Upon completion of this challenge, ping us on Telegram or find an o1Labs team member to show us that you’ve completed the challenge

**Resources**:
[https://o1labs.notion.site/o1Labs-Resources-for-ZKHack-Montreal-99e543deca594402a323cb8c4a6086c5](https://o1labs.notion.site/o1Labs-Resources-for-ZKHack-Montreal-99e543deca594402a323cb8c4a6086c5)

Hello World (o1js)

- Mina is a proof of everything and the o1js SDK allows for elegant composition of proofs.
- To earn this bounty, hackers need to use the unique composition feature of o1js to prove something that depends on another ZK proof

**Requirements**:

- o1js is used to implement key mechanics
- Write a ZkProgram and a SmartContract
- Use a proof generated by the ZkProgram as an input to the SmartContract method or to the ZkProgram itself.
- Project did not exist before ZK Hack

**Criteria**:

- Creativity and novelty of the ZkProgram
- Code completion and quality
- Correctness of implementation
- Documentation

**Resources**:
- [https://o1labs.notion.site/o1Labs-Resources-for-ZKHack-Montreal-99e543deca594402a323cb8c4a6086c5](https://o1labs.notion.site/o1Labs-Resources-for-ZKHack-Montreal-99e543deca594402a323cb8c4a6086c5)

Living Proof

Learn about the latest feature of o1js by building a gaming, defi, or voting zkApp which incorporates the o1js Off-chain State API (Docs: https://docs.minaprotocol.com/zkapps/writing-a-zkapp/feature-overview/offchain-storage)

Building zkApps is easier than ever before. The off-chain state API makes it simple to use off-chain storage solutions for handling large volumes of data. 
So let your imagination run wild and build something we’ve never seen before!

**Requirements**:

- o1js is used to implement key mechanics
- o1js Off-chain State API is used
- Project did not exist before ZK Hack

**Criteria**:

- Creativity
- Code completion and quality
- Correctness of implementation
- Utility & Usability
- Documentation
- Feedback and insight on the o1js Off-chain State API

**Resources**:
- [https://o1labs.notion.site/o1Labs-Resources-for-ZKHack-Montreal-99e543deca594402a323cb8c4a6086c5](https://o1labs.notion.site/o1Labs-Resources-for-ZKHack-Montreal-99e543deca594402a323cb8c4a6086c5)

Unleash your creativity with o1js!

[See description here](https://docs.google.com/document/d/11Js79bMfSRXlBM_V-mH4EkBKsqKEgGP67rOE9Oo45Gg/edit?usp=sharing)

**Requirements**:

See the requirements also from the same docs: [https://docs.google.com/document/d/11Js79bMfSRXlBM_V-mH4EkBKsqKEgGP67rOE9Oo45Gg/edit?usp=sharing](https://docs.google.com/document/d/11Js79bMfSRXlBM_V-mH4EkBKsqKEgGP67rOE9Oo45Gg/edit?usp=sharing)

**Criteria**:

- The prover should be used by a public ZK-rollup
- The prover should accept a witness and generate a valid proof
- The verification must succeed using the proof as input

Hint: zkSync just released their prover ;)

Port a ZK-rollup prover to Gevulot

[See description here](https://docs.google.com/document/d/11Js79bMfSRXlBM_V-mH4EkBKsqKEgGP67rOE9Oo45Gg/edit?usp=sharing)

**Requirements**:

See the requirements also from the same docs: [https://docs.google.com/document/d/11Js79bMfSRXlBM_V-mH4EkBKsqKEgGP67rOE9Oo45Gg/edit?usp=sharing](https://docs.google.com/document/d/11Js79bMfSRXlBM_V-mH4EkBKsqKEgGP67rOE9Oo45Gg/edit?usp=sharing)

**Criteria**:

- The prover should accept a witness and generate a valid proof using the ICICLE library for GPU acceleration
- The verification must succeed using the proof as input

Build a GPU-accelerated prover using ICICLE on Gevulot

[See description here](https://docs.google.com/document/d/11Js79bMfSRXlBM_V-mH4EkBKsqKEgGP67rOE9Oo45Gg/edit?usp=sharing)

**Requirements**:

See the requirements also from the same docs: [https://docs.google.com/document/d/11Js79bMfSRXlBM_V-mH4EkBKsqKEgGP67rOE9Oo45Gg/edit?usp=sharing](https://docs.google.com/document/d/11Js79bMfSRXlBM_V-mH4EkBKsqKEgGP67rOE9Oo45Gg/edit?usp=sharing)

**Criteria**:

- It should use multiple witnesses as inputs
- It should perform multiple proofs
- The results of those proofs should provide the inputs of the recursive proof
- Verification must succeed using the recursive proof as input

Demonstrate recursive proofs on Gevulot

[HMAC](https://en.wikipedia.org/wiki/HMAC) is a *message authentication code* that allows you to verify both:

- Data integrity
- Authenticity

of a message. We currently have no tool like this in *ronkathon*. It involves using multiple primitives together.

### Requirements

An implementation of HMAC-SHA256 using *ronkathon*'s SHA256 hash satisfying:

1. Thorough documentation of the protocol.
2. Passing example tests against a trusted implementation.
3. A binary that allows for a user to engage in the protocol.

### Resources

Github Issue: https://github.com/pluto/ronkathon/issues/109

Wikipedia overview: [https://en.wikipedia.org/wiki/HMAC](https://en.wikipedia.org/wiki/HMAC)

HMAC Generator/Tester: [https://www.freeformatter.com/hmac-generator.html](https://www.freeformatter.com/hmac-generator.html)

How HMAC Works Step By Step: [https://medium.com/@short_sparrow/how-hmac-works-step-by-step-explanation-with-examples-f4aff5efb40e](https://medium.com/@short_sparrow/how-hmac-works-step-by-step-explanation-with-examples-f4aff5efb40e)

What is HMAC?: [https://www.geeksforgeeks.org/what-is-hmachash-based-message-authentication-code/](https://www.geeksforgeeks.org/what-is-hmachash-based-message-authentication-code/)

*ronkathon*:
- [https://github.com/pluto/ronkathon/](https://github.com/pluto/ronkathon/)
- [https://pluto.xyz/blog/ronkathon-learn-cryptography-from-first-principles](https://pluto.xyz/blog/ronkathon-learn-cryptography-from-first-principles)

### Criteria

The winner will be selected based on the following criteria, in this order:

1. **Thorough convincing that the implementation is completely correct.** (Requirements at least met.)
2. **Code clarity and quality.** This means succinct code that is easy to follow, naming, minimal use of other resources (no outside crates, please), use of Rust’s type system for flexibility and security (e.g., compile time checks where possible). Optimizations are a bonus, but should be de-prioritized for clarity. (Bonus points: If you want to add in slick optimizations, please gate these behind a feature!)
3. **Documentation quality.** Other modules in *ronkathon* have wonderful READMEs, Cargo docs, and inline comments where code itself is not clear enough. *ronkathon* is primarily an educational toolbox and playground. We prioritize clarity, readability, and our contributors’ ability to learn and grow over anything. Help us maintain this quality throughout!
4. **Binary engagement:** The included binary can be fairly simple, but the more intuitive and interactive the binary is, the better. This would likely be the first program a user can launch with  *ronkathon* so please make sure to organize this well, document its use, and make using it interesting and engaging! This is your chance to be extra creative.

HMAC-SHA256

AES-CTR and AES-GCM are [block cipher modes of operation](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation) for the [AES block cipher](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) that are, specifically, *counter modes.* The effect is that the block cipher becomes a stream cipher. 

1. [CTR (Counter)](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Counter_(CTR)) mode: Provides confidentiality.
2. [GCM (Galois/Counter Mode)](https://en.wikipedia.org/wiki/Galois/Counter_Mode): Provides both confidentiality and authentication.

These implementations will expand *ronkathon*'s AES implementation to include tools that are currently used in production today.

### Requirements

Implementations of AES-CTR and AES-GCM using *ronkathon*'s existing AES implementation, satisfying:

1. Thorough documentation of both modes of operation.
2. Passing example tests against trusted implementations for both modes.
3. A binary that allows users to engage with both protocols.

### Resources

- Github Issue: https://github.com/pluto/ronkathon/issues/140
- Wikipedia Block cipher mode of operation: https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation
- Wikipedia Galois/Counter Mode: https://en.wikipedia.org/wiki/Galois/Counter_Mode
- NIST SP 800-38A (CTR mode with test vectors): [https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38a.pdf](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38a.pdf)
- NIST SP 800-38D (GCM mode with test vectors): [https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf)
- NIST GCM spec (with GHASH test vectors): https://csrc.nist.rip/groups/ST/toolkit/BCM/documents/proposedmodes/gcm/gcm-spec.pdf
- Difference in Five Modes in AES: https://www.highgo.ca/2019/08/08/the-difference-in-five-modes-in-the-aes-encryption-algorithm/
- AES-GCM explanation: [https://crypto.stackexchange.com/questions/17999/how-does-gcm-aes-work](https://crypto.stackexchange.com/questions/17999/how-does-gcm-aes-work)
- *ronkathon*:
    - [https://github.com/pluto/ronkathon/](https://github.com/pluto/ronkathon/)
    - [https://pluto.xyz/blog/ronkathon-learn-cryptography-from-first-principles](https://pluto.xyz/blog/ronkathon-learn-cryptography-from-first-principles)

### Criteria

The winner will be selected based on the following criteria, in this order:

1. **Correctness and security:** Thorough convincing that both implementations are completely correct and secure. All requirements must be met.
2. **Code clarity and quality:** Succinct, easy-to-follow code with appropriate naming conventions. Utilize Rust's type system for flexibility and security (e.g., compile-time checks where possible). Avoid external crates. Optimizations should be a lower priority than clarity, but can be included behind a feature flag as a bonus.
3. **Documentation quality:** Provide comprehensive READMEs, Cargo docs, and inline comments where code itself is not self-explanatory. Remember that *ronkathon* is primarily an educational toolbox, so prioritize clarity and readability to facilitate learning.
4. **Binary engagement:** Create an intuitive and interactive binary that allows users to experiment with both AES-CTR and AES-GCM. Document its usage clearly and make it engaging for first-time users of *ronkathon*. This is an opportunity to showcase creativity in user interaction and educational value.
5. **Comparison and vulnerability analysis:** As a bonus, include a brief comparison of AES-CTR and AES-GCM, highlighting their strengths, weaknesses, and appropriate use cases. This will enhance the educational value of the implementation. Can you show where either of the two are vulnerable?

Remember, *ronkathon* prioritizes learning and growth. Your contribution should maintain this focus throughout the implementation and documentation process.

AES-CTR and AES-GCM

zkVerify is a blockchain designed to provide ZK proof verifications for any project or dApp using ZK proofs. A high performance, public, decentralized, reliable, and secure blockchain, zkVerify has dedicated proof verification methods written in Rust, and available to be used in a modular and composable way.

zkVerify is uniquely positioned to reduce the cost and time to finality of a wide range of ZK applications. Games, identity solutions, private voting, and private transactions are just some of the applications that stand to benefit from using zkVerify.

This bounty rewards hackers who create the most innovative application that uses the zkVerify protocol for ZK proof verification.

**Resources**:
 
Website: [https://zkverify.io/](https://zkverify.io/)
Documentation: [https://docs.zkverify.io/](https://docs.zkverify.io/)
Whitepaper: [https://downloads.horizenlabs.io/file/labs-web-assets/zkverify-protocol-whitepaper.pdf](https://downloads.horizenlabs.io/file/labs-web-assets/zkverify-protocol-whitepaper.pdf)
Tutorial: [https://docs.zkverify.io/tutorials/tutorials/](https://docs.zkverify.io/tutorials/tutorials/)

**Requirements**:

Application must use zkVerify to verify ZK proofs with any of the verifiers available (Groth16 (either curve), RiscZero STARK, Fflonk, zkSync Era, UltraPlonk).

A clear README file with a short-sentence description of your app, team and background, execution process, problems you faced and what you would do different.

**Criteria**:

Innovation and Utility. How innovative is the application? How practical is it to use? 

Bonus points for developing a front end that simplifies the proof verification submission process to zkVerify.

Documentation quality (Description, code quality, problems faced and feedback)

Best application that uses zkVerify to verify ZK proofs

Best zkVM projects - anything that uses our tooling! There are no specific use cases we are looking for, so be as creative as you’d like. ✨

**Requirements**:

Open-ended prize! The only strict requirement is that your submission uses *any* zkVM. We would love to see you use RISC Zero, but this isn’t a strict requirement. Extra points towards applications that solve real world problems over web3 industry self-serving solutions/tools, etc.

**Criteria**:

Subjective based on team evaluation of presentation and source code.

🤩 Best zkVM Application

The RISC Zero Foundry Template makes it easy to get started with both the on-chain and off-chain parts of a blockchain coprocessor application. This provides a starting point for building powerful new applications on Ethereum that offload computationally intensive (i.e. gas expensive), or would be difficult or impossible to implement Solidity & the EVM.

**Requirements**:

Submissions should offload computation from on-chain to off-chain. Special consideration will be given to projects that utilize our Steel View Call Proofs Library.

**Criteria**:

Subjective based on team evaluation of presentation and source code.

🤝 ZK Coprocessor

There are so many ways to integrate zk proof systems into various on and off-chain applications to add value and unlock new possibilities - many yet to be discovered! We want to pay you to build a novel integration for any other sponsor bounty’s platform.

**Requirements**:

Submissions must be new or non-trivial improvements or extensions of RISC Zero integrations with another sponsor’s platform/tooling/app. Bonus points winning their bounties as well!

**Criteria**:

Subjective based on team evaluation of presentation and source code.

👪 Integrations Bounty

zkSafe can hide who signed a particular transaction, but doesn't hide who are the Safe owners. The task is to modify the circuit and the contracts so that owners of a Safe could be hidden.

**Requirements**:

Real owners who have signing power for zkSafe must not be extractable from onchain data.

**Criteria**:

Correctness and simplicity of the implementation.

**Resources**:

[https://github.com/1kx-network/zksafe](https://github.com/1kx-network/zksafe)

Modify zkSafe to hide Safe owners

Currently, zkSafe supports up to 10 owners and up to 10 signers of a given transaction.  This is due to a fixed size of the circuit.  We need to support an arbitrary number of owners and signers via recursive proving.

**Requirements**:

The whole recursive proving procedure should be possible via a WASM prover in the browser.

**Criteria**:

Correctness, simplicity, performance.

**Resources**:

[https://github.com/1kx-network/zksafe](https://github.com/1kx-network/zksafe)

Recursive Proving

zkSafe is implemented in Aztec Noir.  To guarantee correctness, it would be beneficial to prove and verify the same transaction in multiple proving systems implemented independently.  The suggested systems are Risc0, SP1.

**Requirements**:

For this task, we are happy to relax the requirement of WASM proving, as with other proving systems it is hard or impossible to achieve that. However, proving on the server side must not break the privacy of the solution. It is important that the proof can be verified onchain.

**Criteria**:

Correctness, privacy, performance.

**Resources**:

[https://github.com/1kx-network/zksafe](https://github.com/1kx-network/zksafe)

Implement zkSafe in another proving system

Accelerate Aligned’s roadmap by contributing to our project and extending its capabilities.

Here are some simple challenges to build and examples of how to integrate already existing products with Aligned:
- Build a go sdk for interacting with Aligned.
- Run a tendermint light client on Aligned.
    - [https://github.com/succinctlabs/sp1-tendermint-example](https://github.com/succinctlabs/sp1-tendermint-example)
- Align blobstream 0 from celestia to work with Ethereum using Aligned.
    - [https://github.com/risc0/blobstream0](https://github.com/risc0/blobstream0)
- Integrate one of the zk credential systems proposed in [“zk-cred”](https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=10179430) to be verified on Aligned.
- Integrate [Anon-Aadhaar](https://github.com/anon-aadhaar/anon-aadhaar) to be verified on Aligned.

**Requirements**:
- The project must use Aligned to verify ZK proofs.
- The project must be deployed on the Ethereum Holesky testnet.
- The project must use a clear [Open Source License](https://choosealicense.com/licenses/): MIT, GNU, Unlicensed, or any standard open source license your team wants.
- The project must include appropriate documentation, including:
    - A README.md that describes the project and rationale, provides backgrounds/biographies of team members, and notes on challenges you faced when building the project.
    - Easy to follow deployment and execution instructions.
    - Provide Documentation and integration tests that allows for others to reproduce your project.

**Criteria**:
Any project that verifies proof with Aligned is eligible. We value using any existing SP1 or Risc0 example project and integrating it with Aligned.

Accelerating the Alignment

Sumcheck is an interactive proof protocol whose purpose is for a prover to provide a verifier with a specially constructed sum over a multi-variate polynomial.  In particular, sumcheck uses sum evaluations over a [boolean hypercube](https://cstheory.stackexchange.com/questions/30738/why-is-0-1-n-referred-to-as-the-boolean-hypercube) for all boolean inputs.  In a traditional setting this operation can be performed by simply sharing the entire multi-variant polynomial with the verifier for evaluation.   However this is computational expensive, using sumcheck, the verifier can perform this evaluation more efficiently. 

1. [Multi-variate Polynomial](https://doc.sagemath.org/html/en/reference/polynomial_rings/polynomial_rings_multivar.html)
2. [Sumcheck Protocol](https://people.cs.georgetown.edu/jthaler/sumcheck.pdf)

The goal of this implementation is to extend the foundational polynomial libraries in Ronkathon to include a multivariate implementation and further implement the sumcheck operation over that  multivariate implementation. 

**Requirements**:

Implementations of Sumcheck and Multivariate Polynomial using *ronkathon*'s existing Univariate Polynomial as a starting point. 

1. Passing example test
2. Thorough documentation of both new objects
    1. docstring comments 
    2. A readme (examples in the ronkathon repository)

**Resources**:

- Github Issue: https://github.com/pluto/ronkathon/issues/137
- Sumcheck Explanation: https://people.cs.georgetown.edu/jthaler/ProofsArgsAndZK.pdf
- Sumcheck, the queen of algorithms: https://www.bigsky.gg/posts/sumcheck_queen/
- Justin Thaler Sumcheck Lecture: https://people.cs.georgetown.edu/jthaler/sumcheck.pdf
- The unreasonable power of Sumcheck: https://zkproof.org/2020/03/16/sum-checkprotocol/
- *ronkathon*:
    - [**https://github.com/pluto/ronkathon/**](https://github.com/pluto/ronkathon/)
    - [**https://pluto.xyz/blog/ronkathon-learn-cryptography-from-first-principles**](https://pluto.xyz/blog/ronkathon-learn-cryptography-from-first-principles)

**Criteria**:

The winner will be selected based on the following criteria, in this order:

1. **Correctness and security:** Thorough convincing that the implementation are completely correct and secure. All requirements must be met. It is reasonable to implement over a small (insecure) field for educational properties.
2. **Code clarity and quality:** Succinct, easy-to-follow code with appropriate naming conventions. Utilize Rust's type system for flexibility and security (e.g., compile-time checks where possible). Avoid external crates. Optimizations should be a lower priority than clarity, but can be included behind a feature flag as a bonus.
3. **Documentation quality:** Provide comprehensive READMEs, Cargo docs, and inline comments where code itself is not self-explanatory. Remember that *ronkathon* is primarily an educational toolbox, so prioritize clarity and readability to facilitate learning.
4. **Comparison and vulnerability analysis:** As a bonus, include a brief comparison of Sumcheck and contrast it with PLONK PIOP and STARK PIOP, highlighting their strengths, weaknesses, and appropriate use cases. This will enhance the educational value of the implementation.

Remember, *ronkathon* prioritizes learning and growth. Your contribution should maintain this focus throughout the implementation and documentation process.