Universal Intents Analytics Platform

Open-source blockchain analytics platform for indexing, analyzing, and visualizing ERC-7683/OIF (Open Intents Framework) intent activities across Ethereum and EVM-compatible chains.

🎯 Overview

The Universal Intents Analytics Platform is a comprehensive monitoring solution designed for developers, researchers, and ecosystem builders who need visibility into cross-chain intent transactions, execution patterns, and protocol performance.

Key Features

📊 Real-time Dashboard - Live metrics showing total intents, success rates, and protocol analytics
🔍 Advanced Explorer - Filterable intent table with chain and status filtering
📈 Analytics & Visualizations - Interactive charts for protocol rankings, chain distribution, and performance trends
🔌 REST API - Public endpoints for programmatic access to intent data
📤 Data Export - CSV and JSON export functionality for analysis
⛓️ Multi-chain Support - Ethereum, Optimism, Arbitrum, Base, and more

🏗️ How It Works

System Architecture

graph TB
    subgraph "Blockchain Layer"
        ETH["Ethereum<br/>Chain ID: 1"]
        ARB["Arbitrum<br/>Chain ID: 42161"]
        BASE["Base<br/>Chain ID: 8453"]
        OPT["Optimism<br/>Chain ID: 10"]
        SEP["Sepolia<br/>Chain ID: 11155111"]
    end

    subgraph "ERC-7683 Contracts"
        ETH_CONTRACT["AcrossOriginSettler<br/>0xB0B07055..."]
        ARB_CONTRACT["AcrossOriginSettler<br/>0xB0B07055..."]
        BASE_CONTRACT["AcrossOriginSettler<br/>0x4afb570A..."]
        SEP_CONTRACT["Across Testnet<br/>0x43f133FE..."]
    end

    subgraph "Indexer Service"
        WS["WebSocket<br/>Connections"]
        PARSER["Event Parser<br/>& Validator"]
        STORAGE["Storage<br/>Writer"]
    end

    subgraph "Database Layer"
        PG[("PostgreSQL<br/>Database")]
        INTENTS_TABLE["intents table<br/>- id, chain, status<br/>- solver, amount, protocol<br/>- events (JSONB)<br/>- timestamps, tx_hash"]
    end

    subgraph "API Layer"
        EXPRESS["Express.js<br/>Server"]
        DRIZZLE["Drizzle ORM"]
        ROUTES["/api/intents<br/>/api/analytics<br/>/api/export"]
    end

    subgraph "Frontend Layer"
        REACT["React + Vite"]
        DASHBOARD["Dashboard<br/>Metrics & Charts"]
        EXPLORER["Explorer<br/>Intent Table"]
        ANALYTICS["Analytics<br/>Visualizations"]
        QUERY["TanStack Query<br/>State Management"]
    end

    %% Connections
    ETH --> ETH_CONTRACT
    ARB --> ARB_CONTRACT
    BASE --> BASE_CONTRACT
    SEP --> SEP_CONTRACT

    ETH_CONTRACT -->|"CrossChainOrderOpened<br/>CrossChainOrderFilled<br/>CrossChainOrderCancelled"| WS
    ARB_CONTRACT -->|"Events"| WS
    BASE_CONTRACT -->|"Events"| WS
    SEP_CONTRACT -->|"Events"| WS

    WS --> PARSER
    PARSER --> STORAGE
    STORAGE --> PG
    PG --> INTENTS_TABLE

    INTENTS_TABLE --> DRIZZLE
    DRIZZLE --> EXPRESS
    EXPRESS --> ROUTES

    ROUTES --> QUERY
    QUERY --> REACT
    REACT --> DASHBOARD
    REACT --> EXPLORER
    REACT --> ANALYTICS

    %% Styling
    classDef blockchain fill:#e1f5fe
    classDef contract fill:#f3e5f5
    classDef indexer fill:#e8f5e8
    classDef database fill:#fff3e0
    classDef api fill:#fce4ec
    classDef frontend fill:#f1f8e9

    class ETH,ARB,BASE,OPT,SEP blockchain
    class ETH_CONTRACT,ARB_CONTRACT,BASE_CONTRACT,SEP_CONTRACT contract
    class WS,PARSER,STORAGE indexer
    class PG,INTENTS_TABLE database
    class EXPRESS,DRIZZLE,ROUTES api
    class REACT,DASHBOARD,EXPLORER,ANALYTICS,QUERY frontend

📋 ERC-7683 Event Schema

Event Definitions

The platform monitors three core ERC-7683 events emitted by Across Protocol contracts:

1. CrossChainOrderOpened Event

event CrossChainOrderOpened(
    bytes32 indexed orderId,
    address indexed user,
    address indexed solver,
    uint256 amount
);

Event Data Structure:

interface CrossChainOrderOpenedEvent {
  orderId: string;        // Unique intent identifier (bytes32)
  user: string;          // User address who created the intent
  solver: string;        // Solver address responsible for execution
  amount: string;        // Amount in wei (BigInt as string)
  blockNumber: number;   // Block number when event was emitted
  transactionHash: string; // Transaction hash
  timestamp: string;      // ISO timestamp
}

Database Storage:

Status: "pending"
Type: "Cross-Chain Swap"
Protocol: "ERC-7683" or "Across Protocol"

2. CrossChainOrderFilled Event

event CrossChainOrderFilled(
    bytes32 indexed orderId,
    address indexed solver,
    uint256 fillAmount
);

Event Data Structure:

interface CrossChainOrderFilledEvent {
  orderId: string;        // Intent identifier to update
  solver: string;        // Solver who executed the intent
  fillAmount: string;    // Actual amount filled (BigInt as string)
  blockNumber: number;   // Block number when event was emitted
  transactionHash: string; // Transaction hash
  timestamp: string;      // ISO timestamp
}

Database Update:

Status: "success"
Amount: Updated with fillAmount
Events: Append new event to events array

3. CrossChainOrderCancelled Event

event CrossChainOrderCancelled(
    bytes32 indexed orderId,
    address indexed user
);

Event Data Structure:

interface CrossChainOrderCancelledEvent {
  orderId: string;        // Intent identifier to update
  user: string;          // User who cancelled the intent
  blockNumber: number;   // Block number when event was emitted
  transactionHash: string; // Transaction hash
  timestamp: string;      // ISO timestamp
}

Database Update:

Status: "failed"
Events: Append cancellation event to events array

Event Processing Flow

sequenceDiagram
    participant User as User
    participant Contract as ERC-7683 Contract
    participant Indexer as Indexer Service
    participant DB as Database
    participant API as REST API
    participant Frontend as Frontend

    User->>Contract: Create Intent
    Contract->>Contract: Emit CrossChainOrderOpened
    Contract->>Indexer: Event Log
    Indexer->>Indexer: Parse Event Data
    Indexer->>DB: Insert Intent (status: pending)
    DB->>API: Data Available
    API->>Frontend: Real-time Update

    Note over Contract,Indexer: Intent Execution Phase

    Contract->>Contract: Emit CrossChainOrderFilled
    Contract->>Indexer: Event Log
    Indexer->>Indexer: Parse Event Data
    Indexer->>DB: Update Intent (status: success)
    DB->>API: Data Updated
    API->>Frontend: Status Change

    Note over Contract,Indexer: Alternative: Intent Cancellation

    Contract->>Contract: Emit CrossChainOrderCancelled
    Contract->>Indexer: Event Log
    Indexer->>Indexer: Parse Event Data
    Indexer->>DB: Update Intent (status: failed)
    DB->>API: Data Updated
    API->>Frontend: Status Change

Real-time Event Monitoring

WebSocket Connection Setup:

// server/indexer.ts
const CHAIN_CONFIGS = [
  {
    name: "Arbitrum",
    chainId: 42161,
    rpcUrl: "wss://arbitrum-one-rpc.publicnode.com",
    contractAddress: "0xB0B07055F214Ce59ccB968663d3435B9f3294998",
  },
  {
    name: "Base",
    chainId: 8453,
    rpcUrl: "wss://base.publicnode.com", 
    contractAddress: "0x4afb570AC68BfFc26Bb02FdA3D801728B0f93C9E",
  }
];

// Event listener setup
contract.on("CrossChainOrderOpened", async (orderId, user, solver, amount, event) => {
  // Process and store intent
});

contract.on("CrossChainOrderFilled", async (orderId, solver, fillAmount, event) => {
  // Update intent status to success
});

contract.on("CrossChainOrderCancelled", async (orderId, user, event) => {
  // Update intent status to failed
});

Event History Tracking

Each intent maintains a complete event history in the events JSONB field:

{
  "events": [
    {
      "type": "OrderOpened",
      "timestamp": "2025-01-17T10:30:00Z",
      "blockNumber": 18500000,
      "transactionHash": "0xabc123..."
    },
    {
      "type": "OrderFilled", 
      "timestamp": "2025-01-17T10:35:00Z",
      "blockNumber": 18500015,
      "transactionHash": "0xdef456..."
    }
  ]
}

This provides complete audit trail and enables advanced analytics on intent lifecycle patterns.

1. Blockchain Event Emission

Smart Contract (ERC-7683) → Emits Event → Event Log on Blockchain

When users create, fill, or cancel cross-chain orders, the ERC-7683 contract emits events:

CrossChainOrderOpened - New intent created
CrossChainOrderFilled - Intent successfully executed
CrossChainOrderCancelled - Intent cancelled

2. Event Indexing

RPC Node → WebSocket Connection → Indexer Listener → Parse Event Data

The indexer service:

Maintains WebSocket connections to multiple chains (Ethereum, Optimism, etc.)
Listens for ERC-7683 events in real-time
Parses event parameters (orderId, user, solver, amount, etc.)
Validates and normalizes data

3. Data Storage

Parsed Event → Database Insert/Update → PostgreSQL

Processed intent data is stored with:

Transaction metadata (hash, block number, timestamp)
Intent details (chain, protocol, status, amounts)
Participant addresses (user, solver, destination)
Event history (JSONB for full audit trail)

4. API Layer

Database → Drizzle ORM → REST Endpoints → JSON Response

Express.js API provides:

Intent queries with filtering (status, chain, pagination)
Aggregated analytics (success rates, protocol rankings)
Export functionality (CSV/JSON downloads)

5. Frontend Display

API Response → TanStack Query → React State → UI Components

React application:

Fetches data via API endpoints
Caches with TanStack Query for performance
Renders interactive dashboards and charts
Auto-refreshes for near real-time updates

Use Case Scenarios

Scenario 1: Developer Monitoring Intent Activity

1. Developer opens Dashboard
2. Views total intents across all chains (e.g., 150 intents)
3. Checks success rate (22%) and identifies performance issues
4. Navigates to Explorer to filter failed intents
5. Exports failed intents as CSV for analysis
6. Identifies problematic solver or chain

Scenario 2: Researcher Analyzing Protocol Performance

1. Researcher visits Analytics page
2. Reviews protocol rankings (UniswapX, 1inch Fusion, etc.)
3. Checks chain distribution pie chart
4. Filters intents by specific protocol via API
5. Downloads JSON data for academic research
6. Publishes findings on cross-chain intent adoption

Scenario 3: Real-time Intent Tracking

1. New intent created on Ethereum (CrossChainOrderOpened event)
2. Indexer detects event within ~15 seconds
3. Data parsed and stored in database
4. Dashboard auto-refreshes (React Query polling)
5. New intent appears in Explorer table
6. Metrics update (total intents +1)

🚀 Quick Start

Prerequisites

Node.js 18+
PostgreSQL database
npm or yarn

Installation

Clone the repository:

git clone https://github.com/Modolo-oss/Universal-Intents-Analytics.git
cd Universal-Intents-Analytics

Install dependencies:

npm install

Set up environment variables:

# Database connection
DATABASE_URL=your_postgresql_connection_string

# Session secret
SESSION_SECRET=your_session_secret

Start the application:

npm run dev

Open your browser at http://localhost:5000

📊 Current Data Source

✅ LIVE BLOCKCHAIN DATA: The platform is now indexing real ERC-7683 events from production contracts!

✅ Live Across Protocol contracts on Arbitrum and Base mainnet
✅ Real-time event listening via WebSocket connections
✅ Production-ready infrastructure with proper error handling
✅ CrossChainOrderOpened, CrossChainOrderFilled, CrossChainOrderCancelled events indexed

Current Live Contracts

The platform is actively monitoring these AcrossOriginSettler contracts:

Chain	Contract Address	Status
Arbitrum	`0xB0B07055F214Ce59ccB968663d3435B9f3294998`	✅ Live
Base	`0x4afb570AC68BfFc26Bb02FdA3D801728B0f93C9E`	✅ Live
Sepolia	`0x43f133FE6fDFA17c417695c476447dc2a449Ba5B`	✅ Testnet
Sepolia	`0x5b3acAADE6c53eFCD113dCa116F71312f2df666d`	✅ Testnet

ERC-7683 Deployment Status

Live Contracts (Currently Monitored):

✅ Arbitrum Mainnet - 0xB0B07055F214Ce59ccB968663d3435B9f3294998 (AcrossOriginSettler)
✅ Base Mainnet - 0x4afb570AC68BfFc26Bb02FdA3D801728B0f93C9E (AcrossOriginSettler)
✅ Sepolia Testnet - 0x43f133FE6fDFA17c417695c476447dc2a449Ba5B (Across Testnet Spoke1)
✅ Sepolia Testnet - 0x5b3acAADE6c53eFCD113dCa116F71312f2df666d (Across Testnet Spoke2)

Not Yet Publicly Available:

⏳ Optimism Mainnet - Superchain integration in progress
⏳ Ethereum Mainnet - Still L2-focused deployment
⏳ Other Chains (Polygon, Avalanche, etc.) - No public ERC-7683 deployments found

Implementation Notes:

Across Protocol is the primary ERC-7683 implementer with live contracts
UniswapX uses ERC-7683 backend but hasn't published specific contract addresses
Platform is ready to add new contracts as they become available

What This Means

Real intent transactions are being indexed as they happen
Live success/failure rates reflect actual Across Protocol performance
Production data powers all analytics and dashboards
No more sample data - everything is authentic blockchain activity

🎉 Production Status: LIVE & OPERATIONAL

The platform is already running on live blockchain data! No migration needed.

Current Live Infrastructure

✅ WebSocket RPC Connections - Reliable real-time event listening ✅ Across Protocol Integration - Monitoring live AcrossOriginSettler contracts
✅ Multi-chain Support - Arbitrum and Base mainnet + Sepolia testnet ✅ Event Processing - CrossChainOrderOpened, CrossChainOrderFilled, CrossChainOrderCancelled ✅ Error Handling - Robust connection management and failure recovery ✅ Database Storage - PostgreSQL with optimized indexes for performance

What's Happening Right Now

Live event monitoring across multiple chains
Real-time intent indexing as transactions occur
Automatic status updates when intents are filled or cancelled
Production analytics based on actual Across Protocol activity
WebSocket reliability with automatic reconnection handling

Technical Architecture

// Live contract configurations (server/indexer.ts)
const CHAIN_CONFIGS = [
  {
    name: "Arbitrum",
    chainId: 42161,
    rpcUrl: "wss://arbitrum-one-rpc.publicnode.com",
    contractAddress: "0xB0B07055F214Ce59ccB968663d3435B9f3294998", // Across AcrossOriginSettler
  },
  {
    name: "Base", 
    chainId: 8453,
    rpcUrl: "wss://base.publicnode.com",
    contractAddress: "0x4afb570AC68BfFc26Bb02FdA3D801728B0f93C9E", // Across AcrossOriginSettler
  }
];

🏗️ Tech Stack

Frontend

React with TypeScript
Vite - Build tool and dev server
Shadcn/ui - UI component library
TanStack Query - Server state management
Recharts - Data visualization
Wouter - Client-side routing

Backend

Node.js with Express.js
PostgreSQL - Database (Neon serverless)
Drizzle ORM - Type-safe database operations
ethers.js - Blockchain interaction

Blockchain Indexing

ERC-7683 (OIF) event monitoring
Multi-chain support - Arbitrum, Base mainnet + Sepolia testnet
WebSocket RPC connections for real-time events

📁 Project Structure

IntentInsights/
├── client/                      # Frontend React application
│   ├── src/
│   │   ├── pages/              # Page components
│   │   │   ├── dashboard.tsx   # Main dashboard with metrics
│   │   │   ├── explorer.tsx    # Intent explorer with filtering
│   │   │   ├── analytics.tsx   # Advanced analytics charts
│   │   │   ├── api-docs.tsx    # API documentation
│   │   │   ├── settings.tsx    # User settings
│   │   │   ├── landing.tsx     # Landing page
│   │   │   └── not-found.tsx   # 404 error page
│   │   ├── components/         # Reusable UI components
│   │   │   ├── ui/             # Shadcn components (button, card, etc.)
│   │   │   ├── examples/       # Example components
│   │   │   ├── metric-card.tsx # Dashboard metric cards
│   │   │   ├── app-sidebar.tsx # Navigation sidebar
│   │   │   ├── chain-distribution.tsx # Chain distribution chart
│   │   │   ├── intent-table.tsx # Intent data table
│   │   │   ├── protocol-rankings.tsx # Protocol rankings
│   │   │   ├── search-bar.tsx  # Search functionality
│   │   │   ├── status-badge.tsx # Status indicators
│   │   │   ├── time-range-selector.tsx # Time filtering
│   │   │   ├── theme-provider.tsx # Theme management
│   │   │   ├── theme-toggle.tsx # Dark/light mode toggle
│   │   │   └── volume-chart.tsx # Volume visualization
│   │   ├── lib/                # Utilities and configurations
│   │   │   ├── queryClient.ts  # TanStack Query setup
│   │   │   └── utils.ts        # Helper functions
│   │   ├── hooks/              # Custom React hooks
│   │   │   ├── use-mobile.tsx  # Mobile detection hook
│   │   │   └── use-toast.ts    # Toast notifications
│   │   ├── App.tsx             # Root component with routing
│   │   ├── main.tsx            # Application entry point
│   │   └── index.css           # Global styles
│   └── index.html              # Entry HTML
│
├── server/                     # Backend Express server
│   ├── index.ts               # Server entry point
│   ├── routes.ts              # REST API route definitions
│   ├── storage.ts             # Database operations & queries
│   ├── indexer.ts             # Blockchain event indexer
│   ├── db.ts                  # Database connection setup
│   └── vite.ts                # Vite middleware integration
│
├── shared/                     # Shared TypeScript types
│   └── schema.ts              # Database schema & Zod validation
│
├── attached_assets/           # Project assets
│   └── Logo.png               # Project logo
│
├── components.json            # Shadcn/ui configuration
├── design_guidelines.md       # UI/UX design system
├── drizzle.config.ts          # Drizzle ORM configuration
├── package.json               # Dependencies & scripts
├── package-lock.json          # Locked dependency versions
├── postcss.config.js          # PostCSS configuration
├── tailwind.config.ts         # Tailwind CSS configuration
├── tsconfig.json              # TypeScript configuration
└── vite.config.ts             # Vite build configuration

Key Files Explained

Frontend

client/src/pages/dashboard.tsx - Main dashboard displaying metrics, charts, and protocol rankings
client/src/pages/explorer.tsx - Searchable table with advanced filtering (chain, status, pagination)
client/src/pages/analytics.tsx - Advanced analytics with detailed charts and visualizations
client/src/pages/landing.tsx - Landing page with project overview
client/src/lib/queryClient.ts - Configured TanStack Query client with default fetcher
client/src/components/intent-table.tsx - Reusable intent data table component
client/src/components/metric-card.tsx - Dashboard metric display cards

Backend

server/indexer.ts - Core blockchain indexer that listens to ERC-7683 events from Across Protocol
server/storage.ts - Database abstraction layer with all CRUD operations and analytics queries
server/routes.ts - Express routes for intents, analytics, and export endpoints
server/db.ts - Database connection setup with Drizzle ORM

Configuration

components.json - Shadcn/ui component configuration
drizzle.config.ts - Database schema and migration configuration
vite.config.ts - Build tool configuration for development and production

Shared

shared/schema.ts - Single source of truth for data types, used by both frontend and backend

🗄️ Database Schema

Intents Table

The core intents table stores all intent transaction data:

CREATE TABLE intents (
  id VARCHAR PRIMARY KEY,              -- Intent/Order ID (0x...)
  type VARCHAR NOT NULL,               -- "Cross-Chain Swap", "Bridge", etc.
  chain VARCHAR NOT NULL,              -- "Ethereum", "Optimism", etc.
  chain_id INTEGER NOT NULL,           -- 1, 10, 42161, etc.
  status VARCHAR NOT NULL,             -- "success", "failed", "pending", "executing"
  solver VARCHAR,                      -- Solver address (0x...)
  from_address VARCHAR,                -- User address
  to_address VARCHAR,                  -- Destination address
  amount VARCHAR,                      -- Amount in wei (BigInt as string)
  protocol VARCHAR,                    -- "UniswapX", "1inch Fusion", etc.
  parameters JSONB,                    -- Additional intent parameters
  events JSONB,                        -- Event history array
  block_number INTEGER,                -- Block number
  transaction_hash VARCHAR,            -- Transaction hash
  timestamp TIMESTAMP DEFAULT NOW()    -- Record creation time
);

-- Indexes for performance
CREATE INDEX idx_intents_status ON intents(status);
CREATE INDEX idx_intents_chain ON intents(chain);
CREATE INDEX idx_intents_solver ON intents(solver);
CREATE INDEX idx_intents_timestamp ON intents(timestamp);

Sample Intent Record

{
  "id": "0xd44098c2dab330000000000000000000000000000000000000000000000000",
  "type": "Cross-Chain Swap",
  "chain": "Ethereum",
  "chainId": 1,
  "status": "success",
  "solver": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0",
  "fromAddress": "0x1234567890123456789012345678901234567890",
  "toAddress": "0x0987654321098765432109876543210987654321",
  "amount": "1000000000000000000",
  "protocol": "UniswapX",
  "parameters": {
    "inputToken": "0x...",
    "outputToken": "0x...",
    "deadline": 1234567890
  },
  "events": [
    {
      "type": "OrderOpened",
      "timestamp": "2025-10-12T21:30:00Z",
      "blockNumber": 18500000,
      "transactionHash": "0xabc..."
    }
  ],
  "blockNumber": 18500000,
  "transactionHash": "0xabcdef1234567890...",
  "timestamp": "2025-10-12T21:30:00Z"
}

🔌 API Endpoints

Intent Data

GET /api/intents - List intents with filtering (status, chain, pagination)
GET /api/intents/:id - Get single intent details

Analytics

GET /api/analytics/summary - Overall metrics (total, success rate, etc.)
GET /api/analytics/chain-distribution - Intent count per chain
GET /api/analytics/protocol-rankings - Intent count per protocol

Export

GET /api/export?format=csv - Export intents as CSV
GET /api/export?format=json - Export intents as JSON

🧪 Testing

The platform is production-ready and can be tested by running the development server:

# Start the development server
npm run dev

# The platform includes:
# - Live blockchain event monitoring
# - Real-time dashboard updates
# - Intent explorer with filtering
# - Analytics and data visualization
# - REST API endpoints for data access

🎯 Gitcoin GG24 Submission

This platform was built for the Gitcoin Grants Round 24 (GG24).

Current Status: ✅ PRODUCTION LIVE - Fully Operational Platform

✅ Live blockchain indexing - Real ERC-7683 events from Across Protocol
✅ Production-ready infrastructure - WebSocket connections, error handling, database optimization
✅ Complete feature set - Dashboard, explorer, analytics, API endpoints, data export
✅ Multi-chain support - Arbitrum, Base mainnet + Sepolia testnet
✅ Real-time monitoring - Intent transactions indexed as they happen

Key Achievements

🎉 SUCCESSFULLY MIGRATED TO LIVE DATA - No more sample data, everything is real! 🔧 ALL CRITICAL ISSUES RESOLVED - Proper error handling, connection management, status updates 📊 PRODUCTION ANALYTICS - Live success rates, protocol rankings, chain distribution ⚡ REAL-TIME PERFORMANCE - WebSocket connections for efficient event listening

Critical Issues Resolved

During development, several critical issues were identified and resolved:

✅ Intent Status Updates - Added updateIntentStatus() method for tracking intent lifecycle
✅ Error Handling - Fixed initialize() to properly throw errors when connections fail
✅ Production Readiness - Removed sample data generation, enabled live blockchain indexing
✅ Connection Management - Implemented robust WebSocket connection handling with proper cleanup

These fixes ensure the platform operates reliably in production with real blockchain data.

🛣️ Roadmap

✅ Completed (Production Ready)

Connect to live ERC-7683 contracts on mainnet - Arbitrum & Base live
WebSocket support for real-time updates - Implemented and operational
Production error handling - Robust connection management
Live intent status tracking - Real-time updates for fills/cancels

🚀 Future Enhancements

Additional chain support - Polygon, Avalanche, Optimism mainnet
User authentication - Saved filters and personalized dashboards
Historical data backfilling - Complete intent history from contract deployment
Advanced analytics - MEV detection, solver performance analysis
Notification system - Real-time alerts for intent monitoring
API rate limiting - Production-grade API protection
Data retention policies - Automated cleanup and archiving

📝 License

MIT License - This project is open source and available under the MIT License.

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

📧 Contact

For questions or feedback, please open an issue on GitHub.

Built for the ERC-7683/OIF ecosystem | Gitcoin GG24 Submission

Name		Name	Last commit message	Last commit date
Latest commit History 39 Commits
attached_assets		attached_assets
client		client
server		server
shared		shared
.gitignore		.gitignore
GITCOIN_GG24_PROPOSAL.md		GITCOIN_GG24_PROPOSAL.md
GIVETH_PROPOSAL_SUMMARY.md		GIVETH_PROPOSAL_SUMMARY.md
LICENSE		LICENSE
README.md		README.md
VISUAL_IDEAS.md		VISUAL_IDEAS.md
components.json		components.json
design_guidelines.md		design_guidelines.md
drizzle.config.ts		drizzle.config.ts
package-lock.json		package-lock.json
package.json		package.json
postcss.config.js		postcss.config.js
railway.env.example		railway.env.example
railway.json		railway.json
tailwind.config.ts		tailwind.config.ts
tsconfig.json		tsconfig.json
vite.config.ts		vite.config.ts

License

Modolo-oss/Universal-Intents-Analytics

Folders and files

Latest commit

History

Repository files navigation

Universal Intents Analytics Platform

🎯 Overview

Key Features

🏗️ How It Works

System Architecture

📋 ERC-7683 Event Schema

Event Definitions

1. CrossChainOrderOpened Event

2. CrossChainOrderFilled Event

3. CrossChainOrderCancelled Event

Event Processing Flow

Real-time Event Monitoring

Event History Tracking

1. Blockchain Event Emission

2. Event Indexing

3. Data Storage

4. API Layer

5. Frontend Display

Use Case Scenarios

Scenario 1: Developer Monitoring Intent Activity

Scenario 2: Researcher Analyzing Protocol Performance

Scenario 3: Real-time Intent Tracking

🚀 Quick Start

Prerequisites

Installation

📊 Current Data Source

Current Live Contracts

ERC-7683 Deployment Status

What This Means

🎉 Production Status: LIVE & OPERATIONAL

Current Live Infrastructure

What's Happening Right Now

Technical Architecture

🏗️ Tech Stack

Frontend

Backend

Blockchain Indexing

📁 Project Structure

Key Files Explained

Frontend

Backend

Configuration

Shared

🗄️ Database Schema

Intents Table

Sample Intent Record

🔌 API Endpoints

Intent Data

Analytics

Export

🧪 Testing

🎯 Gitcoin GG24 Submission

Key Achievements

Critical Issues Resolved

🛣️ Roadmap

✅ Completed (Production Ready)

🚀 Future Enhancements

📝 License

🤝 Contributing

📧 Contact

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Contributors 2

Uh oh!

Languages

Packages