General Pool

Projects can apply directly to one or multiple bounties, but there will also be a general jury to evaluate all of them.

Among all eligible projects, whether they apply to a specific bounty or not, the jury will select and reward the top ones. Depending on the quality of the projects, the number of rewarded submissions may vary.

Aligned

Aligned is a decentralized zero-knowledge (ZK) proof verification and aggregation layer for Ethereum. Aligned accelerates Ethereum’s roadmap by making proof verification faster and more affordable.

Our bounties will be awarded to projects that build innovative technology using Aligned for ZKP verification, or extend the capabilities of Aligned by contributing to our open-source project.

Below we provide a non-exhaustive list of potential ideas. We invite you to reach out to our team members at Lambda Hackweek to discuss project ideas if you will be using Aligned for your hackathon project!

Requirements

  • Create a project that demonstrates how Aligned can be used for cheap and fast ZKP verification, thus enabling new types of blockchain infrastructure or consumer dApps (bounties 1 & 2).
    • The project must use Aligned to verify ZK proofs.
    • The project must be deployed on the Ethereum Holesky testnet.
  • Improve the Aligned developer experience (bounty 3).
  • The project must use a clear Open Source License: 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.
    • Documentation that allows for others to reproduce your project.

Resources

Bounty 1: Infrastructure using Aligned for verification

Build infrastructure using Aligned to verify proofs.

Prizes:

  • 1st place: $4000
  • 2nd place: $2500
  • 3rd place: $1000

Here is a list of potential ideas:

Bounty 2: Consumer dApps using Aligned for verification

Build fun games & puzzles using Aligned and unleash your creativity.

This bounty will be awarded to projects which use Aligned to build something that can engage consumers and create fun onchain experiences for users. Judging will take into account user experience, virality, and ease of taking live onto mainnet.

Prizes:

  • 1st place: $4000
  • 2nd place: $2500
  • 3rd place: $1000

Here is a list of potential ideas:

  • ZK Games in Aligned
    • ZK Wordle and then mint an NFT in Ethereum
    • ZK Sudoku and then mint an NFT in Ethereum
    • ZK Tetris with an onchain leaderboard
  • Run a compiler in SP1 or RISC Zero and post a proof to Aligned.
  • Migrate any Halo2 games and examples to Aligned.
  • Run Doom with RISC Zero/SP1 on Aligned.

Bounty 3: Build Aligned Tooling

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

Prizes:

  • 1st place: $4000
  • 2nd place: $2500
  • 3rd place: $1000

Here is a list of potential ideas:

  • Build a Go, Python, or Typescript SDK for interacting with Aligned.
  • Tooling to improve the Aligned developer experience.

ZKsync

zkSync Era is a Layer-2 protocol that scales Ethereum with cutting-edge ZK tech. Our mission is not only to increase Ethereum's throughput merely but to fully preserve its foundational values – freedom, self-sovereignty, decentralization – at scale.

Bounty 1: Build an application using Native Account Abstraction on ZKsync

Native Account Abstraction on ZKsync Era fundamentally changes how accounts operate by introducing the concept of Smart Accounts and Paymasters. Smart Accounts are fully programmable, allowing for various customizations such as signature schemes, native multi-sig capabilities, spending limits, and application-specific restrictions. Paymasters can sponsor transactions for users, enabling users to pay transaction fees in ERC20 tokens.

This bounty is for projects that demonstrate innovative uses of native account abstraction.

Prizes:

  • 1st: 4000
  • 2nd: 2500
  • 3rd: 1000

Bounty 2: Build a ZK app on ZKsync Era

This bounty is for projects that demonstrate innovative uses of ZK technology on ZKSync Era.

Prizes:

  • 1st: 4000
  • 2nd: 2500
  • 3rd: 1000

Requirements for bounty 1 and bounty 2

  • Project must be deployed on zkSync Sepolia Tesnet
  • Documentation should include:
  • a clear README.md with the following:
    • a clear short one-sentence description of your dapp. Aim for something simple like: “Easy social recovery via Telegram” or “Customizable long-term vaults on smart contract accounts to prevent thefts from hacking”.
    • short description of team and backgrounds.
    • a clear installation/execution process that works.
  • A clear Open Source License: MIT, GNU, Unlicensed or any standard open source license your team wants.
  • Have a Project Description section including the problem being solved and any issues you ran into.
  • Bonus:
  • Create a tutorial and document your code projects for others to replicate

Resources

Quickstart: https://docs.zksync.io/build/quick-start/hello-world.html

Documentation: https://docs.zksync.io/build/

Developer Tools: https://docs.zksync.io/build/tooling/zksync-cli/getting-started.html

Native Account Abstraction (AA) on zkSync: https://docs.zksync.io/build/developer-reference/account-abstraction.html.

Native AA vs EIP4337: https://docs.zksync.io/build/developer-reference/differences-with-ethereum.html#native-aa-vs-eip-4337

Examples: daily spend limit smart account: https://docs.zksync.io/build/tutorials/smart-contract-development/account-abstraction/daily-spend-limit.html

Examplel: ERC20 token paymaster: https://docs.zksync.io/build/tutorials/smart-contract-development/paymasters/custom-paymaster-tutorial.html

Repository: paymaster examples: https://github.com/matter-labs/paymaster-examples

Starknet

Build any cool stuff using one or multiple elements of the Starknet stack.

Few ideas:

  • Onchain game using Dojo
  • Innovative dApp on Starknet
  • Hack on Stone prover or Stwo prover
  • Contribute to the Bitcoin Circle Stark verifier
  • Performance optimisations on any component of the Starknet stack
  • Build your custom Starknet Appchain using Madara

Prizes

  • 1st: $4,000
  • 2nd: $2,500
  • 3rd: $1,000

Resources

nil

=nil; is an Ethereum L2 blockchain leveraging zkSharding to enhance scalability through horizontal scaling, modularity, and verifiable security. Our architecture supports parallel transaction processing across multiple execution shards, each validated by zero-knowledge proofs (ZKPs) and EVM opcode compatibility. Interoperability among these shards is seamlessly maintained through a native cross-shard communication protocol, enabling efficient and secure interactions within the network.

We are offering bounties for developers who choose to build dApps on top of our cluster. This is your opportunity to be among the first to explore and code on =nil;. We encourage you to start small and expand your efforts as you learn more about our technology. We will do our best to provide support both online and offline to assist you throughout the hackathon.

We are offering a total bounty of $3,500, distributed as follows:

  • 1st Prize: $1,200
  • 2nd Prize: $1,000
  • 3rd Prize: $800

Addition $500 Pool which will be shared among participants who submit any qualifying dApp project beyond the top three prizes

Additional Resources:

If you want to join our bounties and build on =nil;, get in touch with our team lead Aleksa Opacic for access to the network and all the details. Find Aleksa on Telegram @aleksaopacic

Project Suggestions

We welcome any dApp as a submission for the hackathon. The only mandatory requirement is that it's deployed on the =nil; cluster and users can interact with it. If you are unsure of what to build, here are a few suggestions that we would be excited to see:

  1. Custom Wallets: Understand how wallets work in =nil; and create a novel wallet implementation that could be adopted by various projects within our ecosystem. For example, consider developing vesting wallets that could leave a lasting mark on the =nil; ecosystem.
  2. Async Messages Coordinator: Explore how you can coordinate asynchronous messages at the application level to enhance cross-shard communication. This could be a crucial tool for developers looking to optimize interactions across shards.
  3. NFT Standard Development: Develop a straightforward NFT standard for =nil;
  4. Applications Utilizing Cross-Shard Communication: Asynchronous communication allows us to unlock horizontal scalability. Think of applications that can make use of this additional scale for better and more valuable user experiences.

Polygon Miden

Polygon Miden is a zkRollup with client-side proving. Anyone can create zk proofs of their own state changes, and the rollup only verifies. That leads to high throughput and privacy at the same time.

We are currently on the alpha testnet. The Miden client is available in Rust and WASM for you to build applications. However, smart contract development must be done in Miden Assembly - it’s easier than it sounds.

More info: https://hackmd.io/@Domi2000/rJZ7Ms6BC

**** All bounty applications will be open source, with the full source code available on GitHub.

Bounty #1 $5000 in MATIC - ECDSA signatures in Miden (secp256k1)

For any cross-chain application on Miden, we will need to verify signatures. Most signatures in the Ethereum and Bitcoin ecosystem are secp256k1.

Currently, it is inefficient to use elliptic curve cryptography in the Miden VM and, therefore, in the rollup. However, most cross-chain applications or encryption techniques are based on elliptic curve cryptography, mainly secp256k1.

Find a way to make ECDSA signature verification cheap (<1m cycles) and efficient on Miden - that can be via a chiplet (~ Co-Processor) or any other technique.

Bounty #2 $5000 in MATIC - FRI in a chiplet

One of the primary goals of the Miden VM is to achieve very efficient recursive STARK proof verification (see Bobbin’s zkSummit talk for a high-level overview). One of the main components of verifying STARKs is verifying FRI proofs. For example, verifying a FRI proof for a computation that requires 1M cycles in the Miden VM takes up 20K+ cycles (which is roughly ⅓ of the entire STARK proof verification cost).

Currently, FRI proof verification procedure in Miden VM is written in MASM. One of the main components of this procedure is verifying correctness of a single FRI query (see here). This procedure can be sped up dramatically if most (or all) of the logic is offloaded to a dedicated chiplet.

The goal of this challenge is to design a Miden VM chiplet to reduce the verify_query procedure to as few instructions as possible (ideally, a single new instruction in the VM). This would primarily consist of defining the AIR (intermediate algebraic representation) for the chiplet.

A successful design would use the existing chiplet architecture, though, some modifications of the architecture are possible (e.g., some minor increase in the number of columns is OK). We can also assume that the chiplet can “make calls” to other chiplets for things like hashing, reading/writing memory etc.

Bounty #3 $4000 in MATIC - Prototype of a novel application on Miden

Miden’s properties allow builders to build applications that are infeasible on EVM-chains. Privacy, native account abstraction, and parallel transaction execution open the design space for novel applications and experiments.

The applications could be in DeFi, RWAs, or on-chain voting. One example is the on-chain order book on Miden.

The most useful novel application that works as a Proof of Concept wins this bounty.

Bounty #4 $4000 in MATIC - Prototype a game on Miden

Prototype a game which is multiplayer(preferred) and involves hiding/revealing information as gameplay mechanism and client side proving as a means to improve the gameplay experience.

Examples: Fog of War and Dark Forest.

Bounty #5 $3000 in MATIC - Send funds privately from browser to browser

Use the Miden client npm package to build an in-browser payment application using private notes. Clients could communicate via encrypted emails or WebRTC. However, this should be abstracted away from the user. For this bounty, most technology is already there, and the bounty is about the UX.

The most private and best-designed application wins this bounty.

Celestia

The first modular blockchain network, Celestia is a modular data availability network that makes it easy for anyone to securely launch their own blockchain. You can build whatever by rapidly launching a blockchain with leading Ethereum rollup frameworks or transform nearly any VM into your own sovereign chain. With Celestia underneath, a customizable blockchain becomes as easy to deploy as a smart contract, while accessing abundant throughput enabled by data availability sampling (DAS), the first architecture that scales while maintaining verifiability for any user.

Build Whatever Bounty $2000 - Build whatever while still leveraging Celestia DA. The prize goes to the best hack with Celestia DA overall. To qualify, you can build something with a predefined rollup stack like OP Stack, Arbitrum Orbit (can leverage Stylus), Madara, or build something using Rollkit, Sovereign SDK, a game with Katana or something completely new!

Modular Builder Bounty $2000 - Awarded to the best hack that combines Celestia and any other piece of the modular stack, specially from other sponsors (think Celestia DA for Taiko, or combining Aligned layer with Celestia DA, etc)

https://docs.celestia.org/

Hack Ideas

node101

node101 is thrilled to support innovation in the modular ecosystem by offering bounties to developers who bring the modularity of Cosmos and the privacy & scalability of zero knowledge together. For instance, you may develop a Cosmos SDK project with ZK, integrate Cosmos SDK in your hackathon project, integrate IBC technology into your ZK application, or implement some ZK functionality to an existing Cosmos chain. Nevertheless, be bold to explore new ideas and feel free to reach in case you have any questions.

Cosmos SDK is a powerful framework that simplifies the creation of custom blockchains, enabling developers to focus on building applications rather than infrastructure. By leveraging Cosmos SDK, projects can benefit from the robust CometBFT consensus engine, interoperability with other blockchains through IBC (Inter-Blockchain Communication), and a modular architecture that promotes rapid development and scalability. Some of the big projects that are using Cosmos’s technology that you may have heard of are Cosmos Hub, Celestia, Osmosis, Agoric, Akash, Injective, Namada, Penumbra, Fetch.ai, dYdX, and Bera Chain.

In this hackathon, we aim for more ZK developers to join the modular ecosystem of Cosmos. We believe in modularity more than anything, and we want more people to be a part of the modular change. Just reach out to our team to explore!

E-Mail: yunus@node101.io or necip@node101.io

Telegram: @ygurlek or @necipsagiro

Docs and Resources

Bounty Details

We are excited to offer a total of $4,000 worth of ATOM tokens for this year’s Lambda Week.

  1. 1st Place: $2,000 worth of ATOM
  2. 2nd Place: $1,250 worth of ATOM
  3. 3rd Place: $750 worth of ATOM

Eligibility Criteria

To qualify for the bounty, projects must:

  • Be integrating to an existing Cosmos SDK project or using Cosmos SDK or Cosmos related technology (like IBC),
  • Using ZK for a meaningful functionality inside the project,
  • Make a meaningful contribution to the ecosystem or show inspirational use case,
  • Have a working proof of concept demonstration,
  • Implement modular structure and write clean code,
  • Provide clear documentation and a explanation of the project,
  • Have all the code public in GitHub.

Nevertheless, be bold to explore new ideas and propose your own project. Just discuss with our team before!

Submission Guidelines

  • Submit a link to your project’s public repository (GitHub, GitLab, etc.).
  • Include a detailed README file with the project motivation, an overview of the project, and an explanation of how ZK is integrated to the Cosmos SDK or Cosmos related chain.
  • Also, it is preferable to submit a PR to the Cosmos SDK or related chain if applicable

Judging Criteria

Projects will be judged based on the following factors:

  • Innovation: How unique and creative is the solution?
  • Technical Implementation: How well is ZK and Cosmos integrated and utilized?
  • Impact: What potential impact could this project have in the real world?
  • Documentation and Presentation: How clear and comprehensive is the documentation and presentation of the project?

We look forward to seeing the innovative projects you create using Cosmos SDK and wish all participants the best of luck in the hackathon!

Cartridge

Cartridge leads the development of the Dojo Engine and other tools and infrastructure for building and deploying Fully Onchain Games (FoCG) and Autonomous Worlds (AW).

Dojo is an open source framework for building provable Games, Autonomous Worlds and other Applications that are composable, extensible, permissionless and persistent. Dojo is an extension of Cairo, an efficiently provable language, that supports generation of zero-knowledge proofs attesting to a computations validity and enables exponential scaling of onchain computation while maintaining the security properties of Ethereum.

Prizes will be awarded to teams for

  1. Best Dojo Games,
  2. Best Dojo Games Deployed with Slot,
  3. Best Dojo Games Integrated with Controller!

3x $1,000 Prizes for the Best Games Built with Dojo

2x $500 Prizes for Best Games Deployed with Slot

2x $500 Prizes for Best Games Integrated with Controller

Judging is subjective, but it will be based on the criteria listed below:

  1. Novel use of the unique properties of the Dojo Engine
  2. Originality of concept, game mechanics, visual design, etc.
  3. Compelling visual and game design
  4. Level of fun

Resources

Dojo Book

Slot Documentation

Controller Documentation

Dojo Basecamp Workshop

EigenLayer

EigenLayer enables developers to build arbitrary distributed systems on top of the Ethereum trust network. It extends the security of Ethereum outside the EVM, making it an order of magnitude easier to build decentralized networks.

Prizes

Best use of existing EigenLayer AVS - $2,000.00

Best new EigenLayer AVS - $3,000.00

Resources

AVS Book: https://eigenlabs.gitbook.io/avs-book

Awesome AVS: https://github.com/Layr-Labs/awesome-avs

Mina

Mina Protocol is the world’s first zero knowledge proof verification L1 that enables zero knowledge proof based decentralized applications development on top of it. The entire Mina blockchain can be verified as a zero knowledge proof, thus enabling a constant sized block history: the entire Mina state history can be expressed in 22 KBs! o1js is the name of the typescript framework that is used to generate zero knowledge proofs that can be verified both inside and outside the Mina blockchain. o1js proofs are constant both in proof size and verification time. It also enables one of the world’s best performant proof aggregation technologies through proof recursion.

This year, Mina Protocol will be sponsoring the Lambda Hackathon with a total budget of 15,000 MINA. You may find more information about the bounty details and the technology below. If you have any questions about the bounties or Mina’s technology in general, please feel free to reach!

Some Resources

General Qualification Requirements

All the projects that want to be considered for Mina’s trach must qualify the following criterias:

  • All projects must be using o1js for some zero knowledge proof related functionality (both inside and outside Mina Protocol is accepted).
  • Zero knowledge proofs (ZKPs) must be a valid part of the project and must show some unique functionality that is not possible without ZKPs.
  • All of the code must be written during the hackathon, with the only exception of ZK gaming projects. Please find more information below.
  • All of the code must be in GitHub (or some other Git management tool) and public. Please keep your code public for reference and inspiration to other developers after the hackathon as well.
  • All of the code must be original. You may of course use some other o1js library or project to not reimplement some functionality, but this must be properly documented in your code. Also note that your project will not receive any credits for the libraries you have used without implementing any new functionality.

Please always communicate with us to make sure your project meets all the requirements. We are 7/24 here to help you.

Main Prize Pool

All projects that qualify for the general qualification requirements will be considered for these prizes. In addition to the MINA award that your project will receive, your project will directly qualify for Mina’s Navigators Starter Grant (that is equivalent to an additional grant of 5000 MINA).

Please note that Mina neither requires, nor wants the projects on top of it to be solely using Mina’s technology. Mina is one of the world’s strongest ZKP verification and settlement layers, and it has amazing capabilities, but for some other use cases integrating different technologies may make sense for the project. Thus, please be aware that we support cross chain projects and encourage you to discover new possibilities by including as many technologies as possible in your projects.

  • 1st Place: 3500 MINA + Navigators Starter Grant
  • 2nd Place: 2500 MINA + Navigators Starter Grant
  • 3rd Place: 1750 MINA + Navigators Starter Grant
  • 4th Place: 1500 MINA + Navigators Starter Grant
  • 5th Place: 1250 MINA + Navigators Starter Grant

General Prize Pool

All projects that qualify for the general qualification requirements will be awarded from the general prize pool that worths a total of 4500 MINA. This amount will be split between all qualifying projects equally. So basically, it is impossible to not be awarded if you are able to finish your project using Mina’s technology 🙂

All projects that qualify for Mina’s bounty will also be considered for a Navigators Starter Grant. Please note that there is no guarantee that you will receive this grant, but there is a really high chance that you will be accepted if you made a meaningful contribution to the Mina ecosystem.

Also, please note that Mina Foundation is more than open to have additional rewards for the projects that show extraordinary success during the hackathon. So do not limit yourself to this document and be bold to explore as much as you can!

RISC Zero

It's now possible to pair a program's output with a self-certifying receipt, allowing a skeptical third party to verify correct execution — and the verifier doesn't need to repeat the original computation or even see the inputs to the program!

RISC Zero empowers everyone to create these Verifiable Programs using Zero Knowledge Proofs (ZKPs). Unlike other ZKP domain specific languages and pure arithmetic circuit constructions, RISC Zero provides a Virtual Machine (zkVM) that proves correct execution of a RISC-V compiled program written in any language* !

*Rust is by far the most supported for now, but examples in python, C/C++, Wasmtime, and more exist!

🤩 Best zkVM Application ⸺ $1,500

Up to 3 teams will receive $500

Best RISC Zero 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. ✨

Qualifications

Open-ended prize! The only strict requirement is that your submission uses the RISC Zero zkVM.

🤝 ZK Coprocessor ⸺ $1,000

Up to 2 teams will receive $500

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.

Qualifications

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.

👪 Integrations Bounty ⸺ $1,000

Up to 2 teams will receive $500

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 incentivize you to build a novel integration for any other sponsor bounty’s platform.

Qualifications

Submissions must be new or non-trivial improvements or extensions of RISC Zero integrations with another LambdaHackWeek @ Brussels 2024 sponsor’s platform/tooling/app. Bonus points for those applying for their bounties as well!

🗃️ Resources

OnlyDust

OnlyDust is a platform that onboards developers to blockchain ecosystems, through open-source contributions. Contribute to the most exciting projects in the space and get rewarded.

Bounties

We will provide $15.000 for eligible contributors that are able to tackle issues for the following repos:

Stellar (1 Repo)

Soroban Example DApp: How to build a dapp frontend backed by smart contracts on Stellar.

Proof of Passport (1 Repo)

Proof of passport is developing tools allowing users to generate proofs of humanity, nationality and age using their government-issued passport. We want to make it easy to extract the signed data from passport chips and verify it. It unlocks uses cases in proof of unique identity, sybil resistance and selective disclosure of private data.

Worldcoin (1 Repo)

Worldcoin scroll bridge: Build bridge integrations with Scroll. The point of the state bridge contracts in world-id-state-bridge is to have two contracts, one deployed on Ethereum mainnet and the other one on a target L2.

Taiko

Taiko is Ethereum’s first Based Layer 2 scaling solution. Based means that Taiko uses (the base layer) Ethereum’s nodes as the sequencers for its blocks. As a result, Taiko inherits all the same economic security guarantees as Ethereum. It also means there is no need for an escape hatch mechanism common with external sequencers. Taiko is also Ethereum equivalent, which means that developers can use all the same tools they’re used to and any contract that runs on Ethereum will also run on Taiko.

Bounty: Build Discord/Telegram Bots and Minigames Utilizing the Taiko Blockchain

Description: We are excited to announce a hackathon bounty for innovative developers to build Discord and Telegram bots or minigames that integrate with the Taiko blockchain. This is a fantastic opportunity to showcase your skills in blockchain development, engage with a vibrant community, and win some prizes!

Prize Pool: $1750

The prize money may be divided between up to 3 top prizes. However, if there is one clear standout winner, they may receive the entire prize pool.

Judging Criteria:

  • Functionality (30%)
    • How well does the bot or minigame perform its intended functions?
    • Is the integration with the Taiko blockchain seamless and effective?
  • Innovation (25%)
    • How unique and creative is the bot or minigame?
    • Does it introduce new or interesting use cases for the Taiko blockchain?
  • User Experience (20%)
    • Is the bot or minigame easy to use and navigate?
    • Does it provide a smooth and enjoyable user experience?
  • Technical Implementation (15%)
    • Quality of the code and technical implementation.
    • Efficient use of the Taiko blockchain's features.
  • Documentation (10%)
    • Clarity and completeness of the project documentation.
    • Ease of understanding for other developers or users.

Helpful Resources

  1. Taiko Blockchain Documentation: https://docs.taiko.xyz
  2. Discord.js Documentation: https://discordjs.guide/
  3. Telegraf.js Documentation: https://telegraf.js.org/
  4. Discord Bot Example: https://github.com/discordjs/discord.js
  5. Telegram Bot Example: https://github.com/telegraf/telegraf

Get creative, dive into the world of Taiko blockchain, and build something amazing! Happy hacking!

Some ideas to get you started:

Tipping bot

A bot that allows users to manage a basic Taiko wallet in Discord/TG. They can check their balances and send tokens to other users based on their username.

OTC Trading Bot

A bot that facilitates token swaps between users within Discord/Telegram channels using smart contracts on the Taiko blockchain. Users can initiate and confirm token swaps securely.

Decentralized Lottery Minigame

A lottery game where participants buy tickets using Taiko tokens. The smart contract on the Taiko blockchain manages ticket purchases, randomly selects a winner, and distributes the prize automatically.

Crypto Trading Simulation

A simulation game that mirrors real-time crypto trading on the Taiko blockchain. Players can buy and sell virtual assets, with transactions recorded on-chain to track profits and losses.

NFT Marketplace Bot

A bot that acts as a decentralized NFT marketplace on Discord/Telegram. Users can list, buy, and sell NFTs stored on the Taiko blockchain, with transactions executed through smart contracts.

Blockchain-based RPG

A role-playing game where players collect items or characters represented as NFTs on the Taiko blockchain. Transactions include acquiring, trading, or battling NFTs, all recorded on-chain.

Proof-of-Attendance Bot

A bot that issues proof-of-attendance tokens on the Taiko blockchain for users participating in events or meetings within Discord/Telegram channels. Tokens are minted and distributed as proof of participation.

Token Rewards Bot

A bot that rewards users with Taiko tokens for completing specific tasks or achievements within Discord/Telegram communities. Transactions are recorded on-chain, ensuring transparency and immutability.

Prediction Market Minigame

A prediction market where users can buy and sell prediction shares on future events or outcomes using Taiko tokens. Smart contracts manage the market and settle transactions based on the correct prediction.

Blockchain Voting Bot

A bot that facilitates voting mechanisms on Discord/Telegram using the Taiko blockchain. Each vote is recorded securely on-chain, ensuring transparency and integrity of the voting process.

Collectible Card Game (CCG)

A card game where players collect, trade, and battle with digital cards represented as NFTs on the Taiko blockchain. Players can buy, sell, and upgrade their cards using blockchain transactions.

Decentralized Exchange Bot

A bot that acts as a decentralized exchange (DEX) within Discord/Telegram channels, allowing users to swap tokens directly using Taiko blockchain smart contracts. It provides a secure and transparent trading environment.

Blockchain-based Quest Adventure

An adventure game where players embark on quests, solve puzzles, and earn rewards stored as NFTs on the Taiko blockchain. Transactions include acquiring quest items, completing challenges, and trading rewards.

Dora Factory

A-MACI (Anonymous Minimal Anti-Collusion Infrastructure) is one of Dora Factory's solutions to address the scalability issues in decentralized governance, such as quadratic governance and beyond. It is based on Zk-SNARK / PLONK and provides privacy protection for on-chain voting. MACI ensures that the blockchain does not need to provide public voting details and can only offer a credible voting result, preventing voters from verifying each other and thus avoiding collusion. A-MACI further ensures that voting details are not visible to administrators, providing a trustless anonymous voting mechanism and allowing everyone to become an A-MACI operator.

While Dora Factory develops A-MACI infrastructures, there are many interesting technical and community growth challenges. We offer the following bounties at this year’s Lambda Hack:

1 A-MACI Circuit Bug Bounty

The circuit is the most crucial part of a Zk-SNARK system. If there are issues with the circuit, such as missing necessary constraints, it could provide attackers with means to forge proofs, compromising the system's security.

The A-MACI system includes four circuits: processDeactivate, processMsg, processTally, and addNewKey. The specific implementations of these circuits can be found at: https://github.com/dorahacksglobal/a-maci-evm/tree/main/circuits

If you can find bugs in the circuit and even provide solutions, you can receive a bounty reward.

  • Minor Bug: $300 each
  • Major Bug: $1500 each

2 Design a Tool/Product for User Key Management

In an A-MACI system, users use EdDSA-based public and private keys as their unique identifier. During the lifecycle of A-MACI, users may need to discard old keypair, regenerate new keypair, and use them. Unlike blockchain products that often use various wallet plugins to manage users accounts, there is currently no good A-MACI keypair management tool for browsers.

Design a tool that allows users to securely manage A-MACI keypair, clearly knowing the status of their corresponding public and private keys. The tool should also be able to sign necessary MACI messages.

An MVP is required to claim bounty.

Prize: $2500

A non-functional MVP with a good idea will be rewarded $1000 in bounty prize

3 Design an A-MACI Solution Allowing Variable Voter Voice Credits

Since variable Voice Credits can enable administrators to distinguish voters' identity characteristics, the current A-MACI system from Dora Factory forces all voters to have equal Voice Credits, limiting A-MACI's use cases to some extent.

Design a solution that supports voters who are assigned different Voice Credits while maintaining the anonymity and anti-collusion features of A-MACI. Depending on the completeness of the solution, different levels of rewards will be offered:

  • [A ] Complete circuit/contract code and a write-up about your approach and how a new protocol would work.
  • [B ] Propose a solution with key code snippets to understand the principles. A detailed protocol write-up is required.
  • [C ] Propose a solution without actual code engineering.

Prizes:

  • A - $10000
  • B - $5000
  • C - $2500

Note: submission to this bounty will need to be verified and reviewed by the Dora Factory team, bounty prize release will be delayed until proposed protocol / code is evaluated and verified.

—---------The following three bounties are community growth bounties —------------

4 Masterplan and deployment of a MACI voting round in any use case

**Details: **

Ready to put the power of Minimal Anti-Collusion Infrastructure (MACI) into action? We're challenging you to design, implement, and deploy a MACI voting round for a real-world use case you define.

Become a MACI voting designer and operator yourself by helping organizations in need to build a functional round.

**Prizes: **

  • Best use case: $400
  • Best voting mechanism: $400

Submission Requirements:

Your submission should include the following components:

  • Define and Describe the Use Case:
    • Explain the specific circumstances under which this organization requires MACI voting.
    • Detail the problem or challenge that MACI voting aims to address.
  • Explain the Voting Mechanism:
    • Describe how votes will be counted.
    • Explain the process for determining the final result.
    • Highlight any unique features or improvements in your voting mechanism.
  • Deploy the MACI Voting Round:
    • Use the Vota Operator Manual to guide your deployment.
    • Act as the “operator” to execute this MACI voting round.
    • Provide the deployment link to your MACI voting round.

5: Design a MACI voting use case and its voting mechanism for a real community/DAO

Ready to put the power of Minimal Anti-Collusion Infrastructure (MACI) into action? We're challenging you to design a MACI voting round for a real-world use case. Try designing a MACI voting system for an existing community/DAO to decentralize their governance!

Prize: $150/winner up to 10 winners

Your submission must include the following:

  • Introduction of the Community/DAO: Briefly introduce the team and community/DAO this MACI voting round serves, and how would MACI empower the community/DAO in operation, governance, fund management, etc..
  • Links to relevant sites of this community/DAO.
  • Define and Describe the Use Case:
    • Explain the specific circumstances under which this organization requires MACI voting.
    • Detail the problem or challenge that MACI voting aims to address.
  • Explain the Voting Mechanism:
    • Describe how votes will be counted.
    • Explain the process for determining the final result.
    • Highlight any unique features or improvements in your voting mechanism.

Other requirements:

  • Non-AI Writing in the submission.
  • Prohibited Topics: Statements on any topics or elements that entail gambling and other crimes are NOT allowed as part of the submission.

6: Deploy a MACI round at Dora Vota

Prize: $50/winner up to 40 winners

Intro

Dora Vota is a specialized blockchain for voting and decentralized community governance.It is designed to support voting rounds for various communities and organizations. The first voting scheme we support is MACI (Minimal Anti-collusion Infrastructure).

In order to allow everyone to setup and apply MACI easily, Dora Factory has developed a user-friendly GUI and CLI for MACI voting round deployment and operation.

**Submission requirements: **

You should submit the link to the MACI round deployed by you and your **Operator’s public key **(required when creating the round).

How to Deploy a MACI voting round on Vota

Read more: If you're interested in the mechanisms and details of MACI, you can explore further by reading the following articles:

Note: Only Lambda Hack 2024 participants are allowed to claim MACI deployment bounty.

Brevis

Brevis is a smart ZK coprocessor that empowers smart contracts to trustlessly read historical on-chain states/txs/events and run customizable computations on top at low cost, enabling data-driven dApp UX.

No ZK knowledge is required!

Build with Brevis and win amazing prizes.

Build Data-driven dApps with Brevis ZK Coprocessor

What is required to complete this prize?

  • Developers are required to integrate Brevis SDK into their dApps successfully.
  • The dApps should access historical blockchain states, transactions, and/or events, and run customized business logic/computation on those data through Brevis ZK Coprocessor.
  • The integration should be meaningful: accessing historical states that are also available in the current blockchain states does not count as successful integration.
  • To qualify for the first prize, the dApp must write customized and meaningful computation logic on the data accessed. Simply utilizing historical on-chain data without any computation does not qualify for the first prize.
  • We do consider partial or incomplete integration on a case-by-case basis. For submissions aiming to solve real-world use cases with a clear path towards full integration, we will most likely issue the full amount of the bounty.

Bounty #1 $2000

Bounty #2 $1000

What's Brevis in 2mins

Examples:

Marlin

Marlin provides TEE-based coprocessors to run programs off-chain verifiably via the Oyster marketplace. TEEs or Trusted Execution Environments rely on hardware-based security to provide computational integrity and data confidentiality. Instances can be rented individually or shared using the serverless mode on Oyster. This makes them suitable to run automation or keeper bots, ML models, heavy computations or matching engines as is the case with Kalypso.

Kalypso is a decentralized marketplace for efficient zero-knowledge (ZK) proof generation. Its orderbook-based matching engine connects applications with dedicated hardware providers which improves user experience and boosts hardware utilization. Kalypso's modular and composable architecture makes it easy to integrate into any tech stack, zkVM and proving system. A unique feature of Kalypso is its ability to work with private inputs through the use of Trusted Execution Environments (TEEs).

Projects which use Kalypso to delegate ZK proof generation, or Oyster in any way to run off-chain programs or bots will be awarded two prizes:

Prize #1 $2000

Prize #2 $1500

Additionally, any project that uses either Kalypso or Oyster which doesn’t win the prizes above (and works!) will receive $300 each.

For support, please reach out directly on Marlin’s Discord server:

Kakarot

Kakarot is a ZK-EVM on top of the Starknet and Cairo stack. Kakarot effectively turns StarknetOS chains into dual VM clients (EVM + CairoVM). EVM applications can deploy natively on Starknet, without any modification. Additionally, Kakarot leverages Starkware's STARK prover and proof aggregator (Stone + SHARP), the most battle tested and evolutive prover stack in the industry.

Prizes and bounties are provided for people who are EVM developers or Cairo developers and utilize Kakarot ZK-EVM for dApp or protocol development. Innovative applications on Kakarot would be:

  • DualVM applications that leverage Kakarot’s Cairo interoperability module to run Cairo code from the EVM. For example, dApps where 90% of code can be written in Solidity, and 10% of performance-heavy code written as Cairo programs; or EVM adapters wrapping popular Starknet apps that enables EVM interaction with a Cairo application. Interesting verticals to explore for these hybrid dApps can be found below:
    • DeFi (AMMs, money markets, etc.)
    • Gaming
    • Social applications (NFTs, memes etc.)
  • Token bridges using Kakarot’s messaging system for NFTs or ERC20 tokens.
  • ERC4337-compatible dApps on Kakarot using Pimlico infrastructure

All bounty winners will get exposure and tweets from Kakarot. The top 3 projects will get:

  • #1: 750$
  • #2: 600$
  • #3: 400$

https://docs.kakarot.org

Herodotus

Storage Proofs provide smart contracts with synchronous access to on-chain data and verifiable data feeds across Ethereum layers. Our solutions allow smart contracts to read and process historical and current on-chain data, enabling developers to seamlessly retrieve data from L1 State on L2s, L2 State on L1s, and L2 State on L2s, eliminating the necessity for asynchronous messaging.

Bounty 1. 🛰️ Best Use of Storage Proof API or Turbo ⸺ $1,500

Utilize the Storage Proof API or Turbo to access cross-chain and historical Ethereum data on a supported Layer 2. Develop applications such as a bridge, DeFi app, or other dApps.

Requirements

Submissions must demonstrate actual use of the Storage Proof API or Turbo without mock requests.

Bounty 2. 🛰️ Best Use of Herodotus Data Processor ⸺ $1,500

Leverage the Herodotus Data Processor to develop innovative solutions that demonstrate use of the Herodotus Data Processor to compute over on-chain data. Can either request via API, or generate trace locally via cli to connect your project.

Requirements

Submissions must showcase practical implementations with genuine data processing and verifications, without mock requests.

Use Cases

Governance

Storage Proofs eliminate the need for bridging by allowing users to prove ownership of assets on another network without actually bridging them. This functionality enables the implementation of L1 token/NFT gated contracts on L2s, offering a seamless integration. A perfect example of this use of Storage Proofs and Herodotus is SnapshotX, which leverages Storage Proofs to enable voting based on assets stored on L1.

Bridging

With Storage Proofs, you can access historical data, which is highly valuable for powering intent-based systems such as bridges. For instance, one can prove that after a user initiates a transfer from Chain B to Chain A, they have provided liquidity on Chain A. This historical data allows the actor to reclaim funds from escrow, enabling new kinds of bridging designs.

Additional Materials:

https://github.com/HerodotusDev/yab-herodotus

Rewarding user activity

Historical data allows smart contracts to have visibility comparable to what a human can see on Etherscan. This capability enables developers to build smart contracts that retrieve user activity using Historical Data Proofs (HDP). For example, one can prove that a user interacted with a certain protocol more than ten times over the last month. Combined with the advanced features of Starknet and zkSync, such as account abstraction, this functionality can be leveraged to build a paymaster that subsidizes transactions for highly active users.

Accessing historical randomness

Generating random numbers on Ethereum is inherently complicated due to the nature of blockchain technology, more specifically because of deterministic execution and transparency that makes all data visible to anyone, including the validators who can have some control over the block they produce.

If a random number generation method relies on block-related information, validators could influence the outcome in their favor, or abstain from including transactions that are not favorable to them or other parties subsidizing them.

Here comes RANDAO, a decentralized solution using a commit-reveal scheme directly integrated into the Ethereum protocol and accessible thanks to the block.prevrandao opcode, and injected inside the MIX_HASH property of new block headers.

The problem is, that this is only accessible on Ethereum L1, making it hard for derived L2s to benefit from it.

This example DApp allows users to commit to a dice roll (1-6) on Ethereum Sepolia (L1). It then creates a storage proof of the commitment's storage slot and verifies it on zkSync Sepolia (L2).

On L2, Turbo extracts the MIX_HASH property from the corresponding L1 target block (i.e., a pre-defined future block after the original commitment). It uses it as a source of randomness to determine the dice roll result. Ultimately, Ethereum Layer 2s with Turbo support can utilize Ethereum RANDAO in a nearly identical manner as if they were accessing RANDAO directly on Ethereum.

Additional Materials:

https://github.com/HerodotusDev/turbo-zksync-demo

Reputation based light client for ORUs

Leveraging HDP, it is possible to develop a light client based on a sequencer's reputation. Optimistic rollups, a layer 2 scaling solution, rely on a security model that uses fraud proofs to ensure the integrity of transactions. However, this model results in long finality times as it requires a challenge period to dispute any fraudulent claims. The recent upgrade to permissionless fraud proofs exacerbates this issue, as anyone can post new state roots in the OP Stack, making it difficult to determine trustworthy state roots until they remain undisputed for a week.

A sequencer, identified by an Ethereum address, gains trust by consistently avoiding successful challenges and making accurate claims. This reputation-based system reduces finality time by treating the state root claims of trusted sequencers as valid. The sequencer's reputation is periodically updated using historical data, with any successful challenge resetting their reputation to zero. This ensures that only reliable sequencers are depended upon, enhancing the security and functionality of blockchain ecosystems.

By implementing this design, we can significantly improve the efficiency and reliability of optimistic rollups. The use of historical data to evaluate sequencer performance and reputation allows for quicker validation of state roots, thus reducing the finality time and increasing the overall throughput of the network.

Additional Materials:

https://ethresear.ch/t/reputation-centric-light-client-framework-for-optimistic-rollups/19988