SolSignal

An AI-powered on-chain intelligence platform that gives you the same edge the whales have.

Comment

Inspiration

Every day, regular people lose money on Solana to rug pulls, pump-and-dump schemes, and coordinated whale manipulation. The blockchain is public, transparent, and full of signals, but the average user has no way to read them. Meanwhile, insiders and sophisticated traders exploit information asymmetry to profit at everyone else's expense.

I asked myself what if I could turn raw on-chain data into actionable intelligence that anyone can understand?

The inspiration for SolSignal came from watching communities get wrecked by tokens where the warning signs were technically visible on-chain the entire time, 90% supply concentration in 3 wallets, liquidity unlocks scheduled hours away, suspicious early wallet clusters, but nobody had the tools to see it. I wanted to build a platform that would have saved them.

I also drew inspiration from Bloomberg Terminal's approach to financial intelligence: dense, real-time, data-rich, while also wanting to make it accessible, visual, and powered by AI so you don't need to be a blockchain analyst to benefit from it.

What it does

SolSignal is an AI-powered on-chain intelligence platform for the Solana blockchain. It provides four core capabilities:

  1. Wallet Credit Scoring
    Paste any Solana wallet address and SolSignal generates a behavioral reputation score (0–1000) based on historical profitability, rug pull participation, token holding patterns, transaction frequency, and whale status. It is like a credit score for crypto wallets, allowing you to instantly know if you're dealing with a seasoned trader or a serial rug deployer.

  2. Rug Pull Prediction
    Enter a token mint address and SolSignal analyzes it for rug pull risk using both heuristic analysis and Google Gemini AI. It examines developer wallet concentration, liquidity pool ownership, suspicious transfer patterns, insider trading clusters, and token distribution anomalies to produce a risk level (LOW / MEDIUM / HIGH / CRITICAL) with a confidence score and detailed breakdown.

  3. Whale Activity Tracking
    SolSignal detects coordinated wallet accumulation patterns. When multiple high-value wallets start buying the same token within a short window, the system generates a whale signal with a predicted price movement and confidence level. This allows users to see what the smart money is doing before the price moves.

  4. Immersive 3D Dashboard
    The entire experience runs on top of a real-time Three.js blockchain visualization. An infinite chain of 3D blocks connected by animated chain links, with sparks traveling along completed chains and ambient particles for depth. The scene's color palette smoothly shifts based on what you're looking at: purple for neutral browsing, green when a wallet checks out clean, red when analyzing a potential rug pull. Every panel uses glassmorphism styling so the 3D scene is always visible beneath the UI.

How it was built

Backend — C# / .NET 10 Minimal APIs
The backend is a lightweight .NET 10 API server using the Minimal API pattern. It communicates directly with the Solana blockchain via raw HTTP RPC calls (getSignaturesForAddress, getTransaction, getTokenLargestAccounts, getTokenSupply, getProgramAccounts) for maximum flexibility. Transaction data is parsed, normalized, and stored in MongoDB Atlas for caching and fast re-analysis.

AI Layer — Google Gemini API
Google Gemini is used for wallet behavior classification, rug pull prediction, and whale signal analysis. Each service sends structured prompts with on-chain data and expects JSON responses that get parsed into typed models. A circuit breaker with retry-and-backoff is built into the Gemini service to handle rate limiting gracefully. When the API quota is exhausted, the system automatically falls back to heuristic-only analysis with no stack traces or performance degradation.

Database — MongoDB Atlas
Six collections (wallets, wallet_scores, tokens, transactions, signals, rugpull_analysis) store all analyzed data. Indexes are created eagerly on startup. The caching layer prevents redundant Gemini API calls. Once a wallet or token is analyzed, subsequent requests return cached results instantly.

Frontend — SvelteKit + TypeScript + TailwindCSS
The frontend is a SvelteKit application using Svelte 5 runes ($state, $derived, $effect, $props) throughout. Chart.js handles transaction activity charts, and Cytoscape.js renders interactive wallet network graphs.

3D Visualization — Three.js
The blockchain background is a custom Three.js scene rendered on a full-screen canvas behind all UI content. It features:

  • An infinite conveyor of 3D blocks with unique hex hash labels, physically-based materials (metalness, clearcoat), and wireframe edge overlays
  • Torus-link chains connecting each block with progressive reveal animations
  • Spark particles that travel along completed chains representing data transfer
  • 400 ambient particles with additive blending for depth
  • A mood-reactive lighting system driven by a Svelte store — pages set the mood (neutral/positive/caution/danger/critical/info) and five colored lights smoothly transition using frame-rate-independent exponential interpolation with a 1.2-second half-life
  • Mouse-follow camera parallax and orbiting light positions

Glassmorphism UI
All panels, cards, inputs, badges, and alerts use frosted-glass CSS with backdrop-filter: blur(), semi-transparent backgrounds, and subtle borders — letting the 3D scene show through every surface.

Agentic Development — Google Antigravity

SolSignal was built using Google Antigravity as the primary development environment. Antigravity's agentic AI capabilities accelerated every phase of the project, from scaffolding the .NET backend and wiring up MongoDB repositories, to generating Svelte 5 components with proper rune syntax, to writing the entire Three.js blockchain visualization.

Rather than context-switching between documentation, terminals, and editors, development happened conversationally with the agent. Requirements could be described, generated code reviewed, edge cases iterated on, and bugs debugged in real time.

This workflow was especially valuable for complex cross-cutting work like the Gemini circuit breaker, which required coordinating exception types, retry logic, and logging across multiple service files, and the mood-reactive lighting system, which spanned a Svelte store, a Three.js render loop, and CSS glass styling across dozens of components.

Antigravity made it possible to operate at the speed of a much larger engineering team, delivering a full-stack application with AI integration, real-time blockchain data, 3D visualization, and a glassmorphism interface in a fraction of the time required by a traditional development workflow.

Challenges I ran into

Solana RPC Rate Limiting
The public Solana mainnet RPC has aggressive rate limits. During development, 429 errors appeared within minutes of testing. This was mitigated by building a MongoDB caching layer so each wallet or token only needs to be fetched once. A fallback to a dedicated RPC provider (Helius) is also available for production use.

Gemini API Quota Exhaustion
The Gemini free tier has tight per-minute and daily quotas. A single wallet analysis requires one Gemini call, but during testing the daily limit was reached quickly. Once limit: 0 was hit, every request returned 429 and flooded logs with stack traces. This was solved by building a circuit breaker with automatic retry-after parsing, a custom GeminiRateLimitException, and clean single-line warning logs. The heuristic fallback ensures the app stays fully functional without AI.

MongoDB Upsert Collisions
The model classes initially defaulted Id to null, which meant MongoDB stored _id: null as a valid key. The second upsert for a different entity would collide on that null key. This was fixed by generating unique ObjectIds on construction and preserving existing IDs during replacement operations.

Three.js Infinite Scroll
Getting the blockchain background to scroll infinitely without visual artifacts was harder than expected. The first approach shifted all block positions each frame, which caused compounding floating-point drift, blocks would slowly squeeze together and eventually get culled off-screen. The system was rewritten to use fixed slot positions with a single scroll offset, recycling blocks from the right edge to the left edge. Getting the array ordering, chain link connections, and spark references to remain consistent during recycling took several iterations.

Smooth Mood Transitions
Initial lighting transition code used double-lerping and frame-rate-dependent interpolation, which caused visible jitter on mood changes. This was replaced with a single-pass frame-rate-independent exponential decay (1 - 0.5^(dt/halfLife)) and brightness and pulse speed were locked to constants so only the colors change, making transitions smooth and non-distracting.

Svelte 5 Strictness
Svelte 5's stricter {@const} placement rules and TypeScript's string | undefined typing on route params required adjustments. $derived was used for computed values and nullish coalescing was applied on all route parameters.

Accomplishments I'm proud of

  • The rug pull detector actually works. Feeding it known scam tokens produces HIGH or CRITICAL risk ratings with specific, accurate indicators. It identifies supply concentration, suspicious wallet clusters, and liquidity patterns that match real rug pull post-mortems.

  • The 3D blockchain visualization is genuinely immersive. An infinite chain of blocks with physically-based rendering, chain link animations, traveling sparks, and mood-reactive lighting — all running at 60fps on a background canvas with glassmorphism UI layered on top. It is not a gimmick; it makes the risk data visceral. When analyzing a dangerous token and the entire scene slowly washes red, the danger becomes visually obvious.

  • Graceful degradation everywhere. No Gemini API key triggers heuristic fallback. Rate limiting activates the circuit breaker silently. If Solana RPC fails, cached data serves instead. The app never crashes and always returns something useful.

  • The circuit breaker for Gemini parses retryDelay from the response body, retries once with backoff, then opens the circuit for the specified duration. While open, it skips the network call entirely. This transformed a log-flooding issue into a single clean warning line.

  • Full-stack type safety. TypeScript interfaces on the frontend mirror the C# models on the backend. Svelte 5 runes provide compile-time safety on reactive state. MongoDB's typed collections enforce schema at the repository layer.

What I learned

  • Rate limiting is a first-class engineering problem, not an edge case. Both Solana RPC and Gemini API demonstrated that external dependencies will throttle requests, and applications must handle this gracefully from day one.

  • Frame-rate-independent animation math matters. Naive lerp(current, target, dt * speed) looks fine at 60fps but breaks at variable frame rates. Using exponential decay with a half-life parameter (1 - 0.5^(dt/halfLife)) produces identical visual results regardless of frame rate.

  • Svelte 5 runes are a paradigm shift. Moving from Svelte 4's $: reactive statements to $state, $derived, and $effect requires more explicit thinking about reactivity, but results in cleaner and more predictable code.

  • MongoDB upserts require careful ID management. The _id: null collision bug appeared only after inserting a second unique entity and reinforced that identity fields should never default to nullable values.

  • Three.js object lifecycle management is critical. Every new THREE.Mesh() requires a corresponding dispose() call on geometry and material to prevent GPU memory leaks. In a scene that recycles blocks infinitely, this discipline is essential.

  • Glassmorphism requires careful contrast tuning. Frosted glass panels look great over static backgrounds but can become illegible over animated 3D scenes. Blur radius, background opacity, and border contrast were tuned carefully to maintain readability across all visual states.

What's next for SolSignal

  • Real-time WebSocket streaming — Replace the current on-demand REST polling with live WebSocket feeds so whale alerts and risk changes push to the dashboard instantly as they occur on-chain.

  • Background data ingestion — Add an IHostedService background worker that continuously scans trending tokens and refreshes wallet scores, building a living intelligence database rather than only analyzing on user request.

  • Solana Reputation NFTs — Mint on-chain reputation scores as NFTs using Solnet's wallet and signing utilities so wallets can carry verifiable trust scores across the ecosystem.

  • AI Investment Agent — Build an autonomous agent that monitors SolSignal data streams and executes trades based on whale signals and risk thresholds, enabling an autopilot mode for on-chain intelligence.

  • Mobile optimization — Adapt the Three.js scene for lower-power devices with reduced particle counts and simplified materials, and add a motion-reduction toggle for accessibility.

  • Multi-chain expansion — Extend the analysis engine beyond Solana to Ethereum, Base, and other EVM chains to create a unified cross-chain intelligence platform.

  • Community alerting — Integrate Telegram and Discord bots so users can subscribe to alerts for specific wallets, tokens, or risk thresholds and receive notifications in real time.

Built With

Share this project:

Updates