Voltz

Voltz is a decentralized, AI-enhanced event networking platform designed to solve the "cold start problem" at technical conferences and hackathons. The platform helps attendees make meaningful connections before, during, and after events through intelligent matchmaking and privacy-preserving credential verification.

The Problem: At large events, attendees struggle to find relevant connections among thousands of participants. Traditional networking is inefficient, and attendees often miss opportunities to connect with people who share their interests, skills, or goals.

The Solution: Voltz combines zero-knowledge proofs, decentralized AI, and blockchain infrastructure to create a trustless, privacy-first networking experience:

• Privacy-Preserving Identity: Users verify credentials (GitHub, Twitter, LinkedIn) using vlayer's zero-knowledge proofs, proving their qualifications without revealing personal data
• AI-Powered Matching: Decentralized AI running on 0G Compute analyzes attendee profiles, verified skills, interests, and event goals to generate ranked matches with explanations
• Verifiable Reputation: On-chain reputation system with soulbound profile NFTs on 0G Chain, tracking event attendance, connections made, workshops attended, and verified credentials
• Decentralized Messaging: End-to-end encrypted XMTP messaging that persists across events, enabling seamless communication
• Scalable Infrastructure: Built on 0G's high-throughput blockchain infrastructure to support events with 10,000+ attendees

How It Works:

1. Users onboard via Privy authentication and create a soulbound profile NFT
2. Credentials are verified through ZK proofs without exposing sensitive information
3. Before events, AI analyzes all attendees and generates personalized match recommendations stored on 0G DA
4. During events, users can message matches via XMTP, check in with QR codes, and track workshop attendance
5. Post-event, reputation scores update on-chain and users receive insights and follow-up recommendations

Technology Stack: 0G Chain for smart contracts, 0G Storage for profile data, 0G Compute for AI inference, vlayer for ZK-TLS proofs, XMTP for messaging, and Privy for seamless Web3 authentication.

Voltz transforms event networking from random chance into intelligent, verified connections while maintaining user privacy and data sovereignty.

Technical Architecture & Implementation

Voltz was built as a full-stack Web3 application with four main components: smart contracts, backend API, frontend, and an XMTP messaging agent. Here's how we pieced everything together:

🏗️ Smart Contracts on 0G Chain

We deployed four core contracts using Solidity 0.8.28 and Hardhat with the Ignition deployment framework:

1. VoltzProfile.sol - Soulbound NFT profiles with metadata pointers to 0G Storage
2. VoltzEvent.sol - Event management with registration tracking and check-in verification
3. VoltzReputation.sol - Point-based reputation across categories (events, connections, workshops, credentials) with tier achievements
4. VoltzAttestation.sol - ZK proof verification for credentials using vlayer's proof system

Key Implementation Details:

• Used Hardhat Ignition modules for deterministic, resumable deployments to 0G Chain (EVM-compatible L1)
• Contracts reference off-chain data on 0G Storage via URI pointers, keeping gas costs low
• AccessControl patterns for role-based permissions (admin, verifier roles)
• Soulbound tokens implemented via blocking transfers in the profile NFT

Partner Integration - 0G Chain: We configured wagmi to support 0G's testnet (chain ID 16600) alongside mainnet and Sepolia, creating a custom chain config with RPC endpoints at https://rpc-testnet.0g.ai. The high-throughput EVM layer allowed us to handle frequent on-chain updates without worrying about congestion.

⚙️ Backend API - Fastify on Steroids

Built with Fastify (faster than Express) as a high-performance REST API with real-time capabilities:

Tech Stack:

• Fastify with WebSocket support for live updates
• Prisma ORM with PostgreSQL for relational data (user sessions, cached profiles, analytics)
• Redis + Bull Queue for background job processing (AI matching, event sync)
• Ethers.js v6 for blockchain interactions with 0G Chain
• Privy Server Auth for JWT validation and user authentication
• Rate limiting via Redis-backed @fastify/rate-limit

Architecture Highlights:

• Modular service layer: contract.service.ts handles all blockchain writes, storage.service.ts manages 0G Storage uploads, auth.service.ts validates Privy tokens
• Bull queues process expensive operations asynchronously (AI matching runs in background when users register for events)
• WebSocket endpoint provides real-time match notifications and event updates
• Structured logging with Pino for production debugging

Partner Integration - 0G Storage: We built a StorageService class that uploads profile and event metadata to 0G's decentralized storage. The service generates content IDs (CIDs), uploads JSON blobs, and returns URIs that get stored on-chain. This keeps sensitive profile data off-chain while maintaining verifiability.

Partner Integration - vouch SDK: Integrated @getvouch/sdk to verify credentials through vlayer's ZK-TLS proofs. When users connect GitHub/Twitter/LinkedIn, vouch generates zero-knowledge proofs that we submit to the VoltzAttestation contract without exposing raw OAuth tokens or personal data.

Hacky Bit #1: Since 0G Storage SDK wasn't fully available, we built a mock implementation for development that simulates CID generation using SHA-256 hashes. The architecture is abstraction-ready for swapping in the real SDK.

🎨 Frontend - Next.js 15 with React 19

Built on the bleeding edge with Next.js 15's App Router and React 19 Server Components:

Tech Stack:

• Next.js 15.1 with App Router for file-based routing
• React 19 (RC) with new hooks and concurrent features
• Privy React SDK for authentication (email, social, wallet)
• wagmi + viem for blockchain interactions
• XMTP React SDK for decentralized messaging UI
• Radix UI primitives for accessible components
• Tailwind CSS v4 (beta) for styling
• Zustand for client-side state management
• TanStack Query for server state and caching
• Framer Motion for animations

Integration Architecture: Providers (providers.tsx): PrivyProvider (auth layer) └─ WagmiProvider (blockchain layer) └─ QueryClientProvider (data layer) └─ App Components

Partner Integration - Privy: Configured Privy with embedded wallets that auto-create for users without wallets. Supports multiple login methods (wallet, email, Google, Twitter) with a custom purple theme. The embedded wallet flow was crucial for onboarding non-crypto users at events.

Partner Integration - XMTP: Used @xmtp/react-sdk v9 to build the messaging interface. XMTP client initializes from the user's Privy wallet signer, enabling end-to-end encrypted conversations that persist across events.

Hacky Bit #2: Next.js 15 + React 19 caused type conflicts with XMTP and Radix UI (expecting React 18). We used @ts-ignore comments strategically and configured package.json with React 18.3 while using Next 15's React 19 runtime - it works because of React's backwards compatibility.

Hacky Bit #3: Built a "demo mode" that disables Privy auth if environment variables aren't set, showing a helpful setup screen instead of crashing. This made development iteration faster.

🤖 XMTP Agent - Autonomous Messaging Bot

Built a standalone agent using XMTP's Agent SDK to provide automated support:

Architecture:

• Event-driven handlers for conversation starts, text messages, reactions
• Middleware pipeline: logging → rate limiting → filtering → auth
• Command routing for /help, /profile, /matches, /events
• Backend API integration for fetching user data and matches

Partner Integration - XMTP: The agent uses @xmtp/agent-sdk with environment-based initialization (wallet key, DB encryption). It runs as a separate process, listening for messages and responding autonomously. This was perfect for sending match notifications pre-event.

Implementation Pattern: agent.on('text', async (ctx) => { // Route to appropriate handler if (text.includes('match')) { await handleMatchNotification(ctx); } });

🧠 AI Integration - 0G Compute (Planned)

Designed for 0G Compute's decentralized AI inference:

Planned Architecture:

1. Background job triggers when event fills with attendees
2. Job sends all profile metadata to 0G Compute endpoint
3. AI model (running on decentralized nodes) performs semantic matching
4. Results include match scores + explanations
5. Proofs stored on 0G DA, match data cached in PostgreSQL
6. XMTP agent notifies users of top matches

Why 0G Compute: Eliminates centralized AI dependencies. Match results are verifiable through proofs on DA layer, preventing manipulation.

Hacky Bit #4: Built the queue infrastructure and API endpoints first, then planned to swap in 0G Compute client. For hackathon demo, we can use a mock AI service that returns random matches with LLM-generated explanations.

🔐 vlayer ZK Proofs Integration

How it Works:

1. User clicks "Verify GitHub" in frontend
2. Frontend calls vouch SDK which initiates ZK-TLS proof generation via vlayer
3. vlayer's prover fetches GitHub API over TLS, generates proof of commit count/stars without revealing auth token
4. Proof hash + claim returned to frontend
5. Backend receives proof, submits to VoltzAttestation contract
6. Contract stores: { subject: userAddress, claim: "100+ Solidity commits", proofHash: 0x... }

Privacy Win: We prove credentials without storing GitHub tokens, usernames, or any PII on-chain or in our database.

📊 Data Flow Architecture

On-Chain (0G Chain):

• Profile NFT ownership
• Event registrations & check-ins
• Reputation points & tiers
• Attestation claims & proof hashes

0G Storage:

• Full profile metadata (skills, bio, interests) - encrypted
• Event metadata (description, schedule, venue)
• Large data blobs (profile images as IPFS CIDs)

0G DA:

• ZK proof payloads from vlayer
• AI computation proofs (verifiable match results)
• Historical event data for analytics

PostgreSQL:

• Cached on-chain data for fast queries
• User sessions & JWT refresh tokens
• Analytics & event insights
• XMTP message metadata (pointers only, not content)

Redis:

• Rate limiting counters
• WebSocket connection state
• Bull job queue data
• Real-time leaderboard cache

🚀 Deployment Strategy

Smart Contracts:

• Hardhat Ignition deployment to 0G testnet
• Deterministic addresses via CREATE2 patterns
• Deployment artifacts in contracts/ignition/deployments/

Backend:

• Dockerized Fastify app with multi-stage builds
• Prisma migrations run on startup
• Environment-based config (dev/staging/prod)

Frontend:

• Next.js SSR deployment (Vercel-ready)
• Environment variables for Privy App ID, backend API URL
• Static optimization for public pages

Agent:

• Long-running Node process with PM2/systemd
• Separate wallet for agent identity
• Encrypted local database for XMTP state

⚡ Notable Technical Decisions

1. Fastify over Express: ~20% faster request handling, built-in schema validation
2. Prisma over raw SQL: Type-safe queries, auto-generated client, easy migrations
3. Bull over custom queues: Battle-tested, Redis-backed, retry logic out-of-box
4. Soulbound NFTs: Prevents profile trading, ensures reputation stays with individual
5. Off-chain metadata: Keeps gas costs low while maintaining verifiability through URIs
6. Modular contract design: Easier to upgrade individual components without redeploying entire system

🛠️ Challenges & Solutions

Challenge 1: 0G Storage SDK not production-ready Solution: Built abstraction layer with mock implementation, ready to swap

Challenge 2: Next.js 15 + React 19 type incompatibilities Solution: Used React 18 types with strategic @ts-ignore flags, works at runtime

Challenge 3: XMTP agent needs separate wallet but should act on behalf of Voltz Solution: Created dedicated agent identity, stores relationship in backend

Challenge 4: Expensive AI matching for 10,000+ attendee events Solution: Background jobs with Bull queue, results cached in Redis/PostgreSQL

Challenge 5: Managing real-time WebSocket state at scale Solution: Redis pub/sub for cross-instance communication, graceful reconnection handling

📦 Partner Technology Benefits

• 0G Chain: High throughput (handles frequent on-chain updates), low fees, EVM compatibility (reuse existing Solidity/Hardhat tooling)
• 0G Storage: Decentralized storage cheaper than on-chain, censorship-resistant profile data
• 0G DA: Verifiable proof storage without bloating blockchain state
• vlayer: Privacy-preserving credentials without trusted oracles or KYC providers
• XMTP: Messaging that persists across events, no central server to shut down
• Privy: Smooth Web3 onboarding, embedded wallets eliminate MetaMask friction
• vouch SDK: Simplified ZK proof generation, works with vlayer out-of-box