🦔🫛 HedgePod Agent

Build your own AI-powered hedge fund

Autonomous cross-chain DeFi that makes 23M World App users their own hedge fund.

TL;DR: Deposit once. AI agents automatically rebalance across 8+ chains for optimal yield. Gasless. Chain-abstracted. Human-readable. Built for non-crypto users.

• 🚀 Live Demo: hedgepod.app
• 🎬 Demo Video: Watch on YouTube
• 💬 Discord: Join our community
• 📱 Telegram: t.me/hedgepod
• 🐦 Twitter/X: @hedgepod
• 📸 Instagram: @hedgepod_app
• 💻 GitHub: mollybeach/hedgepod

• What Is HedgePod?
• Key Integrations
• Architecture
• Multi-Language Support 🌍 19 languages
• Quick Start
  • Prerequisites
  • Installation
  • Environment Setup ⚡ Start here!
  • Deploy Contracts
  • Run Frontend
• Tech Stack
• Documentation
• Contact

HedgePod Agent is a World mini app that solves crypto's biggest UX problem: chain fragmentation.

Users deposit USDC/ETH/USDT once, and autonomous AI agents:

• Monitor yields across 8+ chains in real-time using Pyth Network price feeds and APR calculations
• Move funds via LayerZero omnichain fungible tokens (OFTs) with custom APR-aware routing logic
• Execute optimal swaps through 1inch aggregation across 50+ DEXs when profitable
• Trade on Uniswap v4 with dynamic fee hooks that adjust (0.1%-0.3%) based on real-time Pyth volatility data
• Access real pool data from The Graph's Uniswap v3 subgraphs for liquidity and volume information
• Ensure fair rewards using Pyth Entropy for verifiable randomness in agent selection
• Operate 24/7 autonomously powered by Coinbase CDP server wallets with x402 authorization
• All gasless (Privy sponsorship), all transparent (ENS names), all automated

Built for the 23M World App users who don't know what an RPC is—and never should.

✨ HedgePod's consumer-grade UI with Animal Crossing-inspired design

• Real-Time Data: All prices, volatility, liquidity, and volume from live APIs (Pyth, The Graph, 1inch)—no mock data
• True Cross-Chain: LayerZero OFT extended with custom logic—only moves funds if APR improvement justifies gas
• Dynamic Pricing: Uniswap v4 hook adjusts swap fees automatically based on market volatility to protect liquidity providers
• Autonomous Agents: Coinbase CDP server wallets execute rebalances 24/7 without user approval (via x402 authorization)
• Consumer UX: Animal Crossing-themed UI, ENS names everywhere, gasless transactions, World ID verification
• Multi-Language: Available in 19 languages to serve World App's global 23M user base

• LayerZero V2 - Extended OFT contracts with custom APR-aware routing logic. Only transfers funds cross-chain if yield improvement exceeds threshold. Deployed across 8 chains with automated peer configuration.

• Uniswap v4 - Dynamic fee hooks (VolatilityFeeHook.sol) that adjust swap fees (0.1%-0.3%) based on real-time Pyth volatility. Protects LPs from impermanent loss during high volatility.
• 1inch Aggregation Protocol - Swap, Quote, Price, and Liquidity Source APIs for optimal routing across 50+ DEXs. Used by agents for best execution and portfolio valuation.

• Pyth Network - Pull-based price feeds via Hermes API for ETH/USD, BTC/USD, USDC/USD. Volatility calculations from confidence intervals power dynamic fees.
• Pyth Entropy - Verifiable randomness for fair agent selection and weekly lottery rewards. MEV protection through random rebalancing order. PR Submitted
• The Graph - GraphQL queries to Uniswap v3 subgraphs across 5 chains. Real liquidity ($245.8M+ TVL) and 24h volume data—no mocks.

• World (MiniKit) - Full SDK integration for 23M user distribution. MiniKitProvider, wallet auth, SIWE, transactions via sendTransactionViaMiniKit().
• World ID (IDKit) - Orb-level verification for sybil resistance on agent deployment. Zero-knowledge proofs verify humanity without revealing identity.
• ENS - Human-readable addresses everywhere (jane.eth not 0x...). No crypto jargon visible to end users.
• Privy - Gas sponsorship for gasless transactions. Users never pay fees, maximizing accessibility.

• Coinbase CDP - Server wallets for 24/7 agent autonomy. x402 authorization pattern allows recurring rebalances without user approval.
• Supabase - PostgreSQL database for agent performance tracking, rebalance history, and portfolio analytics.

• Hardhat 3 - Smart contract development, testing (94% coverage), and multi-chain deployment automation.

┌─────────────────────────────────────────────────────────────┐
│ WORLD MINI APP (Next.js + MiniKit SDK)                      │
│  • Privy gas sponsorship (gasless UX)                       │
│  • ENS resolution (jane.eth not 0x...)                      │
│  • Octav widget (portfolio dashboard)                       │
└─────────────────────┬───────────────────────────────────────┘
                      │
                      ├──> Deposit USDC/ETH/USDT (any chain)
                      │
┌─────────────────────▼───────────────────────────────────────┐
│ HedgePod VAULT (Smart Contracts)                            │
│  • Deployed on: World Chain, Base, Celo, Zircuit, Polygon  │
│  • Issues AutoYield Tokens (LayerZero OFT)                  │
│  • Grants x402 authorization to agent wallet                │
│  • Integrated with Uniswap v4 pools (custom hook)           │
└─────────────────────┬───────────────────────────────────────┘
                      │
                      ├──> Agent monitors & rebalances 24/7
                      │
┌─────────────────────▼───────────────────────────────────────┐
│ YIELD AGENT (CDP Server Wallet)                             │
│  • Autonomous wallet with x402 authorization                │
│  • Monitors: Pyth APRs, 1inch liquidity                     │
│  • Rebalances via: LayerZero OFT, 1inch Fusion+, Uniswap v4 │
│  • Redundancy: Chainlink CCIP for critical ops              │
└─────────────────────────────────────────────────────────────┘

📊 Real-time portfolio tracking across 8+ chains with autonomous agents

HedgePod is available in 19 languages to serve users worldwide (all World Coin supported languages):

Language auto-detection: The app automatically detects your browser's preferred language and displays content accordingly.

Manual switching: Use the language selector in the header to switch between languages at any time.

Access any language directly:

• English: https://hedgepod.app/en
• Spanish: https://hedgepod.app/es
• Chinese: https://hedgepod.app/zh
• And so on...

node >= 18.0.0
npm >= 9.0.0

# Clone the repository
git clone https://github.com/mollybeach/hedgepod.git
cd hedgepod

# Install dependencies
npm install

REQUIRED - Create your .env file:

# Copy the example file
cp .env.example .env

Then edit .env with your actual values. Minimum required for deployment:

# 1. Your deployer wallet private key (from MetaMask)
DEPLOYER_PRIVATE_KEY=your_private_key_here

# 2. Alchemy RPC for Base Sepolia (get free at https://www.alchemy.com/)
BASE_SEPOLIA_RPC=https://base-sepolia.g.alchemy.com/v2/YOUR_ALCHEMY_API_KEY

# 3. WalletConnect for frontend (get free at https://cloud.walletconnect.com/)
NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID=your_walletconnect_project_id_here

Optional but recommended for full functionality:

# Block explorer verification
BASESCAN_API_KEY=your_basescan_api_key_here

# Additional networks
POLYGON_AMOY_RPC=https://rpc-amoy.polygon.technology
CELO_ALFAJORES_RPC=https://alfajores-forno.celo-testnet.org

You'll need testnet ETH before deploying:

• Never commit your .env file (already in .gitignore)
• Use a separate deployer wallet, not your main wallet
• Only fund what you need for deployment
• See docs/ENV_TEMPLATE.md for complete documentation

# Compile contracts
npx hardhat compile

# Run test suite
npx hardhat test

# Check coverage
npx hardhat coverage

Before deploying, make sure:

1. ✅ You've created your .env file (see Environment Setup above)
2. ✅ You have testnet funds in your deployer wallet
3. ✅ You've compiled contracts: npx hardhat compile

# Deploy to Base Sepolia (recommended first deployment)
npx hardhat run scripts/deploy/deployer.ts --network baseSepolia

# Or use Makefile shortcuts
make deploy-base-sepolia

# Deploy to all testnets
make deploy-all

After deployment, verify your contracts:

# Verify on BaseScan
make verify-base-sepolia

📚 Detailed deployment guide: docs/DEPLOYMENT_QUICKSTART.md

Before starting the frontend, create frontend/.env.local:

# frontend/.env.local
NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID=your_walletconnect_project_id_here

# Supabase (for agent performance tracking - optional for local dev)
NEXT_PUBLIC_SUPABASE_URL=https://your-project.supabase.co
NEXT_PUBLIC_SUPABASE_ANON_KEY=your-anon-key-here

📚 Database setup: See docs/DATABASE_SETUP.md for Supabase configuration (5 min setup)

Then start the development server:

# Install frontend dependencies (first time only)
cd frontend
npm install

# Start development server
npm run dev
# Open http://localhost:3000/en (or your locale)

Your frontend will automatically connect to deployed contracts using data from:

• frontend/lib/data/contracts_data.json (auto-generated on deployment)

🎨 Frontend features:

• 🦔 Animal Crossing-themed UI
• 💰 RainbowKit wallet connection (100+ wallets)
• 🌐 Multi-chain support (World, Base, Celo, Polygon, etc.)
• ⚡ Responsive design for mobile and desktop

# Start yield monitoring agent
cd backend
npm run agent:start

Status: 🚧 Ready for deployment to Base Sepolia, Polygon Amoy, Celo Alfajores

To deploy to testnets:

# Deploy to Base Sepolia (recommended first)
make deploy-base-sepolia

# Deploy to all testnets
make deploy-all

See deployments/ for full deployment history, ABIs, and verification commands.

📚 Deployment guide: docs/DEPLOYMENT_QUICKSTART.md

Smart Contracts: Solidity 0.8.24, Hardhat 3, OpenZeppelin, LayerZero OFT, Uniswap v4

Frontend: Next.js 14, TypeScript, TailwindCSS, World MiniKit, Privy SDK, wagmi, RainbowKit, next-intl (i18n)

Backend: Node.js, TypeScript, Coinbase CDP SDK, Pyth Hermes API, 1inch API, Supabase (PostgreSQL)

Oracle & Data:

• Pyth Network - Real-time price feeds & volatility for dynamic fees
• The Graph - Uniswap v3 liquidity & volume data via GraphQL subgraphs

Infrastructure: Alchemy, Vercel, Railway, Supabase

Integrations: LayerZero, Pyth Network, The Graph, 1inch, Uniswap v4, World, Coinbase CDP, Privy, ENS, Chainlink, Zircuit, Octav

Languages: 10 languages supported (English, Chinese, Spanish, Arabic, Portuguese, Indonesian, French, Japanese, Russian, German)

Comprehensive guides and documentation:

hedgepod/
├── contracts/          # Solidity smart contracts
│   ├── HedgePodVault.sol
│   ├── AutoYieldToken.sol
│   ├── YieldOracle.sol
│   └── VolatilityFeeHook.sol
├── frontend/           # Next.js frontend application
│   ├── app/           # Pages and routes
│   ├── components/    # Reusable UI components
│   └── lib/           # Utilities and contract data
├── backend/           # Agent backend (Node.js)
├── scripts/           # Deployment and utility scripts
│   ├── deploy/        # Deployment scripts
│   └── verify/        # Contract verification
├── config/            # Network and price configurations
├── deployments/       # Deployed contract addresses & ABIs
└── docs/             # Documentation

• 🚀 Live Demo: hedgepod.app
• 📧 Email: mollybeach@hedgepod.app
• 💻 GitHub: mollybeach/hedgepod
• 💬 Discord: Join our community
• 📱 Telegram: t.me/hedgepod
• 🐦 Twitter/X: @hedgepod
• 📸 Instagram: @hedgepod_app

MIT License - see LICENSE for details

Built for ETHGlobal Buenos Aires 2025 with:

• LayerZero for omnichain infrastructure
• World for 23M user distribution
• Coinbase CDP for autonomous agents
• And many other amazing sponsors!

🦔 Making DeFi accessible for everyone!