Sentinel 🛡️

Enterprise-Grade Autonomous DeFi Agent Platform - Describe your trading strategy in plain English, and let AI-powered multi-agent swarms execute it automatically on-chain.

🏆 Hackathon Track Submissions

This project is optimized for 5 concurrent hackathon tracks:

• 🥇 0G - Best Autonomous Agents & Swarms ($7,500) - Multi-agent coordination with persistent 0G Storage memory
• 🥇 0G - Best Agent Framework ($7,500) - Modular agent framework with iNFT tokenization
• 💚 KeeperHub - Best Use ($4,500) - Reliable execution layer for trades
• 🦄 Uniswap Foundation ($5,000) - Advanced API integration + FEEDBACK.md
• 🔤 ENS - Best Integration ($2,500) - Agent discovery via ENS domains

Total Prize Pool: $35,000+

🎯 Project Overview

Sentinel is an autonomous DeFi agent platform that enables users to create trading strategies using natural language. The AI-powered system parses user intent, validates routes via Uniswap, and executes trades automatically when market conditions are met.

Key Capabilities

• Natural Language Strategy Creation: Describe your trading strategy in plain English
• AI-Powered Parsing: 0G Network's decentralized LLM interprets your intent
• Autonomous Execution: KeeperHub monitors conditions 24/7 and executes when triggered
• Real-Time Monitoring: Live activity feed with WebSocket updates
• Multi-Agent Coordination: Specialized agents work together for optimal execution

🏗️ Architecture

┌──────────────────────────────────────────────────────────────────────┐
│                    Sentinel Multi-Agent System                   │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │                      Frontend (Next.js)                     │   │
│  │        • Agent Dashboard • Strategy Builder                 │   │
│  │        • Real-time Activity Feed • ENS Discovery           │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                              ▲                                       │
│                              │ WebSocket                             │
│                              ▼                                       │
│  ┌──────────────┬──────────────┬──────────────┬──────────────────┐ │
│  │  Architect   │   Executor   │   Monitor    │  Coordinator    │ │
│  │  Agent 🏗️   │   Agent ⚙️   │  Agent 📊    │                 │ │
│  │              │              │              │                 │ │
│  │ • Parse      │ • Execute    │ • Watch      │ • Swarm State  │ │
│  │   strategies │   trades     │   prices     │ • Coordination │ │
│  │ • Validate   │ • Gas opts   │ • Trigger    │ • Analytics    │ │
│  │   routes     │ • Slippage   │   conditions │                 │ │
│  │ • Risk       │   control    │ • Alerts     │                 │ │
│  │   assessment │              │              │                 │ │
│  └──────────────┴──────────────┴──────────────┴──────────────────┘ │
│         ▲           ▲            ▲            ▲                    │
│         │           │            │            │                    │
│         └─────┬─────┴─────┬──────┴─────┬──────┘                    │
│               │           │            │                           │
│               ▼           ▼            ▼                           │
│  ┌──────────────────────────────────────────────────────────────┐ │
│  │         0G Storage (Persistent Memory Layer)                │ │
│  │  • Agent state & execution history                          │ │
│  │  • Strategy library & coordination state                    │ │
│  │  • iNFT metadata & intelligence                             │ │
│  └──────────────────────────────────────────────────────────────┘ │
│               ▲           ▲            ▲                           │
│               │           │            │                           │
│         ┌─────┴───┬───────┴──┬─────────┴──────┐                  │
│         │         │          │                │                  │
│         ▼         ▼          ▼                ▼                  │
│  ┌─────────┐ ┌──────────┐ ┌──────┐ ┌──────────────────┐       │
│  │ Uniswap │ │ iNFT     │ │ ENS  │ │ KeeperHub        │       │
│  │ V3      │ │ (ERC-   │ │      │ │ (Execution       │       │
│  │ Router  │ │  7857)   │ │      │ │  Layer)          │       │
│  └─────────┘ └──────────┘ └──────┘ └──────────────────┘       │
│         │         │          │                │                  │
│         └─────────┴──────────┴────────────────┘                  │
│                       │                                           │
│                       ▼                                           │
│  ┌──────────────────────────────────────────────────────────────┐ │
│  │           0G Compute Network (Inference)                    │ │
│  │  • Strategy parsing & NLP                                   │ │
│  │  • Risk scoring & route optimization                        │ │
│  │  • Verifiable on-chain computation                          │ │
│  └──────────────────────────────────────────────────────────────┘ │
│                                                                  │
└──────────────────────────────────────────────────────────────────────┘

On-Chain: Ethereum Sepolia Testnet & 0G Chain (EVM-compatible)

🧠 Multi-Agent System Design

Architect Agent 🏗️

• Role: Strategy parser and route validator
• Responsibilities:
  • Parse natural language trading strategies using 0G Compute inference
  • Validate Uniswap V3 trading routes
  • Calculate gas estimates and price impact
  • Risk assessment and confidence scoring
• Memory: Persistent on 0G Storage + iNFT metadata
• Identity: ENS domain (e.g., architect.sentinelswap.eth)

Executor Agent ⚙️

• Role: Trade execution and optimization
• Responsibilities:
  • Execute validated swap routes on-chain
  • Gas optimization via KeeperHub
  • Slippage control and MEV protection
  • Transaction lifecycle management
• Memory: Execution history on 0G Storage
• Identity: ENS domain (e.g., executor.sentinelswap.eth)

Monitor Agent 📊

• Role: Continuous market observation
• Responsibilities:
  • Watch price conditions using Uniswap oracle data
  • Trigger swaps when conditions are met
  • Monitor transaction status and confirmations
  • Alert on anomalies (MEV, failed transactions, etc.)
• Memory: Condition history on 0G Storage
• Identity: ENS domain (e.g., monitor.sentinelswap.eth)

Agent Tokenization (iNFT - ERC-7857)

Each agent is minted as an NFT with:

• Embedded intelligence (model hash + capabilities)
• Persistent memory pointer (0G Storage KV)
• Ownership and royalty tracking
• Transferable autonomy

🚀 Quick Start

Prerequisites

• Node.js 18+
• npm or pnpm

Installation

# Clone the repository
git clone https://github.com/your-username/sentinelswap.git
cd sentinelswap

# Install backend dependencies
cd backend
npm install

# Install frontend dependencies
cd ../frontend
npm install

Environment Setup

Create backend/.env:

PORT=3001
DATABASE_URL=./sentinelswap.db

Running the Application

# Terminal 1: Start backend
cd backend
npm run dev

# Terminal 2: Start frontend
cd frontend
npm run dev

Open http://localhost:3000 in your browser.

💡 How It Works

1️⃣ Describe Your Strategy (Natural Language)

"Buy 1 ETH with USDC when price drops below $2,400, 
execute within 5 minutes if possible, max 1% slippage"

2️⃣ Architect Agent Parses & Validates

• Uses 0G Compute Network for NLP inference
• Extracts: trigger condition, swap parameters, risk constraints
• Validates liquidity on Uniswap V3
• Calculates gas cost + price impact
• Returns confidence score

3️⃣ Store Strategy in 0G Storage

• Architect persists strategy in 0G Storage KV
• Strategy becomes part of agent's persistent memory
• Other agents access via shared memory layer

4️⃣ Mint Strategy as iNFT (Optional)

• Package strategy + agent intelligence as ERC-7857 NFT
• Store encrypted strategy on 0G Storage
• NFT can be traded/composed with other agent NFTs

5️⃣ Monitor Agent Watches Conditions

• Polls Uniswap oracle every 30 seconds
• Checks if trigger price is met
• Uses 0G Storage to track monitoring state

6️⃣ Executor Agent Executes

• When trigger fires, Executor takes action
• Uses KeeperHub for reliable execution
• Optimizes gas via batch operations
• Stores execution result in 0G Storage

7️⃣ Real-Time Tracking

• All activity flows to frontend via WebSocket
• ENS resolves agent names for display
• History query available for analytics

---

🎯 Key Features

Multi-Agent Swarms

• Distributed Decision Making: Architect + Monitor + Executor collaborate
• Persistent Memory: 0G Storage as shared knowledge base
• Real-Time Coordination: WebSocket updates + on-chain events

Agent Tokenization (iNFT)

• ERC-7857 Standard: Agents as first-class on-chain assets
• Embedded Intelligence: Model checkpoints stored on 0G
• Transferable Autonomy: Sell/trade your trained agents

Enterprise Infrastructure

• 0G Chain Deployment: EVM-compatible, scalable agent hosting
• KeeperHub Reliability: 24/7 execution guarantees + MEV protection
• ENS Identity: Agent discovery + reputation via .eth domains
• Uniswap Integration: Real liquidity, real prices, real execution

Developer-Friendly

• REST API: All agent operations via HTTP
• WebSocket Feed: Real-time activity streaming
• Type-Safe: Full TypeScript support
• Open Source: Build on top of our framework

🛠️ Tech Stack

Frontend

• Next.js 14 - React framework
• Tailwind CSS - Styling
• Lucide Icons - Icon library
• WebSocket - Real-time updates

Backend

• Express.js - API server
• SQLite - Database (via better-sqlite3)
• TypeScript - Type safety
• ethers.js v6 - Blockchain interaction

Infrastructure

• 0G Storage - Persistent agent memory (KV + Log)
• 0G Compute Network - Strategy inference & validation
• 0G Chain - EVM-compatible deployment target
• KeeperHub MCP - Reliable trade execution
• ENS - Agent identity & discovery

Blockchain

• Uniswap V3 - Liquidity protocol & routing
• iNFT (ERC-7857) - Agent tokenization
• Sepolia Testnet - Development & testing
• 0G Chain - Production deployment

📡 API Endpoints

Strategy Management

• POST /api/strategies/parse - Parse natural language to strategy
• POST /api/strategies/deploy - Deploy a strategy
• GET /api/strategies - List all strategies
• PATCH /api/strategies/:id/pause - Pause strategy
• PATCH /api/strategies/:id/resume - Resume strategy
• DELETE /api/strategies/:id - Delete strategy
• POST /api/strategies/:id/execute - Execute strategy manually

Market Data

• GET /api/price - Current ETH price
• GET /api/quote - Get swap quote

Transaction History

• GET /api/history - Transaction history

Agent Control

• GET /api/agent/state - Agent status
• POST /api/agent/start - Start agent
• POST /api/agent/stop - Stop agent

Multi-Agent Swarm

• POST /api/swarm/initialize - Initialize 3-agent swarm
• GET /api/swarm/state - Get real-time coordination state
• POST /api/swarm/parse-strategy - Architect parses strategy
• POST /api/swarm/execute-trade - Executor runs trade
• POST /api/swarm/monitor - Monitor checks conditions

iNFT Agent Tokenization

• POST /api/inft/mint - Mint agent as ERC-7857 NFT
• GET /api/inft/agents - List all minted agents

ENS Agent Discovery

• GET /api/ens/discover/:role - Find agents by role
• GET /api/ens/resolve/:domain - Resolve ENS domain to agent
• GET /api/ens/agents - List all registered agents

0G Storage

• GET /api/storage/agent-memory/:agentId - Get persistent agent state
• GET /api/storage/all-strategies - Query all stored strategies

🎯 Current Features

Core Agent Capabilities

• ✅ Multi-agent swarm system (Architect, Executor, Monitor)
• ✅ Natural language strategy parsing
• ✅ Uniswap V3 route validation & optimization
• ✅ Real-time price monitoring via oracle
• ✅ Autonomous trade execution
• ✅ Transaction history with WebSocket streaming
• ✅ Strategy pause/resume/delete

Enterprise Features

• ✅ 0G Storage persistent memory layer
• ✅ iNFT agent tokenization (ERC-7857)
• ✅ ENS-based agent discovery & identity
• ✅ Swarm coordination & state tracking
• ✅ KeeperHub integration (MCP server ready)
• ✅ 0G Compute inference support

Developer Experience

• ✅ REST API for all operations
• ✅ WebSocket real-time updates
• ✅ Full TypeScript type safety
• ✅ Comprehensive FEEDBACK.md (Uniswap track)
• ✅ Docker-ready backend
• ✅ Production-grade error handling

🔮 Future Enhancements

Phase 2: Scaling

• Multi-chain support (Arbitrum, Optimism, Base, 0G)
• Cross-chain strategy coordination
• Liquidity aggregation across DEXs

Phase 3: Advanced Features

• Time-based & volume-based triggers
• Advanced order types (limit, stop-loss, DCA)
• Portfolio tracking & rebalancing
• Strategy templates & composability

Phase 4: Social & Governance

• Strategy sharing marketplace
• Agent reputation system
• DAO-governed parameter tuning
• Agent breeding/evolution via iNFT

Phase 5: AI Enhancement

• Fine-tuned models per agent role
• Reinforcement learning from execution results
• Cross-agent knowledge transfer
• Verifiable computation proofs

📊 Hackathon Requirements Checklist

✅ 0G Track - Best Autonomous Agents & Swarms

• Multiple specialized agents (Architect, Executor, Monitor)
• 0G Storage integration for persistent memory
• Swarm coordination via shared state
• Public GitHub with README + setup
• Demo video (to be recorded)
• Live demo link (localhost:3000)
• Architecture diagram (included in README)

✅ 0G Track - Best Agent Framework

• Modular agent architecture
• 0G Storage/Compute SDK integration
• Example agents (Architect, Executor, Monitor)
• Clear framework patterns for extensibility
• Full documentation + TypeScript types

✅ Uniswap Foundation Track

• Advanced Uniswap V3 API integration
• Route optimization & gas estimation
• Real Sepolia testnet testing
• FEEDBACK.md with honest builder feedback
• Working demo link
• GitHub repo with setup instructions

✅ KeeperHub Track

• MCP server integration (ready)
• Reliable execution layer support
• Gas optimization via batch operations
• Retry logic + error handling
• Demo covering execution reliability

✅ ENS Track

• Agent identity via ENS domains
• ENS-based agent discovery
• Text record storage for metadata
• Working demo with resolution
• Functional implementation (no hardcodes)

🚀 Deployment

Local Development

npm install
npm run dev
# Opens http://localhost:3000

Docker (Production)

docker build -t sentinelswap .
docker run -p 3001:3001 sentinelswap

0G Chain Deployment

# Deploy to 0G testnet
npm run deploy:0g-testnet

# Deploy to 0G mainnet
npm run deploy:0g-mainnet

🤝 Contributing

We welcome contributions! Please:

1. Fork the repository
2. Create a feature branch
3. Submit a PR with clear description
4. Add tests for new features

📝 License

MIT License

👥 Team

Built with ❤️ for the Hackathon