System Architecture

 Developer 
 Machine 
 
 
 Next.js 
 (port 
 3000) 
 
 
 Game 
 Daemon 
 
 
 PostgreSQL 
 (local) 
 

 Vercel Edge Network 
 
 Edge Functions (Multi-Region
 
 IAD1 SFO1 CDG1 
 
 

 
 
 
 
 Neon Upstash 
 Postgre Redis 
 
 
 
 Vercel 
 Cron 
 (Game) 
 

 Layer 1: Network (Vercel) 
 - DDoS protection 
 - Edge firewall 


 Layer 2: Application (Next.js) 
 - CORS policies 
 - Rate limiting 
 - Input validation 


 Layer 3: Authentication (Privy) 
 - JWT verification 
 - Wallet signatures 
 - Session management 


 Layer 4: Authorization (Middleware)
 - User/Admin/Agent checks 
 - Resource ownership 
 - Permission validation 


 Layer 5: Database (Prisma RLS) 
 - Row-level security 
 - SQL injection prevention 
 - Prepared statements 

 Neon DB 
 
 
 Primary 
 (Write) 
 Replication
 
 Read 
 Replica 1
 
 
 Read 
 Replica 2
 

// Pattern used in all API routes
 
import { withErrorHandling, successResponse } from '@/lib/errors/error-handler';
import { requireAuth } from '@/lib/api/auth-middleware';
import { asUser } from '@/lib/db/context';
 
export const GET = withErrorHandling(async (request) => {
 // 1. Authenticate
 const user = await requireAuth(request);
 
 // 2. Get data with RLS
 const data = await asUser(user, async (db) => {
 return await db.model.findMany({
 where: { userId: user.userId }
 });
 });
 
 // 3. Return response
 return successResponse({ data });
});

// Pattern for real-time features
 
// Server: Broadcast update
import { getEventBroadcaster } from '@/lib/sse/event-broadcaster';
 
const broadcaster = getEventBroadcaster();
broadcaster.broadcast('feed', {
 type: 'feed_update',
 data: newPost
});
 
// Client: Subscribe
const eventSource = new EventSource('/api/sse/events?channels=feed');
eventSource.addEventListener('feed_update', (event) => {
 const post = JSON.parse(event.data);
 updateFeed(post);
});

// A2A protocol pattern
 
// 1. Connect
const client = new A2AClient({ serverUrl, wallet });
await client.connect();
 
// 2. Discover agents
const agents = await client.discover({ capabilities: ['trading'] });
 
// 3. Request data
const analysis = await client.request('a2a.requestAnalysis', {
 marketId: 'market-123',
 fromAgent: agents[0].id
});
 
// 4. Act on data
if (analysis.signal === 'BUY' && analysis.confidence > 0.7) {
 await trade(market, analysis);
}

-- Heavy read paths
CREATE INDEX idx_posts_timestamp ON "Post"("timestamp" DESC);
CREATE INDEX idx_posts_author ON "Post"("authorId", "timestamp" DESC);
 
-- Common queries
CREATE INDEX idx_positions_user ON "Position"("userId", "marketId");
CREATE INDEX idx_markets_resolved ON "Market"("resolved", "endDate");
 
-- Leaderboard
CREATE INDEX idx_users_reputation ON "User"("reputationPoints" DESC);

Request
 
 → L1: React Query (client-side, 30s)
 → If miss...
 
 → L2: Redis (server-side, 60s)
 → If miss...
 
 → L3: Database (source of truth)
 → Update L2, L1

// Pattern: entity:id:property
'markets:active'
'user:123:profile'
'pool:456:positions'
'leaderboard:top:100'

// On market update
await redis.del('markets:active');
await redis.del(`market:${marketId}:prices`);
 
// Broadcast to clients
broadcaster.broadcast('markets', {
 type: 'market_update',
 marketId
});

// Instance 1 publishes
await redis.publish('babylon:feed_update', JSON.stringify(post));
 
// Instance 2 receives
redis.subscribe('babylon:feed_update', (message) => {
 const post = JSON.parse(message);
 broadcaster.broadcastToLocal('feed', post);
});
 
// All connected clients receive update

// N+1 Query Problem
const posts = await prisma.post.findMany();
for (const post of posts) {
 const author = await prisma.user.findUnique({
 where: { id: post.authorId }
 });
}
 
// Solution: Include relation
const posts = await prisma.post.findMany({
 include: {
 author: {
 select: {
 username: true,
 displayName: true,
 profileImageUrl: true
 }
 }
 }
});

// next.config.mjs
export default {
 experimental: {
 optimizePackageImports: ['lucide-react']
 },
 compiler: {
 removeConsole: process.env.NODE_ENV === 'production'
 }
}

Application
 → Console (development)
 → File logs (production)
 → Vercel Logs (production)
 → Sentry (errors only)