Gauntlet

The project is a decentralized challenge and reward system built primarily on Ethereum-compatible smart contracts, using PYUSD as the primary staking and reward token. The core on-chain components are the SponsorDAO and ValidatorDAO. Sponsors create challenges by staking PYUSD and providing metadata including the challenge domain, timeframe, and off-chain references (like IPFS links). Participants interested in the challenge can contribute funds to the challenge and submit their solutions off-chain, which triggers emitted events that the system listens to. Off-chain, an AI agent inspects each submission, determines the domain of the challenge, and routes it to a corresponding off-chain “dummy DAO” (or actual DAO in production) that simulates consensus on whether the challenge should be funded or accepted. Additionally, the AI generates zero-knowledge (zk) proofs to validate the correctness of participant submissions without revealing the solution itself. ValidatorDAO, which holds a special validation role, listens to these submission events and registers challenges requiring validation. Once the AI determines the winner(s) based on zk proofs, it communicates the results to ValidatorDAO, which marks the challenge as validated and calls SponsorDAO’s functions to finalize the challenge, transferring all staked PYUSD to the winner(s) or, if no valid winner is found, returning funds to the challenge creator. Throughout this process, events are emitted at every key step—challenge creation, participant funding, submission, verification, and completion—to ensure that off-chain services, the frontend, and any monitoring tools can synchronize with the on-chain state. This architecture ensures a secure, trustless, and auditable system where challenges are transparently funded and verified while leveraging off-chain AI and dummy DAOs to simulate human or community consensus and zk proofs for privacy-preserving verification of answers.

This project is a decentralized, blockchain-based challenge and reward platform designed to enable sponsors to create challenges, have participants submit solutions, and fairly determine winners using a combination of on-chain and off-chain logic. The backbone of the system is Solidity smart contracts deployed on Ethereum-compatible networks, with PYUSD chosen as the native ERC20 token for staking and rewards. The core on-chain components are SponsorDAO and ValidatorDAO. SponsorDAO handles challenge creation, participant staking, and payout logic, while ValidatorDAO acts as a verification and finalization layer that ensures challenges are completed correctly and securely. Access control is implemented using OpenZeppelin’s AccessControl and Ownable libraries to grant specific roles to sponsors, validators, and the system itself, maintaining a secure and auditable flow of actions.

Participants interact with the blockchain by funding challenges and submitting answers, which are recorded off-chain as events (rather than storing bulky data on-chain). This is where we integrated an event-driven architecture: every submission, funding, and completion emits events that off-chain services or listeners can capture. We leveraged these events to simulate off-chain decision-making, which allowed us to build “dummy DAOs” for different domains. Each dummy DAO simulates a community or expert vote and returns a consensus decision, which is crucial for deciding whether a challenge is fundable or accepted.

The AI agent is responsible for analyzing the submissions and categorizing challenges into specific domains, allowing it to route each challenge to the corresponding dummy DAO. Additionally, the AI generates zero-knowledge proofs (zk proofs) to ensure that submitted solutions are valid without revealing sensitive details. ValidatorDAO listens to challenge registration events and, once zk proofs are verified by the AI, calls SponsorDAO to mark the challenge as verified and complete, distributing the staked PYUSD either to the winning participant or, in fallback cases, to the challenge creator.

We tested the system extensively using Forge (Foundry). For Solidity, we wrote comprehensive unit tests for both SponsorDAO and ValidatorDAO, as well as an integrated end-to-end test that simulates the complete lifecycle of a challenge—from creation to participant funding, submission, validation, and payout. For the ERC20 token, we implemented a test version of PYUSD to simulate minting and transfers, which allowed us to rigorously test escrow and reward flows without using real assets.

One particularly hacky yet elegant solution we implemented was the event-driven communication between the on-chain contracts and off-chain AI/dummy DAOs. Instead of storing large submission data or performing heavy computations on-chain, we rely on events as a lightweight, gas-efficient bridge. This allows the blockchain to remain secure and immutable while the AI handles intensive computation and decision-making off-chain. Another notable design choice was using fallback logic in ValidatorDAO to handle cases where no valid winner is found, ensuring that challenges are always resolvable and funds are never stuck in the contract.

Technologies and frameworks used include:

Solidity 0.8.20 for smart contract development.

OpenZeppelin libraries for ERC20, access control, and safe token transfers.

Foundry / Forge for local testing and testnet deployment.

IPFS (simulated in tests) for metadata and submission storage.

Event-driven architecture for communication between on-chain contracts, AI, and dummy DAOs.

The combination of on-chain escrow, off-chain decision-making, and zk proof validation (can be implemented in future) ensures a system that is decentralized, auditable, and privacy-preserving while remaining gas-efficient and modular. Overall, the project integrates multiple layers—smart contracts, off-chain AI logic, simulated governance, and test infrastructure—into a cohesive challenge and reward platform suitable for hackathon demonstration or further extension into real-world usage.