previous
Our protocol was growing fast — new tokens launching, liquidity pools spinning up, community members trading — but there was nowhere to see any of it. No dashboard, no charts, no way to know what was happening on-chain without reading Etherscan. The community was flying blind.
So I built Based Gecko (github.com/AaronJCunningham/based-gecko) — a real-time analytics platform for the entire ecosystem, inspired by what CoinGecko does for the broader market but purpose-built for ours.
When a token is brand new and only lives on one Uniswap pair, CoinGecko doesn’t know it exists. There’s no price API. No chart widget you can embed. Nothing. If you want to show your community what their tokens are doing, you have two options: tell them to go read raw blockchain data, or build the tooling yourself.
I went with option two.
Here’s the reality of building on Ethereum: every piece of data costs an RPC call, and RPC calls are slow and rate-limited. If every user who loads the page triggers a chain of blockchain queries — token lookups, reserve checks, swap history — the app crawls and your Alchemy bill explodes.
My solution was to flip the model. Instead of the frontend asking the blockchain for data on every page load, I built a backend service that scrapes the chain on a schedule, processes everything, and caches the result. The frontend just reads from the cache. Page loads are instant because the heavy lifting already happened in the background.
The scraper runs every 20 minutes. It finds every activated token in the ecosystem, checks which ones have Uniswap liquidity (V2 and V3, across multiple fee tiers), builds price histories, and parses recent trades. By the time a user opens the app, all of that data is sitting in memory ready to serve.
This one decision — moving blockchain queries off the user’s critical path — is what makes the whole platform feel fast. It’s the difference between a tool people actually use and one they close after 3 seconds of loading spinners.
This was the most fun challenge. CoinGecko has years of price history APIs. We had nothing — just raw pool state on Ethereum.
So I built charts from first principles. For each token, the scraper reads the Uniswap pool reserves at historical block numbers going back 60 days. The price at any moment is just the ratio between the two tokens in the pool. Plot those points on a timeline and you have a price chart — no API, no data provider, just math applied to on-chain state.
The transaction feed is built the same way. I parse raw Swap events from the pool contracts, figure out if each one was a buy or sell based on which token amounts moved, calculate the price and volume, and present it as a live feed of trades. The community can see exactly who’s buying, who’s selling, and at what price — all derived from the blockchain itself.
This matters because it means the platform can track any token the moment it gets a liquidity pool. No waiting for CoinGecko to index it. No submitting listing requests. If it exists on Uniswap, Based Gecko sees it.
Crypto communities live in chat. I built a trollbox — a live chat embedded in the platform — but with a twist: your identity is your wallet.
When you connect, you sign a message with MetaMask (no gas, no transaction). The backend verifies your signature and looks up your on-chain token holdings. Your chat messages get tagged with what you actually hold — not what you claim to hold. The server enriches every message with real balance data, so nobody can fake being a whale.
This creates a trust layer that most community platforms don’t have. When someone in chat says “I’m bullish,” you can see whether they’re holding a meaningful position or just talking. The leaderboard tracks top holders, individual token leaders, and daily streak — how many consecutive days someone has shown up. It rewards consistent community members, not drive-by speculators.
I built the chat window to be draggable and collapsible so it doesn’t get in the way of the data. On mobile it goes full-width. Small design decisions, but they matter when someone’s trying to check a price while having a conversation.
A token analytics platform has to show a lot of information without feeling overwhelming. I designed a three-column layout: token metadata on the left, the chart in the center, and trading stats on the right. On mobile it collapses to a single scrollable column — same data, different hierarchy.
One decision I’m proud of: what happens when a token doesn’t have an active trading pair yet. Instead of showing a blank space or a “no data” message, I render a Three.js particle visualization — a slowly rotating spiral of glowing particles. It makes the page feel alive even when there’s nothing to chart yet. Empty states are part of the design, not an afterthought.
Everything is custom — no component library, no pre-built theme. I designed the interface to feel like a proper trading terminal: dark background, accent colors for positive/negative movement, monospace type for numbers so columns align naturally. The goal was to make it feel professional enough that the community takes it seriously as a tool, not a toy.
The part I care about most isn’t any single feature — it’s that the whole thing works as a connected system.
The scraper feeds the cache. The cache feeds the frontend. WebSockets handle real-time chat. Wallet signatures tie everything to on-chain identity. The leaderboard pulls from Supabase, which gets updated on every chat message and login. Two services, one database, and the blockchain as the source of truth.
I designed, built, and shipped this solo — backend architecture, blockchain data pipeline, frontend, UI design, WebSocket infrastructure, auth system, database schema, deployment. It’s the kind of project where every layer talks to every other layer, and you can’t fake your way through any of them.