Proxy

Proxy is an autonomous governance agent that bridges Ethereum mainnet DAOs with Base-native AI agents. It monitors Governor contracts in real-time, analyzes proposal states, and executes governance actions using non-custodial delegated authority.

The Problem: DAO participation is fragmented and inefficient. Delegates must manually monitor proposals across chains, remember to vote before deadlines, queue successful proposals, and execute them after timelocks expire. This leads to low participation, missed executions, and governance gridlock.

The Solution: Proxy acts as a "self-driving delegate" that never sleeps. It combines four cutting-edge protocols to create a transparent, non-custodial governance automation layer:

1. Virtuals (Base) - Hosts Proxy's agent identity and personality, enabling AI-driven decision-making with transparent reasoning for every action taken.

2. Envio HyperSync (Ethereum) - Streams real-time governance events from Compound Governor without expensive RPC polling, detecting proposals, votes, and execution opportunities instantly.

3. Lit Protocol - Enables non-custodial transaction execution via Programmable Key Pairs (PKPs) and Vincent Abilities. Users delegate scoped permissions to Proxy without surrendering private keys.

4. BlockScout - Provides transaction verification and human-readable summaries of all governance actions, creating a transparent audit trail.

How It Works:

1. Envio detects a new proposal on Compound Governor
2. Proxy's Virtuals agent analyzes the proposal state
3. When conditions are met (proposal active, succeeded, or queued), Proxy determines the optimal action
4. Lit Protocol executes the transaction using delegated authority
5. BlockScout verifies and displays the action with decoded method calls
6. Users see real-time updates in the beautiful Next.js dashboard

Key Features:

• Real-time proposal monitoring via Envio HyperSync
• Autonomous voting, queuing, and execution
• Non-custodial - users maintain full control via Lit's scoped delegation
• Cross-chain: Agent on Base, execution on Ethereum mainnet
• Transparent audit trail via BlockScout integration
• Beautiful UI showing agent status, proposals, and transaction history

Impact: Proxy represents a new paradigm for DAO governance, moving from manual, time-intensive participation to automated, efficient execution while maintaining decentralization and user control. It's not just a bot; it's a trustworthy digital delegate that works 24/7 to ensure governance proposals don't get stuck in the queue.

Tech Stack:

• Next.js 14 (App Router) + TypeScript + Tailwind CSS
• Deployed on Vercel with serverless functions
• 4 partner protocol integrations

Architecture & Partner Integrations:

🌐 Virtuals Integration: We deployed Proxy as a Virtuals agent on Base, giving it an onchain identity and personality. The agent communicates via webhooks (Next.js API route at /api/webhooks/virtuals) to receive governance updates and send execution commands. The virtualsService (src/lib/virtuals.ts) handles decision logic, formatting proposals for agent understanding, and logging all actions for transparency.

Benefit: Virtuals provides the "brain" - an AI-powered decision engine that reasons about governance actions while maintaining verifiable onchain identity.

📡 Envio HyperSync Integration: Instead of expensive RPC polling, we use Envio's HyperSync client to stream governance events from Compound Governor on Ethereum mainnet. The envioService (src/lib/envio.ts) subscribes to ProposalCreated, ProposalQueued, ProposalExecuted, and VoteCast events, decoding them into structured Proposal objects. HyperSync's efficiency (up to 2000x faster than RPC) means Proxy detects governance opportunities in near real-time.

Benefit: Instant event detection without RPC rate limits or high costs. Critical for time-sensitive governance actions.

🔒 Lit Protocol Integration: The core innovation - non-custodial execution. We use Lit Protocol's PKPs (Programmable Key Pairs) and Vincent Abilities to enable users to delegate scoped permissions to Proxy. The litService (src/lib/lit.ts) connects to Lit Network, encodes governance function calls (castVote, queue, execute), and signs transactions using the PKP. Users retain full control - they define exactly what Proxy can do and can revoke permissions anytime.

Benefit: Solves the custody problem. Users get automation without handing over private keys. This is the breakthrough that makes autonomous governance agents trustworthy.

🔍 BlockScout Integration: Transparency layer. The blockScoutService (src/lib/blockscout.ts) fetches transaction history for both Proxy's execution wallet and the Compound Governor contract. We decode governance method calls (castVote: 0x56781388, queue: 0xddf0b009, execute: 0xfe0d94c1) and generate human-readable summaries like "Voted FOR on proposal #127" or "Executed proposal transferring 20 ETH". Every action Proxy takes is visible and verifiable.

Benefit: Creates public accountability. Anyone can audit Proxy's actions via the dashboard or BlockScout explorer.

Frontend Architecture: Three main components (AgentStatus, ProposalList, TransactionHistory) fetch data from our API routes, which abstract the SDK complexity. We use React's useState for simple state management - no need for Redux/Zustand since blockchain is our source of truth. Tailwind CSS provides a modern, gradient-heavy design with partner badges prominently displayed.

API Layer: Six serverless functions handle:

• /api/governance/proposals - Fetches proposals via Envio
• /api/governance/actions - Executes actions via Lit
• /api/governance/state - Checks proposal state
• /api/transactions - Gets history via BlockScout
• /api/agent/status - Returns agent metadata
• /api/webhooks/virtuals - Receives agent commands

Hacky/Notable Details:

1. Cross-chain coordination: Agent lives on Base, but monitors/executes on Ethereum mainnet. This required careful webhook design to bridge the two networks.

2. Event signature mapping: We manually mapped Compound Governor event signatures (e.g., ProposalCreated: 0x7d84a6263ae0d98d3329bd7b46bb4e8d6f98cd35a7adb45c274c8b7fd5ebd5e0) since Envio HyperSync works at the raw log level. This gives us maximum performance.

3. Method decoding: Built custom decoder in blockScoutService to translate raw transaction input data into human-readable governance actions. Falls back gracefully when method is unknown.

4. Simulation mode: For the hackathon, Lit executions return simulated transaction hashes since we don't have production PKP delegation set up. The architecture is production-ready - just needs real keys.

5. Type safety everywhere: Full TypeScript coverage with custom types (src/types/governance.ts) for Proposals, Votes, GovernanceActions, and partner-specific payloads.

Challenges Overcome:

• Data formatting: Each SDK has different data structures. We normalized everything into our governance.ts types.
• Async coordination: Envio streams events, Virtuals processes them, Lit executes them, BlockScout verifies them - all async with proper error handling.
• Mainnet vs Testnet: Supporting both for demo (testnet) and judging (mainnet addresses).

What's Next:

• Multi-DAO support (Uniswap, Aave, ENS)
• Advanced decision logic using AI reasoning (via Virtuals' LLM integration)
• Push notifications when governance actions are taken
• Proposal simulation before execution (estimate gas, outcome prediction)