ETHGlobal Buenos Aires

Connect your project with the MATE Metaprotocol (our official EVVM tesnet deployed on Sepolia) with a x402 agents OR make your dApp. 1. Using 'async nonces' and 'executor' is a plus. 2. Optionally integrate any of the available services and other functionalities: MATE NameService, MATE Staking, p2p Swap, etc.

Qualifications

You must use the official MATE Metaprotocol deployed on Sepolia or any of its official services.

Create a new EVVM Service or a cusotmized EVVM that you believe is needed today. Check the Mate NameService, p2p Swap and Staking as references and/or starting point. We are looking forward to see more Services and customized chains related to -gasless- Retail, -async- DeFi, Governance, Institutions (Gov, Schools, Librares, etc) and Gaming.

Qualifications

For this implementation you can deploy your own custom EVVM or use the MATE Metaprotocol (our testnet EVVM already deployed on Sepolia).

Capture and/or Receive transactions and execute them in an EVVM. If you feel confident, try to do something legendary, something out of the box with fishing spots and fishers!

Qualifications

For this implementation you can deploy your own EVVM or use the MATE Metaprotocol (our testnet EVVM already deployed on Sepolia).

Make your project interact in a meaningful way with the MATE Metaprotocol (our official EVVM tesnet and/or Servces deployed on Sepolia) or its ecosystem. Sepolia EVVM (upgrade Nov 17th): 0xF817e9ad82B4a19F00dA7A248D9e556Ba96e6366 Sepolia MATE Staking (upgrade Nov 17th): 0x8eB2525239781e06dBDbd95d83c957C431CF2321 Sepolia NameService (upgrade Nov 17th): 0x8038e87dc67D87b31d890FD01E855a8517ebfD24

Qualifications

You must use the official MATE Metaprotocol deployed on Sepolia or any of its official services.

Give us a feedback, could be on the product, tooling, documentation, workshops or any other related to the EVVM, the MATE Metaaprotocol desgn, the vailable Services or recommendations for new ones!

Qualifications

Send the feedback with your project name using the Feedback Input in the ETHGlobal Project Submission form.

Show us your best Mini Apps! Projects that build and deploy a Mini App using MiniKit are eligible for this prize.

Qualifications

- build a Mini App with MiniKit - integrate any of the MiniKit SDK Commands - if your Mini App uses on-chain activity, deploy your contracts to World Chain - your project must not be gambling or chance based - proof validation is required and needs to occur in a web backend or smart contract

This pool prize is for all projects that build within the World ecosystem (and don't receive another prize from World)!

Qualifications

- make a good-faith effort to integrate World ID, build a Mini App, and/or build on World Chain - your project must not be gambling or chance based

Use Pyth Pull oracle to power up you dapp. The prize will go to the top three teams with best and most innovative use of Pyth Price feeds. Please read the qualification requirements carefully.

Qualifications

Qualification Requirements Your app should use Pyth price feeds via Pull method. The steps include. 1. Pull/Fetch the data from Hermes. (Check the links and Resources) 2. Update the data on chain using updatePriceFeeds method. 3. Consume the price. 4. You can run a price pusher too if you prefer traditional way of using oracles. (Optional) Please follow our comprehensive Pyth EVM guide to to integrate Pyth in less than 5 minutes.

Use Pyth Entropy to generate and consume random number on chains. Anyone can permissionless generate random number on-chain. This pool prize will be given to most Innovative apps to use Pyth Entropy.

Qualifications

Your app should consume random number generated by Pyth. Please follow along the guides and Tutorials to get started. NOTE: To get qualified for this track, raise a PR in https://github.com/pyth-network/pyth-examples. You just have to submit the working code along with a detailed README of your project.

Use Pyth Entropy to generate and consume random number on chains. Anyone can permissionless generate random number on-chain. This pool prize will be given to most Innovative apps to use Pyth Entropy.

Qualifications

Your app should consume random number generated by Pyth. Please follow along the guides and Tutorials to get started. NOTE: To get qualified for this track, raise a PR in https://github.com/pyth-network/pyth-examples. You just have to submit the working code along with a detailed README of your project.

Create a custom Aqua app based on SwapVM that implements a sophisticated DeFi position. You may modify SwapVM opcodes and define your own instructions. The final positions must be demonstrated through tests, scripts or UI. Examples: - Leverage - AMM - Lending - Options

Qualifications

Requirements**: - SwapVM is used to power Aqua app - Onchain execution of token transfers should be presented during the final demo - Proper Git commit history (no single-commit entries on the final day)

Utilize 1inch's infrastructure to help build your application - Build with our swap protocols (1inch Cross-chain Swap (Fusion+), Intent-based Swap (Fusion), Classic Swap, limit order protocol) - Build with any of our data APIs (price feeds API, wallet balances API, token metadata API, and many more) - Use our Web3 API to interact with the blockchain

Qualifications

**Requirements**: - Your project uses at least one 1inch API to provide meaningful functionality for your users - Proper Git commit history (no single-commit entries on the final day) **Judging Criteria**: - Practicality and usefulness - Code quality/completeness

Build Uniswap v4 Hooks designed for stable-asset markets. Projects should explore novel applications of Hooks for synthetic lending, credit-backed trading, or optimized stable AMM logic.

Qualifications

A user interface is not required, but projects must provide clear evidence of functional code. Each team must submit: TxID transactions (tesnet and/or mainnet) a GitHub repository, README.md, demo link or setup instructions, and a demo video (max 3 min).

Build Uniswap v4 Hooks designed for volatile asset pairs. Projects should explore innovative Hook logic that enhances liquidity resilience, mitigates Loss Versus Rebalancing (LVR), or improves capital efficiency for volatile asset pairs.

Qualifications

A user interface is not required, but projects must provide clear evidence of functional code. Each team must submit: TxID transactions (testnet and/or mainnet), a GitHub repository, README.md, demo link or setup instructions, and a demo video (max 3 min).

For this price, we are looking for dApps built on any blockchain to leverage the Filecoin Onchain Cloud for decentralized storage needs. Use Filecoin Onchain Cloud to power any dApps that need decentralized storage, even if it’s not storage-centric. Whether you’re building an AI project, a social dApp, an NFT marketplace, a gaming platform, or a DeFi app — integrate Filecoin to store and retrieve essential data like metadata, assets, or proofs in a decentralized way. Show the world how decentralized storage unlocks new reliability and transparency for your dApp.

Qualifications

1. Your project must use Synapse SDK or Filecoin Pin in a meaningful way to access the Filecoin Onchain Cloud. 2. Must include a working demo (frontend or CLI). 3. Open-source code submitted via GitHub.

For this prize, we would love to see applications built around decentralized storage itself using Filecoin Onchain Cloud. Build a next-generation storage-native application using Filecoin Onchain Cloud. Think beyond uploading files — create something that showcases Filecoin as the programmable storage layer for Web3. This could include verifiable data sharing, dataset marketplaces, decentralized AI training data, on-chain file publishing, or new retrieval and warm-storage services.

Qualifications

1. Your project must use Synapse SDK or Filecion Pin in a meaningful way (storage, retrieval, or payment). 2. Your project must deploy to the Filecoin Calibration Testnet. 3. Must include a working demo (frontend or CLI). 4. Open-source code submitted via GitHub.

We’re looking for high-quality onchain apps that use at least one of the following CDP tools: ✅ CDP Embedded Wallets (for end-users) ✅ CDP Server Wallets (for AI agents) ✅ CDP Trade API for onchain swaps ✅ CDP Data APIs (SQL API, token balances, web-hooks) ✅ x402 with CDP Facilitator ✅ Coinbase Pay (fka Coinbase Commerce) for onchain payment acceptance Bonus points for: - Using more than one of our products - Sharing your project on X and tagging @CoinbaseDev - Giving us high-quality feedback on what worked well, and how we can improve

Qualifications

🔍 What We’re Looking For Product Quality: Is it well-built, useful, and polished? Would someone actually use this? Use of CDP: Higher scores for using more CDP tools, but you only need one to qualify Developer feedback: Did you give thoughtful feedback on what worked well, and how CDP can improve? Social signal: Did you share your project on X and tag @CoinbaseDev? Bonus points for good storytelling or reach! We’re looking for high-quality onchain apps that use at least one of the following CDP tools: ✅ CDP Embedded Wallets (for end-users) ✅ CDP Server Wallets (for AI agents) ✅ CDP Trade API for onchain swaps ✅ CDP Data APIs (SQL API, token balances, web-hooks) ✅ x402 with CDP Facilitator ✅ Coinbase Pay (fka Coinbase Commerce) for onchain payment acceptance

What we’re looking for: Infra for agents, AI systems, and verifiable pipelines that don’t rely on black boxes or centralized gatekeepers. Examples: Agents powered by open data Verifiable inference pipelines IPFS-native model storage Evaluation tools with provenance baked in Multi-agent sandboxing Judges want: Something useful A clear link between AI and open infra Strong technical decisions

Qualifications

👉 Submission requirements Use any tech stack you want Submit here to the ETH Global portal and here: https://pl-genesis-frontiers-of-collaboration-hackathon.devspot.app

What we’re looking for: Coordination, incentives, governance, and economic toys that rewire how groups make decisions on the internet. Think: “If a DAO and a Nash equilibrium had a baby.” Examples: Reputation systems that don’t rug you Incentive engines, e.g. using hypercerts Sustainable public goods funding mechanisms Governance dashboards that don’t suck Impact monitoring and prediction at scale A rigorous mechanism evaluation benchmark Judges want: A clever mechanism Something real people (or bots) would use A design backed with evidence

Qualifications

Use any tech stack you want Submit to the ETH Global portal and here: https://pl-genesis-frontiers-of-collaboration-hackathon.devspot.app

What we’re looking for: Anything that lets researchers, builders, and weirdos collaborate with open data instead of hiding it behind walled gardens. Examples: Tools for scientific collaboration Knowledge graph builders Research indexing / visualization IPFS-linked data workflows DeSci-friendly infra Hypercerts for research artifacts Judges want: A real “oh, this could be huge” moment Strong use of open storage or distributed infra A clean UX for researchers

Qualifications

👉 Submission requirements Use any tech stack you want Submit to the ETH Global portal and here: https://pl-genesis-frontiers-of-collaboration-hackathon.devspot.app

What we’re looking for: Tools that make the internet harder to kill, censor, or compromise. If it makes Big Brother sweat even a little, you’re on the right track. Examples (but don’t limit yourself): P2P networking magic Zero-knowledge usage protecting PII Auth systems without a single point of trust Privacy-preserving messaging Post-quantum experiments for the future dystopia we might get stuck in Judges want: Clever architecture Clean implementation A real contribution to a sovereign internet

Qualifications

👉 Submission requirements Use any tech stack you want Submit to the ETH Global portal and here: https://pl-genesis-frontiers-of-collaboration-hackathon.devspot.app

Build the best omnichain application using LayerZero’s cross-chain messaging protocol and Omnichain Fungible Token (OFT) standard. Projects should demonstrate seamless token or data movement across multiple blockchains. Whether it’s a DeFi protocol, game, NFT marketplace, or novel cross-chain tool, the most innovative and technically sound implementations of LayerZero’s architecture will win. Judges will evaluate creativity, functionality, and how effectively the project leverages omnichain interoperability.

Qualifications

To qualify for the Best Omnichain Implementation track, participants must adhere to the following criteria: 1. Interact with the LayerZero Endpoint contract using either the LayerZero Contracts Library or your own custom integration to send / receive a cross-chain message. 2. Extend the Base Contract Logic: It's not sufficient to simply inherit the OApp / OFT / Endpoint interface contracts; the developer must also extend it. This means adding new functionalities, features, or optimizations that create new cross-chain use cases. The extension should demonstrate innovation and an advanced understanding of the LayerZero tech-stack. 3. Working Demo: Hackathons have a tough time crunch, and we respect you all for learning to work with our tools so fast! Please focus on having the core contract working, and clean the rest up after. 4. Feedback Form:When hacking, hard to use, buggy, or confusing documentation and tooling can ruin your experience! Please take the time to submit any feedback that you think might be useful for how we can improve your lives when building on LayerZero! The best feedback submission will win $750! Please submit using the form linked under "Resources".

Build your first workflow with CRE! Chainlink Runtime Environment (CRE) is an all-in-one orchestration layer that enables developers to build institutional-grade smart contracts — data-connected, compliance-ready, privacy-preserving, and interoperable across blockchains and traditional systems. With CRE, you can connect blockchains to external APIs, enterprise systems, data sources, LLMs, or AI agents. Using the CRE SDK (available in Go and TypeScript), you’ll build Workflows — modular programs that orchestrate logic across on-chain and off-chain environments. With the CRE CLI, you can compile, simulate, and deploy these workflows to CRE, where they run on a Decentralized Oracle Network (DON) for fault-tolerant execution.

Qualifications

Requirements: ✅ Goal: Build, simulate, or deploy a CRE Workflow that’s used as an orchestration layer within your project. ✅ Your workflow should: - Integrate at least one blockchain with an external API, system, data source, LLM, or AI agent. - Demonstrate a successful simulation (via the CRE CLI) or a live deployment on the CRE network. - Be meaningfully used in your project 💡 If you show us a successfully simulated workflow execution, our team will deploy it to the live CRE network for you during the hackathon!

Build something awesome using Chainlink! Anything that came from the Chainlink Documentation counts - using CCIP, Price Feeds, Data Streams, PoR or VRF. Note: Please use CRE instead of using Chainlink Functions or Automation. These products will be deprecated, and any project that needs this type of functionality should use CRE instead.

Qualifications

Requirements: - Each project must use a Chainlink service in some form to make a state change on a blockchain, otherwise it will not be eligible for the Chainlink core prizes. This means that a front end simply reading from Chainlink Data Feeds doesn't count. Using Chainlink inside your smart contracts is required. - While all project submissions are evaluated holistically, there will be bonus points given to projects that use multiple Chainlink services in a meaningful way. - Please let us know how you use Chainlink in the project description.

Deploy smart contracts on Arc that demonstrate programmable logic using USDC or EURC. Contracts should go beyond simple transfers, like automation, conditional logic, or cross-chain interoperability. Bonus points for composability with Circle's Gateway or CCTP offerings.

Qualifications

Qualification Requirements Submissions will be evaluated based on the following parameters. Please be clear what bounty you are submitting for as a part of your submission! * Functional MVP and diagram: Projects must demonstrate a working frontend and backend plus an architecture diagram. * Video demonstration + presentation: Succinctly outlining the project's core functions and its effective use of Circle's Developer tools/tech is required, supported by detailed documentation. * Link to GitHub/Replit repo

Create an autonomous agent that uses Circle Wallets to execute transactions on Arc. The agent should make decisions on real-world data or API inputs and transfer USDC. Bonus points for integrating x402 to monetize API or AI-driven actions.

Qualifications

Qualification Requirements Submissions will be evaluated based on the following parameters. Please be clear what bounty you are submitting for as a part of your submission! * Functional MVP and diagram: Projects must demonstrate a working frontend and backend plus an architecture diagram. * Video demonstration + presentation: Succinctly outlining the project's core functions and its effective use of Circle's Developer tools/tech is required, supported by detailed documentation. * Link to GitHub/Replit repo

Build an onchain treasury automation system using Circle Gateway and Arc that manages, allocates, and distributes USDC. Bonus points for integrations that use Circle Wallets

Qualifications

Qualification Requirements Submissions will be evaluated based on the following parameters. Please be clear what bounty you are submitting for as a part of your submission! * Functional MVP and diagram: Projects must demonstrate a working frontend and backend plus an architecture diagram. * Video demonstration + presentation: Succinctly outlining the project's core functions and its effective use of Circle's Developer tools/tech is required, supported by detailed documentation. * Link to GitHub/Replit repo

Create a seamless crosschain app that leverages Circle's Bridge Kit to enable USDC transfers between Arc and supported chains.

Qualifications

Qualification Requirements Submissions will be evaluated based on the following parameters. Please be clear what bounty you are submitting for as a part of your submission! * Functional MVP and diagram: Projects must demonstrate a working frontend and backend plus an architecture diagram. * Video demonstration + presentation: Succinctly outlining the project's core functions and its effective use of Circle's Developer tools/tech is required, supported by detailed documentation. * Link to GitHub/Replit repo

Any type of ENS integration is eligible for this prize. Get creative! An example of a successful project may be a smart contract wallet that mints an ENS subname on L2 and sets its primary name upon deployment. If you're building an AI project, consider how ENS can be used to name autonomous agents. Come by our booth for help brainstorming ways to integrate ENS into your project!

Qualifications

It should be obvious how ENS improves your product and is not just implemented as an afterthought. Your demo must be functional and not just include hard-coded values. Upon submission, your project showcase must have a video recording or link to a live demo (ideally both) and the code needs to be open source and accessible on Github or a similar platform.

Use protocols on Flare blockchain in an innovative and world changing way! Build DApps utilising at least one of Flare’s Enshrined Data Protocols: * FTSO (Flare Time Series Oracle) for price feeds. * FDC (Flare Data Connector) for Web3 and Web2 data sources, * Flare’s Secure Random Number Generator, or * FAssets to build dApps that use FXRP (synthetic XRP on Flare) bringing non-smart-contract XRP into DeFi.

Qualifications

DApps must make use of at least one of Flare's enshrined Data Protocols. Dapps must address real-world problems, or cater to specific use cases to be impactful. Add Feedback in the README describing your experience with building on Flare.

Most innovative external data source use case or most innovative cross chain application secured by Flare’s protocols.

Qualifications

Show innovation by utilizing real world data in an on chain application. If you are using an external data source, provide a link to it's API. Can be combined with MAIN track or other bounties.

Create one or more agents using the Hedera Agent Kit that can send and receive A2A messages and, if appropriate, settle payments via AP2 using Hedera tokens. For example, an AI travel agent might negotiate bookings with other agents and pay with stablecoins.

Qualifications

1. Multi‑agent communication — implement message exchange using the A2A standard. 2. Agent Kit integration — build your agents with the Hedera Agent Kit and its adaptors. 3. Open‑source deliverables — publish code and documentation; include a demo video illustrating agents negotiating via A2A/AP2 and settling on Hedera. Bonus points for using multiple Hedera services or advanced features like human‑in‑the‑loop modes.

Hedera’s EVM compatibility allows developers to write Solidity contracts while benefiting from fast finality and low fees. This bounty is about using cross‑chain and real‑world data to build innovative dApps. Example ideas include multi‑chain financing, cross‑chain auctions or data‑driven trading bots.

Qualifications

1. Deploy and verify a smart contract on Hedera — use Hedera mainnet, testnet or previewnet; verify contracts on Hashscan. 2. Integrate oracles and/or bridges — consume external price feeds from Chainlink, Pyth or Supra, and/or use Chainlink CCIP, LayerZero or HashPort for cross‑chain transfers. 3. Use Hedera services where relevant — consider HTS System Contracts or the Token Service for hybrid native/EVM functionality. 4. Deliverables — provide open‑source code, a clear README and a demo video. Bonus points for combining multiple oracles/bridges, integrating Hedera wallet flows (HashPack, Kabila, MetaMask Snap), or offering a novel real‑world use case.

The Hedera Agent Kit supports a plugin architecture that allows developers to add new tools and integrate third‑party services. This bounty rewards the most useful and well‑architected new plugin that introduces new capabilities. Plugins might wrap external APIs (e.g., DeFi protocols, data providers), simplify token operations, or provide analytics and monitoring.

Qualifications

1. Follow the plugin architecture — your plugin must adhere to the Hedera Agent Kit’s plugin interface and be installable via npm or similar. 2. Provide clear documentation — include setup instructions, available tools and example usage. Explain how the plugin interacts with Hedera and any external services. 3. Demonstrate utility — build a small sample agent showing how the plugin is used. If the plugin interfaces with Hedera network services, ensure contracts are verified and transactions are signed appropriately. 4. Deliverables — publish the plugin code and example project under an open‑source licence, supply a README and a short demo video. Bonus points for interoperability with other agent ecosystems or for integrating real‑world data sources.

This category is for building infrastructure that either enhances Hyperlane or makes use of Hyperlane's capabilities. Maybe you’ll build a customized Deploy tool to bundle ICA's and HWR's? Or perhaps you’d build a way to more easily connect chains with Hyperlane? Maybe you’ll build a tool to allow any chain to get access to oracle feeds from any chain? You decide!

Qualifications

Get in touch with the Hyperlane team for more details! Join our discord to engage & get support.

The grand prize will be given to the most compelling submissions made during the hackathon. It can qualify under any of the categories below, so be sure to read them to get some ideas!

Qualifications

Get in touch with the Hyperlane team for more details! Join our discord to engage & get support.

An interchain application is an application that communicates between different blockchains. It can either transfer assets or make interchain function calls. The winner of this prize will be the most impressive application that makes use of Hyperlane and benefits from its presence on multiple blockchains.

Qualifications

Get in touch with the team for more details! Join our discord to engage with the team and get support.

Expand Ledger hardware support with the Device Management Kit. Add signers, upstream improvements, or build Discover Live Apps. Example projects: - Implement DMK in popular Web3 connector libraries (ethers.js, wagmi, RainbowKit, web3-react, Reown AppKit, Web3Auth...) - Add a new Signer to the Device Management Kit - Build a Device App (C/Rust) or a Discover Live App

Enable human-readable signing for any dApp. Author ERC-7730 descriptors to decode complex transactions, or build the developer tooling needed to scale the standard. Example projects: - Create ERC-7730 JSON files for DeFi protocols → Win a Ledger device - Build tooling for ERC-7730 creation/validation - Improve the JSON Creation Tool

Rewarding surprising, high-impact ideas that change how people build with Ledger.

Qualifications

Show us inventive Ledger tooling, DMK use cases, or Clear Signing flows that transform developer experiences.

Ethereum is not just a blockchain; it is the most open coordination protocol ever built. It enables anyone, whether human or machine, to participate in shared rules, value exchange, and governance without requiring permission. Your challenge is to build the missing infrastructure, tools, or mechanisms that make Ethereum a natural environment for agents. Not just agents using Ethereum, but agents that belong on Ethereum—able to transact, reason, coordinate, and collaborate. Ask yourself: - What would make an autonomous agent choose Ethereum as its operating ground? - How can Ethereum’s openness, composability, and credible neutrality become useful primitives for agentic systems? - And, inversely, where can AI be genuinely useful to the human Ethereum community? How might agents augment governance, collective research, public goods, or community coordination? We’re interested in the connective tissue: the foundations that allow agents and humans to coordinate effectively, transparently, and trustlessly. Possible Directions: - Agent Coordination Primitives - Economic Infrastructure for Agents - Governance Augmentation - Bridging Cognition and Consensus - Collective Missions

Qualifications

Requirements: - Your project must explore autonomous or semi-autonomous coordination via Ethereum, not just basic contract calls. - Include at least one component demonstrating agentic reasoning, decision-making, or cooperation. - Provide a short write-up or demo video explaining both why Ethereum matters and how the agentic aspect functions. - Strong entries will demonstrate an understanding of how to attract agents, including what problem they’d solve, what value they’d gain, and why Ethereum is the right foundation. Judging Criteria: - Visionary Potential - Originality - Coherence - Execution - Go-to-Market for Agents - Composability

AI is transforming the battlefield of smart contract security. As vibe coding accelerates and more unaudited protocols rush to deployment, vulnerabilities are slipping through human review processes. At the same time, AI-driven attackers are getting faster, smarter, and more adaptive; therefore, the defenders must evolve too. AgentArena is where that evolution takes place — a competitive platform where AI security agents battle-test smart contracts to uncover vulnerabilities before they fall prey to hackers. Each agent acts independently, scanning, reasoning, and reporting vulnerabilities for bounties. This hackathon invites agent builders, AI researchers, and security engineers to build new agents that will join the swarm competing in AgentArena. Your mission: create the most capable, creative, and effective autonomous agent for vulnerability discovery. Your Challenge: - Build a new security agent using our Agent Template - Design your own strategy — whether it’s reasoning-driven, model-assisted, heuristic-based, or something entirely new. - Optimize for insight, depth, and originality in how your agent identifies vulnerabilities. - Compete for a $3,000 grand prize and a place in the next generation of autonomous code security. Even if you don’t win the prize, all submitted agents can continue to evolve and participate in future AgentArena competitions, earning bounties for every valid exploit they uncover.

Qualifications

Your agent will be evaluated on: 1. Strategy & Creativity - How original and effective is your approach to vulnerability detection? - Does your agent demonstrate a clear reasoning process or novel search strategy? 2. Performance in Test Runs - Quality and relevance of the vulnerabilities identified in our test repositories. - Depth of analysis and ability to surface meaningful security insights. 3. Code Quality - Clean structure, clarity, and readability of your implementation.

The age of autonomous agents is here, but it runs on a massive trust deficit. How do you prove an AI agent did what it was supposed to do, and nothing more? ChaosChain is the accountability protocol for the agentic economy. We're building the open-source infrastructure to make AI agents trustworthy by design. We invite you to build on our Triple-Verified Stack, a framework for end-to-end verifiable agent workflows: 1. Intent Verification: Proof that a human authorized an action. 2. Process Integrity: Proof that the correct code was executed (leveraging TEEs like EigenCompute or just a hash of the code). 3. Outcome Adjudication/Accountability: On-chain consensus that the result was valuable and correct. Built on open standards like AP2, x402 and ERC-8004, ChaosChain turns trust into a programmable primitive. Your challenge is to utilize our SDKs to develop an application or service that leverages one or more verifiable AI agents. Show us what's possible when you can cryptographically prove an agent's identity, actions, and results. What can you build with this? * Verifiable Risk Oracles for DeFi * Autonomous E-commerce Agents that handle payments * Decentralized service marketplaces * Auditable scientific research agents * Autonomous DAO Manager * Decentralized Physical Infrastructure (DePIN) Agen The possibilities are endless when trust is a primitive.

Qualifications

Qualifications: 1. Use the ChaosChain SDK (Python or TypeScript) as a core component of your stack. 2. Implement x402 payment flow (verify + settle), via our hosted facilitator (embedded in our sdk). 3. Show at least one verifiability link in the chain (preferably more): - AP2-signed intent, and/or - Process integrity artifact (hash/attestation/log), and - Outcome anchoring with ERC-8004 (proof/claim/registry write or mock if testnet). 4. Submit a 2–3 min demo video + public GitHub with setup instructions. Judging Criteria: 1. End-to-end verifiability: clear mapping of Intent (AP2) → Process integrity → Outcome adjudication (ERC-8004). 2. Correct x402 integration: proper 402 flow, verify/settle, real (or testnet) payments. 3. Utility & UX: solves a real agentic use case; smooth DX for other builders. 4. Technical depth: thoughtful architecture, clean code, receipts/links to proofs. 5. Presentation: concise video, readable README, reproducible demo.

Smart contract security remains one of the toughest challenges in Web3 — and the gap is widening. As AI accelerates code generation and vibe coding pushes unaudited contracts to the Ethereum mainnet, vulnerabilities are slipping through faster than review processes or traditional audits can catch them. AuditAgent fights fire with fire. It’s an AI-powered pre-auditing solution that uses large language models to analyze smart contract source code, documentation, and specifications — detecting vulnerabilities, inconsistencies, and logic flaws before deployment. In this challenge, you’ll put AuditAgent to the test: Run it on your own smart contracts, identify a major vulnerability, and fix it. Your mission: demonstrate how AI-driven auditing can make your contracts safer and your development process more secure. Your Challenge: 1. Run AuditAgent on one or more of your smart contracts. 2. Use its analysis to identify a genuine vulnerability or logical issue. 3. Fix the issue and submit your before/after code along with a brief summary of what you found. The goal is to showcase real impact — using AI to strengthen your code.

Qualifications

Prize of $500 — awarded to the best submission demonstrating: - A real, meaningful vulnerability identified and resolved using AuditAgent. - A high-quality fix that effectively addresses the issue. Judging Criteria: 1. Impact of the Discovery - Significance and severity of the vulnerability found. 2. Use of AuditAgent - How effectively the tool was leveraged to identify and address the issue. 3. Quality of the Fix - How well the patch resolves the problem and improves contract safety.

What to build: ROFL (Runtime Off-chain Logic) apps run inside a Trusted Execution Environment (TEE). They rely on Sapphire for registration, billing, virtual machine management, and secure storage of secrets and configuration. Execution with ROFL takes place entirely off-chain, making it ideal for compute-intensive or always-on services such as secure decentralized oracles, bridges, AI agents, LLM chatbots, and more. Redundancy is possible with native support for replicas. Apps running with ROFL can also access its integrated key management service, allowing Sapphire smart contracts to verify that a transaction was genuinely signed from within the TEE. Additionally you can add multisig admin control over your apps deployed with ROFL for higher integrity. Please note: The Oasis Foundation reserves the right to adjust the reward structure based on the quality and relevance of the submissions received.

Qualifications

Demo video up to three minutes long A text description explaining the features and functionality of your project An open-source Github repository with a complete README A way to test the project, including a link to the app or testing instructions Complete the submission form by the final deadline Optional: Present your hack at the booth that you don’t get overlooked

Awarded to the team that builds the most impactful and technically robust application powered by the Octav API. This prize recognizes projects that leverage Octav’s portfolio, wallet, transaction, and token endpoints to deliver real-time DeFi insights, analytics, or automation. Judges will evaluate innovation, data integration depth, and user experience in demonstrating how Octav’s infrastructure can power next-generation DeFi tools.

Qualifications

1. Use the Octav API as a core data source (e.g., portfolio, wallet, transaction, or token data). 2. Include at least one authenticated API call with a valid Octav key. 3. Present a functional demo or hosted app that demonstrates live data usage. 4. Incorporate meaningful data processing or visualization beyond raw API output. 5. Provide a clear README or documentation explaining API endpoints used and app architecture. 6. Be fully built within the hackathon timeframe and submitted before the deadline. 7. Bonus consideration for AI integrations using Octav’s AI Development Framework for intelligent insights or autonomous DeFi actions.

Awarded to the team that builds the most innovative, functional, and visually cohesive Octav Widget leveraging on-chain data. Projects must demonstrate how the widget extends the Octav dashboard experience through analytics, DeFi insights, or portfolio visualization while maintaining performance and usability. Evaluation will focus on creativity, utility, and implementation depth.

Qualifications

1. Be built using Octav’s Widget Template. 2. Integrate live on-chain or Octav API data. 3. Function within the Octav dashboard environment (no standalone apps). 4. Include at least one configurable user element (chart range, token, chain, etc.). 5. Provide a public demo and GitHub repository showing widget source code. 6. Be submitted before the hackathon deadline.

We want to see projects building innovative payment projects, either using x402 and agentic tooling developed by Polygon deployed to the Polygon network, or just straight up super useful to merchants, services, and more. Polygon is already solidified as the leader in payments and stablecoins, but a leader needs to keep innovating and growing: bring us your use cases and let us grow together! We're looking for three kinds of projects: 1) Combining x402 with an AI / Agentic application 2) Projects that expand the x402 protocol: Privacy, Batching, Refunds / Fraud Management, Integration with 8004, Identity, etc. 3) Payment flows (not gambling! not defi per se) - merchant applications, services, payment processing middleware, wallets and mobile apps, etc. The more your idea can bring payment transaction count up (no botting!), the better!

Qualifications

• Application deployed to Polygon Network • A GitHub repository with README.md, demo link or setup instructions • Demo Video or live presentation. Keep in mind the internet sucks, so to be safe, recording a video is probably better.

We’re awarding $10,000 to the best builders using the Symbiotic Relay SDK! Relay Apps let you create stake-secured attestations that connect off-chain computation, oracles, AI outputs or any other data/events to on-chain actions. Top 3 teams with the most creative, technically solid, and high market potential Relay Apps will share the prize pool.

Qualifications

1. Submit a short demo video (up to 3 minutes) that walks through your project and shows it in action 2. Project must integrate the Symbiotic Relay SDK to generate or verify a stake-backed attestation and showcase a functional prototype during judging 3. Include a brief README.md describing your project’s purpose, features, and design choices 4. Provide a public GitHub repo with clean code, documentation, and setup instructions 5. Make your project testable – include a live link or clear steps for running it locally 6. Ensure all required submission fields are completed before the final deadline (Optional) Show off your project in person at the Symbiotic booth

Rewarding the most compelling end-to-end product built on Amp datasets. Example Use Cases: - Cross-chain portfolio dashboard that aggregates wallet positions and liquidity using Amp token datasets. - Risk analytics or MEV monitor that visualizes transaction patterns or protocol surface exposure. - NFT trait liquidity explorer that ranks collections by floor depth and trading velocity using Amp NFT datasets.

Qualifications

Builders should demonstrate how Amp datasets can power real-world insights, analytics, alerts, agent workflows, risk dashboards, or user experiences across DeFi, NFTs, RWAs, or AI.

Connect The Graph’s products in AI or autonomous agent workflows, including Token API MCP, Subgraph MCP, or Substreams to train AI models. Example Use Cases: - Leverage The Graph’s Token API in ChatGPT 5 to create a new AI agent that pulls onchain data for a novel use cases like onchain accounting for a DAO or real-time trading across multiple chains - AI trading or monitoring agent that queries Token API price and liquidity data through the Token API MCP server. - Governance summarizer bot that pulls DAO data from Subgraphs MCP to generate natural-language updates.

Qualifications

Builders should focus on one of the following: - intelligent data consumption - decision-making - automation using verifiable onchain data.

Apply your hacking skills to generate the best APY or improve the user experience of DeFi for the masses on Zircuit. This prize will be split among the best DeFi protocols that deploy on Zircuit, with quality, security, and novelty being the deciding factors. Remember: deploying on Zircuit is as easy as changing your endpoint in your favorite development framework and a project is eligible as long as the contracts are deployed on Zircuit and verified. These DeFi protocols are the ones that will launch a new DeFi summer. Your project should be clearly identifiable as a DeFi protocol. Quality, completeness, and security are paramount. A protocol that lets you (or others!) steal from your users is not a winning submission. Use cases should be well thought out and documented. Through superior UI/UX or novel use cases for staking, your project should aim to give well established DeFi juggernauts cause for concern. This bounty will be judged based on completeness, execution, and creativity.

Qualifications

1) Project contracts must be deployed on the Zircuit Testnet and verified via the Zircuit Explorer. 2) A GitHub repository containing the project artifacts (contracts, tests, documentation) and a solid README or short video demo of the project. The README should include: - a clear short one-sentence description of your submission - a short description of what you integrated Zircuit with and how - short description of the team and their backgrounds - clear instructions for testing the integration - feedback describing your experience with building on Zircuit optionally, a short video demo or slide deck.

Zircuit supports EIP-7702 which brings some account abstraction on-chain. This bounty is to use this functionality in a new and complete way on-chain. This can include deploying contracts to delegate to, interfaces to use the new transaction types, and more. Remember: deploying on Zircuit is as easy as changing your endpoint in your favorite development framework. You may need to use command line tools to use 7702 functionality (see the links!). A successful submission will include a functional prototype that solves the problem it’s intended to address. It will showcase some innovation/creativity, either through technological or UI improvements. It may be complete and solve a long-standing open problem or introduce something with a lot of potential for future development. Either way, it has an impact on the Zircuit ecosystem. Winning projects should have a user-centered design that makes it easy for the target audience. This can be end users or developers integrating the project into their own codebase. The best may also include clean and consistent visual designs. Any interesting blockchain applications are welcome. Novel ideas are more impressive than clones of existing projects, though there are certainly times where clones include significant improvements. Those that are very technical may impress the judges if done correctly but simpler ideas may be easier to do well. This bounty will be judged based on completeness, execution, and creativity.

Qualifications

1) Project contracts must be deployed on the Zircuit Mainnet or Garfield Testnet and verified via the Zircuit Explorer. 2) A GitHub repository containing the project artifacts (contracts, tests, documentation) and a solid README or short video demo of the project. The README should include: - a clear short one-sentence description of your submission - a short description of what you integrated Zircuit with and how - short description of the team and their backgrounds - clear instructions for testing the integration - feedback describing your experience with building on Zircuit - optionally, a short video demo or slide deck.

Integrate Zircuit into your favorite web3 project. Bring Zircuit to wallets, dev tools, bridges, or any other dApp. Grow the Zircuit Ecosystem by connecting Zircuit to the best that web3 has to offer. Success looks like Zircuit running with an on- or off-chain app or tool that didn’t support it before. The integration should be correct and functional, but does not need to be complicated. Some integrations can be as simple as adding a chain ID or a node URL to a file. The project should have an impact on the Zircuit ecosystem by expanding its reach. This bounty will be judged based on completeness, usefulness, execution, and creativity.

Qualifications

1) Project contracts must be deployed on the Zircuit Mainnet or Garfield Testnet and verified via the Zircuit Explorer. 2) A GitHub repository containing the project artifacts (contracts, tests, documentation) and a solid README or short video demo of the project. The README should include: - a clear short one-sentence description of your submission - a short description of what you integrated Zircuit with and how - short description of the team and their backgrounds - clear instructions for testing the integration - feedback describing your experience with building on Zircuit - optionally, a short video demo or slide deck

Build the next generation of privacy-preserving applications using vlayer’s ZK Prover Server - a REST API that compresses Web Proofs into zero-knowledge proofs (ZKPs). Prove the validity of real-world web data without revealing its contents. Think: privacy-preserving verification for the internet 🌍 💡 Example Use Cases: - Real-World Data Feeds: Feed verified web data (e.g., commodity prices, weather APIs) into smart contracts. - Proof of Engagement: Prove you posted, commented, or followed someone on social media - and verify it on-chain. - Reputation Scoring: Aggregate verified actions across platforms into a unified, on-chain reputation score. - Trustless Oracles: Combine vlayer proofs with existing oracles (like Chainlink or Redstone) for hybrid verification.

Qualifications

This application has it all - a great idea and a best-in-class implementation. To qualify, the project must use vlayer’s Web Prover Server (POST /compress-web-proof and POST /verify-zk-proof), and incorporate both Prover and Verifier smart contracts. Developers must also provide proof of RISC Zero contract deployment.

Build something awesome using vlayer’s Web Prover Server - a REST API for generating and verifying cryptographic web proofs with the TLSNotary (TLSN) protocol. With just a few lines of code, you can prove that data came from any public endpoint or OAuth call (like Reddit, GitHub, Twitter, or an exchange API) - without exposing your private information. Turn any HTTPS response into a trustless proof verifiable by anyone 🤯 💡 Example Use Cases: - Reddit Identity Verifier: Prove your Reddit username by generating a TLS proof of your /api/v1/me profile. - GitHub Contributor Badge: Verify open-source contributions directly from the GitHub API. - Proof of Assets: Generate Web Proofs from exchange APIs (like Binance or Coinbase) to show account balances without revealing personal info.

Qualifications

The application must generate Web Proofs using vlayer’s Web Prover Server for server-side proof generation and verification (POST /prove and POST /verify).

vouch enables applications to verify user-owned data from internet platforms without accessing or storing sensitive information. Using vouch’s existing data sources - or a new one you create - integrate vouch Web Proofs into your application to unlock privacy-preserving credentials and verification. 💡 Example Use Cases: - Identity & Age Verification Credential: Verify age or residency without exposing personal details, and issue a vouch claim such as “User X is over 18” or “Resident in Jurisdiction J.” - Social Media Engagement Credential: Verify a user’s follower count, posts, or community memberships (e.g., Reddit, Twitter), and issue a vouch attestation like “User X has >1,000 followers and posted in r/web3.”

Qualifications

The application must use vlayer’s client-side proving service (vouch) to generate Web Proofs. Developers may use existing data sources or create new ones.

Push the boundaries of what vouch can do by creating a brand new data source for the vouch catalog. This track rewards builders who go beyond integration - extending the protocol itself with new verified data types, APIs, or attestation logic that others can reuse across the ecosystem. 💡 Example Use Cases: - YouTube Creator Credential: Add a data source that attests to a creator’s subscriber count, view count, or verified channel status. - Financial Data Source: Build integrations for platforms like Robinhood, Revolut, or Kraken to verify balances, transactions, or activity metrics. - Academic Credential Source: Integrate APIs from Coursera, edX, or university verification portals to attest to course completions or degrees.

Qualifications

Must create a new vouch data source in the vouch catalog that demonstrates a new use case and/or improves the protocol.

Build something impossible elsewhere. This track celebrates developers who push the boundaries of what's possible by leveraging 0G's groundbreaking infrastructure stack. ------------------------------------- What We're Looking For: Projects that showcase the unique advantages of 0G's technology: 🔹 Infinite scalability through our DA layer 🔹 High-throughput decentralized storage for data-intensive applications 🔹 Decentralized AI compute network for verifiable, on-chain intelligence 🔹 EVM compatibility for smart contract deployment The key question: Could your project exist without 0G? If the answer is no, you're on the right track. ------------------------------------- Inspiration (Not Requirements): We're excited to see creative applications across any domain, including: 🔹 AI agents with verifiable computation and permanent memory 🔹 Decentralized ML training platforms with proof of contribution 🔹 High-performance storage solutions for media, gaming, or scientific data 🔹 On-chain games with AI-driven NPCs, procedural generation, or dynamic environments 🔹 DeFi protocols enhanced with AI-powered risk analysis, yield optimization, or market predictions 🔹 Decentralized social platforms with content moderation or recommendation engines ------------------------------------- Mainnet Bonus: Projects that fully deploy their smart contracts and storage solutions to 0G Mainnet will receive extra points. Show us you're ready for production.

Qualifications

Submission requirements: 🔹 Project name and a short description 🔹 Contract deployment addresses/Storage Hash 🔹 Public GitHub repo (README + setup instructions) 🔹 Demo video & live demo link (keep the video under 3 mins!) 🔹 Explain which protocol features or SDKs you used 🔹 Team member names and contact info (Telegram & X)

Using VisualSign the project must integrate with one of the "Top-Tier" protocols (example provided below). The prize will go to the top three teams with the best and most strategic use of VisualSign. This prize is not for the "coolest" or "most creative" hack, but is a targeted bounty to manufacture a high-quality, high-prestige case study. Please read the qualification requirements carefully.

Qualifications

This $5,000 prize effectively commissions the creation of a "killer feature" demo. The winning project will be the tangible proof-of-concept shown to other wallets and dApps, demonstrating that VisualSign can successfully render complex, high-value transactions on a real-world target. Evaluation will be based on the complexity of the transactions parsed. A parser for a simple swap is far less valuable than one that clearly renders complex, multi-step interactions such as stake, borrow, delegate, or create_pool. Top tier protocols to integrate with: Aave, Curve Finance, EigenLayer, Ethena, Ether.Fi, Lido, SparkLend, Uniswap. If there is a specific project that you work with and can see VisualSign integrated with in a strategically valuable way please use that!

Use VisualSign across any dapp of your choice. The goal is to see all that VisualSign can interact with! We’re calling on builders to create with VisualSign across dapps, and to reimagine secure signing.

Qualifications

This PR must contain a working VisualSign-parser chain module for ethereum for at least one function on a unique Ethereum dApp. Include the code that you're using to decode the raw transactions, including at least a valid transaction from a block explorer as well as a test that displays clearly what the user should see. You should show what the decoded representation looks like in the human readable mode in your pull request to qualify for the award.

Prize Track: Sports x DeFi Build DeFi that bridges the on-chain and off-chain sports economy. From athlete-backed tokens and predictive staking systems to yield models tied to match performance or fan engagement, this track rewards projects that turn fandom into financial participation — where fans, clubs, and creators share real on-chain value. Ideas to inspire hackers: - On-chain fantasy staking systems (predictive + yield). - Tokenized sports tickets as collateral or tradable assets. - DeFi-driven ticketing or real-world yield use cases - LP pools tied to fan token performance or match outcomes. - DeFi primitives that reward community contributions (watch-to-earn, play-to-support). - Real-world athlete or club revenue tokenization. - Fan-funded infrastructure or decentralized sponsorship systems

Qualifications

Contract deployed and/or transactions happening on Spicy Testnet or Chiliz Chain Mainnet

Prize Track: Fan Ownership Build apps that give fans true ownership — not just engagement — in their favorite clubs, creators, or moments. From dynamic NFTs and tokenized memberships to fan-governed DAOs and AI-powered fan identities, this track rewards projects that turn passion into real participation and value. Ideas to inspire hackers: - Tokenized membership or loyalty passes that evolve with engagement. - Dynamic NFTs that track a fan’s journey or “season stats.” - Tools for creators or athletes to issue personalized tokens. - Fan-powered DAOs or governance dashboards for clubs. (Can use AragonDAO) - AI agents that represent a fan’s digital legacy or fandom identity. (Can use ElizaOS)

Qualifications

Contracts Deployed and/or app transactions happening on Spicy Testnet or Chiliz Chain Mainnet

Citrea opens the door to an entirely new class of Bitcoin powered experiments. Some brilliant, some chaotic, some beautifully unhinged. The Best Degen Bapp track is for the builders who think outside the box, break assumptions, push boundaries, and ship the kind of ideas that make people say: “Wait… you built what on Bitcoin?” This track looks for creativity in its rawest form, whether your project looks impractical, shockingly clever, or something so new that it breaks normal categories. If it makes us laugh, mock, or rethink what Bitcoin applications can be, you're in the right place. We can't actually give examples for this category but here are few we could think of: Bitcoin native social experiments: Chaotic coordination games, on-chain memes with mechanics, self destroying apps for privacy (somehow). Game-Fi but Bitcoinized: Mine to Mint apps, Burn to mint puzzles, proof of vibes systems, mining inspired game mechanics. Useless but brilliant tools: Anything that feels like why we need crypto for this but is actually genius. Weird primitives: Be creative. Look for mechanisms no one asked for but everyone suddenly needs. “Why not?” apps: If it breaks regular models, that’s the energy we look for. Look for daily apps and how to enable them Bapps. If your project fits nowhere else, it probably belongs here. Building for this track does not prevent you from also applying to the Innovation track. Let chaos inspire you.

Qualifications

- Integrate Citrea (contracts deployed to Citrea testnet and/or frontend using Citrea RPC) - Explain how you’re using Citrea in the description - Be open source (public GitHub during judging) - Show a working demo (ideally a deployed live link, or video + alternatively provide instructions to build & run on a local environment or showcase to the Jury at booth) - Include any necessary links, deployed addresses/tx hashes, and etc.

This track is for teams who want to work on ideas that strengthen Bitcoin’s role in the world: sound money, global access, resilience, interoperability, and long-term utility. If your project focuses on unlocking new possibilities for Bitcoin users or enhancing Bitcoin’s functionality, this is the right place for it. Some areas of interest include: - Privacy and sovereign money systems - Bitcoin x AI x Citrea integrations - Bitcoin-secured RWAs or new asset models - Community-focused Bitcoin apps such as ROSCAs and savings circles - Cross-chain and interoperability solutions - Infrastructure that improves security, scalability or user experience - Any novel concept that uses Citrea to extend what Bitcoin can do This track is all about building the next generation of Bitcoin applications and tools with clear purpose and long term impact. If your work contributes to the future of Bitcoin, you belong here.

Qualifications

- Integrate Citrea (contracts deployed to Citrea testnet and/or frontend using Citrea RPC) - Explain how you’re using Citrea in the description - Be open source (public GitHub during judging) - Show a working demo (ideally a deployed live link, or video + alternatively provide instructions to build & run on a local environment) - Include any necessary links, deployed addresses/tx hashes, and etc.

Build a web3 dApp that sets the benchmark for simplicity and user experience in web3. We are looking for innovative solutions across the DeFi, Web3 Gaming and AI Agents domains. Bonus points for leveraging the gasless nature of the chain and integrating the DeFi primitives like the Saga Dollar yield-bearing stablecoin.

Qualifications

- Deploy smart contract your Saga L1 chain (Reach out to TG: @DeJen for access) - Projects must have a accessible UI/frontend, and a GitHub repository with a descriptive README which includes a short description of your submission and why you chose Saga chainlet - Demo video

Create a project that uses our onchain verification for disclosure proofs. We are looking for interesting use cases of using the Self onchain SDK in your contracts. Self Smart contracts verify proofs, manage a merkle tree of identity commitments and allow for onchain disclosure of data while guaranteeing the permissionless aspect of the protocol. Using the Self.xyz SDK, allows a user to disclose their country, age (or range), that they are not on OFAC or from a sanctioned country, and verify that proof that onchain on the Celo network, or offchain, without sharing any private information with third parties.

Qualifications

To be eligible, projects must: - implement Self onchain SDK (right now only on Celo mainnet and testnet) - proof needs to work

Create a project that uses our off chain/backend verification for disclosure proofs.

Qualifications

To be eligible projects must: - implement Self offchain SDK - proof needs to work

This one is an interesting track for devs to experiment and innovate. If you’re building a project focused on DeFi, Payments, or agentic payments, then this track is for you! Integrate crosschain intents with Avail Nexus SDK into your app in a meaningful manner. Utilize powerful features like "Bridge & Execute", or "XCS Swaps (crosschain swaps)" to build your app. Rethink how DeFi or Payment rails are built. Build innovative solutions. Example Ideas: - Adaptive Yield Router: what if users can move their idle stables to best APY anywhere; weekly replace intents with checking all guardrails such as slippage, gas ceiling etc. At a click of a button by a user. - Payroll & Splits: Pay your team across any chain with any token. Abstract and consolidate funds from anywhere. - An app that allows you to deposit unified USDC/USDT on the highest yield generating market on Aave/Morpho - A browser extension that allows you to spend unified eth to stake on Lido

Qualifications

Qualification requirements: - README that clearly defines how Avail Nexus SDK is used - Meaningful use of Nexus SDK (nexus-core, nexus-widgets, or nexus-elements) - Show a demo of a crosschain intent interaction on the app. - Bonus points if you use Nexus SDK features like “Bridge & Execute” in the project.

For this track, devs are free to build anything, any dapp or usecase powered by Avail Nexus. Develop any innovative and efficient app across any vertical that seamlessly integrates the Avail Nexus SDK to share and transfer liquidity across chains. Example Ideas: - Unified gas refuel: “top up gas on X chain” or refuel for any token. similar to smolrefuel.com but with Nexus integrated and better pricing. - Intent playground: Visual Composer to drag/drop steps and simulate cost/latency before submitting - Intent explorer: Uses Nexus SDK intents and creates an explorer for navigating through a wallet’s intents. - A browser extension that allows you to spend unified eth to stake on Lido - An app that allows you to deposit unified USDC/USDT on the highest yield generating market on Aave/Morpho

Qualifications

- README that clearly defines how Avail Nexus SDK is used - Meaningful use of Nexus SDK (nexus-core, nexus-widgets, or nexus-elements) - Show a demo of a crosschain intent interaction on the app. - Bonus points if you use Nexus SDK features like “Bridge & Execute” in the project.

We're looking for the next viral Mini App on Celo! Focus on real-world consumer use cases for a wide audience. Whether its a fun game, an AI agent, or DeFi use case, build something that’s fun, creative and brings value to millions of users.

Qualifications

✅ Live Farcaster Mini App (must use Farcaster wagmi wallet connector to auto-connect wallet to app) ✅ Does onchain actions on Celo ✅ Verified contract deployed on Celo Mainnet (for agents, transactions on mainnet) ✅ Live Demo in Farcaster Wallet ✅ Open Source: Be public and free for others to review ✅ Not be a simple fork of an existing project ✅ Include a README.md with: A short description of what you integrated with Celo, and how it was done A short one-sentence description that clearly describes your project A short description of your team and their social handles

Build the most impactful application using Fluence CPU cloud API on decentralized infrastructure. 🎯 Objective Create application leveraging Fluence CPU cloud API that demonstrates real-world advantages of decentralized compute—whether through cost efficiency, scalability, or improved accessibility. 🚀 Examples Data processing pipelines • Web scrapers • API aggregators • Batch processing jobs • Blockchain indexers

Qualifications

🪼 To qualify, your project must integrate Fluence Cloudless Compute: • Host your backend or core logic on Fluence CPU Cloud. • Optionally leverage the Fluence GPU Containers API to power your compute-intensive workloads (e.g., ML inference, rendering, etc.). 🪼 Your submission must also include a README.md file covering: • What it does: Clear project overview and purpose. • How to set it up: Step-by-step setup and installation instructions. • How you use Fluence: Explain how Fluence APIs, instances, and hardware (CPU/GPU) are used in your architecture. • How to run it: Execution instructions, environment variables, or command examples. • Examples & visuals: Include sample inputs/outputs, screenshots, or example API calls. 🪼 Your project must be live and accessible: • Deployed on the Fluence Platform. • Include a public endpoint or access link. • Provide clear usage instructions (how to interact with the deployed version). 🪼 To ensure openness and reusability: • Include a recognized open-source license in your repository (e.g., MIT, Apache 2.0, or similar).

**Yellow is here to challenge you:** explore the capabilities of ERC-7824 and the Nitrolite Protocol, whether by contributing to or building with the **Yellow SDK**.

Qualifications

## **Hackathon project requirements** - **Integrate Nitrolite SDK:** demonstrate the use of ERC-7824 in facilitating state channel mechanisms within your application - **Provide a Working Demo:** submit a functional demonstration of your application, showcasing the integration - **Open Source Your Code:** ensure your project’s codebase is publicly accessible for evaluation

Build your project using Hardhat 3 as the main Solidity testing and network simulation tool

Qualifications

Usage of a Hardhat release 3.0.0*. Usage of Hardhat 2 releases won't qualify.

Build the best application using the EIL SDK, which is designed to make ETH and ERC-20 tokens seamlessly transferable across all L2 chains. Projects should demonstrate seamless token movement across multiple chains. The most innovative, creative and technically sound implementations of the EIL SDK will win. As the EIL SDK is designed to boost usability, good UX will also play a role. Judges will evaluate creativity, functionality, and how effectively the project leverages the EIL SDK.

Qualifications

Must demonstrate actual usage of the EIL SDK with relevant transaction payloads attached in the submission.

Turn real-world assets into programmable, composable digital primitives. Tokenized RWAs are rapidly becoming one of the most impactful Web3 use cases: from on-chain treasuries and money markets to supply-chain assets, invoices, or even real estate shares. This prize is for builders to bring asset value on-chain using MultiBaas as the backend infrastructure. What kind of creative things can you do with tokens? 💡 Some Ideas to Explore: 🏦 On-chain Treasuries – Tokenize treasury bills or money-market style assets with transparent yield reporting 📄 Invoice Financing – Build tokenized invoice marketplaces with automated cashflow tracking 🏠 Real Estate Shares – Fractional ownership, secondary trading, or compliance-aware transfer logic 📦 Supply Chain Assets – Track movement, custody, and settlement by tokenizing commercial goods 🪙 Stablecoins – Create an interface for minting and managing stablecoins, including compliance aspects, yield tracking, or anything else you think useful in the stablecoin world

Qualifications

An explanation of each MultiBaas feature you used with: - The feature name - What you used it for - A link to a line in your repo demonstrating the usage

Build practical DeFi applications on Rootstock and/or RIF technologies. We’re looking for accessible, efficient tools that redefine everyday finance, with a special emphasis on generating native bitcoin yield. 🔸Yield farming strategies 🔸Lending protocols 🔸Decentralized exchanges (DEXs) 🔸Liquidity pools

Qualifications

Qualification Requirements - Smart contract deployed in Rootstock and at least 2 on-chain (testnet) successful transactions. - Projects must have a description and a GitHub repository with a descriptive README. - The README should include: 1) Clear short one-sentence description of your submission. 2) Short description of what you integrated Rootstock with and how. 3) Short description of the team and their backgrounds. 4) Clear instructions for testing the integration. 5) Feedback describing your experience with building on Rootstock. 6) A short video demo or slide deck.

Build dapps on Rootstock and unleash your creativity. We’re looking for original solutions. Some examples include: 🔸DeFi Automation Agents 🔸Smart Contract Assistants 🔸Cross-Chain Interoperability Agents 🔸Decentralized Governance Helpers

Qualifications

Qualification Requirements - Smart contract deployed in Rootstock and at least 2 on-chain (testnet) successful transactions. - Projects must have a description and a GitHub repository with a descriptive README. - The README should include: 1) Clear short one-sentence description of your submission. 2) Short description of what you integrated Rootstock with and how. 3) Short description of the team and their backgrounds. 4) Clear instructions for testing the integration. 5) Feedback describing your experience with building on Rootstock. 6) A short video demo or slide deck.

Build anything that puts the RIF token to work on Rootstock; bonus points for slick, one‑step UX and creative token utility. 🔸RIF one‑click staking; bridge or swap then stake in a single flow 🔸RIF staking inside a Telegram mini‑app; think MEW‑style but in TG 🔸AI bot that answers English questions by querying Collective Graph subgraphs 🔸RIF‑POAPs; mint event badges or sub‑domain NFTs paid in RIF 🔸Social‑content rewards in RIF; track on‑chain engagement then tip users 🔸x402 payments; ship a lightweight SDK that lets devs accept USDRIF with Coinbase’s agentic standard

Qualifications

Qualification Requirements - Smart contract deployed in Rootstock and at least 2 on-chain (testnet) successful transactions. - Projects must have a description and a GitHub repository with a descriptive README. - The README should include: 1) Clear short one-sentence description of your submission. 2) Short description of what you integrated Rootstock with and how. 3) Short description of the team and their backgrounds. 4) Clear instructions for testing the integration. 5) Feedback describing your experience with building on Rootstock. 6) A short video demo or slide deck.

Only with native privacy can identity infrastructure work on-chain, because sensitive information simply cannot be exposed. Build on Aztec to create identity systems where people host credentials, attestations, or identity data that they can leverage across applications, whether on Aztec itself or composed cross-chain. This could be credential systems, DID infrastructure, verification mechanisms, aggregated attestations from multiple sources (like combining OpenBanking.nr and ZKPassport), or novel ways to prove facts about yourself without exposing everything.

Qualifications

• Must use Aztec Devnet's latest version • Must either compose in novel ways with existing identity applications like ZKPassport or create new ways of proving facts about yourself (attesting) • Must clearly demonstrate how Aztec's privacy layer becomes the identity infrastructure (not just use Aztec as an additional chain) • Identity data and control must remain with the user, not dependent on a centralized authority - Submission must include documentation or demo showing how end users would interact with and manage their identity

Privacy becomes more powerful across chains. Build applications that compose protocols across chains through Aztec's privacy layer to discover entirely new use cases that only work when privacy is composable across ecosystems. Leverage our bridge partners (Holonym, Substance Labs, Train, Wormhole and more) to create cross-chain experiences that weren't possible before.

Qualifications

• Must use Aztec Devnet's latest version • Must integrate with at least one of our bridge partners: Holonym, Substance Labs, Train or Wormhole • Application must leverage the Aztec network to either relay messages or send funds across chains • Must clearly demonstrate how Aztec's privacy layer enables the cross-chain interaction (not just use Aztec as an additional chain)

Privacy unlocks a design space we haven't fully explored yet. We know there are applications that become possible with native privacy that we haven't seen before. Build the thing that makes us say 'oh wow, that's why privacy matters.' This could be gaming mechanics, governance systems, DeFi patterns we haven't seen, confidential business logic, or something we haven't thought of. The constraint is: it should only be possible because Aztec has native privacy.

Qualifications

• Must use Aztec Devnet's latest version • Must clearly demonstrate how this application can only exist due to Aztec's privacy layer (not just use Aztec as an additional chain) • Must include clear documentation explaining why this application requires native privacy and how Aztec's specific capabilities enable it • Should demonstrate a testable implementation or working prototype (not just concept/wireframes)

For the app that proves users shouldn’t worry about gas ever. This prize rewards the cleanest implementation of Privy’s native gas sponsorship to deliver a frictionless experience: no pop-ups, no approvals, no confusion. Just clear actions that feel instant. Build something your non-crypto friends could use without knowing a transaction even happened.

Qualifications

- Must be built using Privy’s APIs or SDK. - Must use Privy for embedded wallet auth and management. - Must enable Privy’s native gas sponsorship and demonstrate a sponsored transaction as part of the core user experience. - Sponsored flows must use Privy’s sponsorship configuration (no custom gas abstraction logic).

For the app that shows what’s possible when payments become programmable. This prize goes to a team that uses x402 + Privy to make money move automatically in service of the user—whether that’s recurring actions, agentic flows, or onchain logic that just works without extra clicks. We’re looking for products that make automation feel natural, safe, and invisible.

Qualifications

- Must be built using Privy’s APIs or SDK. - Must use Privy to create and manage the user’s embedded wallet. - Must integrate x402 authorization in at least one core user flow (e.g., scheduled/recurring actions, automated payments, agent-driven transactions).

For the app that nails trust, speed, and continuity. Session signers let apps take actions on a user’s behalf even when they’re offline without requiring constant re-approvals. This prize goes to the team that uses session keys to deliver a fluid, high-velocity experience. Think one-tap payments, rapid-fire trading, or any workflow where every second counts.

Qualifications

- Must be built using Privy’s APIs or SDK. - Must use Privy for embedded wallet authentication and management. - Must generate and authorize a Privy session signer key for the user. - Must demonstrate at least one meaningful delegated action using the session signer (e.g., transaction execution without user re-approval, background/automated actions, offline-triggered flows, or high-frequency interactions like trading or payments).

We’re looking for sticky, culture-driven tools/products — something fun, useful, and interactive, leveraging AI tools & Agents. E.g. • Gaming Tools > Guild/Clan management dashboard/Portfolio tracker tailored for gamers • SocialFi > Social Speculation platforms, "Proof of Skill" MMR Matching platforms • AI Agents & Tooling > AI gaming assistants, NFT Creation platforms OR anything experimental that enhances the Ronin experience. Additional points if teams tap into the Ronin Culture (Integrating & Building for existing Ronin Games/NFTs/Ecosystem)

Qualifications

- Attach a Video Demo (Loom) & a working Frontend/UI with the github REPO. - Deploy a smart contract & run transactions on Saigon testnet/Ronin mainnent - Integrate Ronin’s Wallet SDK (onboarding, auth, session management)

Your project must use the Pipes SDK in a meaningful way. Judgement criteria is as follows: - How central and effective is the use of the Pipes SDK? - Is the project working, demo-ready, and usable? - Does it explore new ideas or unexpected use cases? - Is it easy to understand, replicate, and demo?

Qualifications

1. Provide a GitHub repository with source code and documentation. 2. Include a demo video (max 5 minutes) showcasing the working prototype. 3. Add a README explaining: - How you used the Pipes SDK - What problem your project solves - Any next steps or roadmap - Feedback from using the Pipes SDK (what was your experience? How was it?) 4. Teams must submit by the official ETHGlobal Buenos Aires deadline.

The Pipes SDK is used to pipe on-chain data from our decentralised data lake into any unique application, they usually power analytics dashboards or trading terminals. Here we are looking for the most extraordinary use of the Pipes SDK, the weirder the better!

Qualifications

1. Your project must use the Pipes SDK in a meaningful way (minimum: at least one pipe integrated into your architecture). 2. Provide a GitHub repository with source code and documentation. 3. Include a demo video (max 5 minutes) showcasing the working prototype. 4. Add a README explaining: - How you used the Pipes SDK - What problem your project solves - Any next steps or roadmap - Feedback from using the Pipes SDK (what was your experience? How was it?) 5. Teams must submit by the official ETHGlobal Buenos Aires deadline.

The most speculative/ degenerative use case of the pipes SDK. Think of the most trench friendly application, how would data pipelines power this?

Qualifications

1. Your project must use the Pipes SDK in a meaningful way (minimum: at least one pipe integrated into your architecture). 2. Provide a GitHub repository with source code and documentation. 3. Include a demo video (max 5 minutes) showcasing the working prototype. 4. Add a README explaining: - How you used the Pipes SDK - What problem your project solves - Any next steps or roadmap - Feedback from using the Pipes SDK (what was your experience? How was it?) 5. Teams must submit by the official ETHGlobal Buenos Aires deadline.

Build a peer-to-peer lending platform that uses Circles' trust graph as a credit scoring mechanism. Build systems where loan terms, interest rates, and collateral requirements are determined by trust relationships rather than traditional credit scores, enabling under-collateralized lending between trusted community members. Loans could be taken out in CRC or in other collateral, such as stables. Users’ personal CRC might (or might not) figure in the scheme as interest token, with the limited rate of personal CRC creation limiting the rate at which loans can be taken out.

Qualifications

- Use of Relative Trust score api endpoint (optional) - GUI for the loan experience (trust score page, borrowing, lending)

Best Cross-Chain Application deployed on ANY Espresso-integrated chain (Celo, ApeChain, Rari, Appchain, Molten, T3rn, NodeOps, Rufus, Huddle01, LogX).

Qualifications

The application must: - Have a cross-chain interaction (from a source chain to a destination chain). You can use message protocols like Hyperlane to perform the cross-chain interaction. - The source chain must be an Espresso-integrated chain (ApeChain, Rari, Appchain, Molten, T3rn, NodeOps, Rufus, Huddle01, LogX, Celo). The application must: - The message protocol (for example, Hyperlane), must read from the Espresso's Caff Node RPC. This is just a normal RPC instrumented to read from the Espresso Network.

build something your group of friends would actually use every day: to play, trade, vote, bet, share, or just have fun together.

Qualifications

Although there’s no native chat integration for mini apps (like fetching current group members), teams can still deliver full group chat experiences by using a hybrid combination of agents to access context—for example, a chat‑resident agent paired with a backend coordinator—to infer group membership and state and orchestrate collaborative actions inside chat.

Whether standalone or paired with a miniapp, show how agents can make chats smarter, more useful, or more fun.

Qualifications

Agent demos must be built in the Base app and use at least one supported content type: attachments, transactions, or inline actions.

* A concise 2–5 page concept note or design brief * Architecture and flow diagrams showing integration with the Bitcoin Trustless Vault * Optional risk model or system sketch (e.g., vault collateralization, protocol parameters) * Optional frontend or CLI demo of the application frontend * Links to whitepapers, mockups, or GitHub prototypes if available

Qualifications

Technical Insight & Feasibility – how clearly the design demonstrates secure trustless integration. DeFi Composability & Innovation – how creatively the Vault is used with existing Ethereum primitives. Economic Value & Scalability – potential for real on‑chain utility, TVL, or user adoption. Documentation & Clarity – quality of explanation, diagrams, and project organization.