Memepedia: The Memory Solana Never Had

Stop scrolling. Read this.

Solana has the highest throughput of any chain in production. 65,000 transactions per second at peak. A new block every 400 milliseconds. On a normal day it processes more raw activity than every other major chain combined, and on a busy day it produces more events in an hour than a human could read in a year. Tokens launch by the thousand. Wallets split, recombine, and disappear. KOLs call coins and delete the tweets ten minutes later. Devs migrate funds through six hops before lunch. Every byte of it sits on a public ledger that anyone can read, and almost nobody actually can. The throughput is the feature. The throughput is also the problem.

This is the gap that has sat open since the day Solana shipped. Solscan shows transactions. Birdeye shows charts. Bubblemaps shows holders. DexScreener shows pairs. Each tool answers exactly one question, and the person trying to make a decision is left with twenty browser tabs at two in the morning, stitching fragments together by hand, trying to catch the signal before the chart finishes telling the story without them.

The data exists. The context does not. The memory does not.

Memepedia is the memory.

What It Is

Memepedia is the largest open reference layer for Solana tokens. Paste a contract address. Get back everything worth knowing about it on a single page. The chart, the holder distribution, the dev wallet history, the liquidity events, the social mentions, the KOL calls, the wallet clusters, the narrative timeline, the risk flags, the comparable launches, the obituary if the coin is already dead. Not a list of tabs. Not a feed of disconnected data. One page that reads like something a researcher with infinite time would have written about that token, except the researcher is a fleet of clankers and the time is right now.

And here is the part nobody else has built. Memepedia builds itself.

The first time anyone in the world queries a contract, the clankers do the work from scratch. They pull the on-chain history, scrape the social layer, run the wallet graph, identify the dev, surface the snipers, write the entry, store it. The second time anyone queries that same contract, the entry is already there, already deeper than it was an hour ago, because every relevant event since the last read has been folded into it. Every query expands the archive. Every query makes the next query faster. Every search makes Memepedia bigger.

This is not a tool. It is a dataset that grows every time it is used.

The Fleet

Behind the search bar is a fleet of clankers, each one built for a single job and pointed at it without rest.

The Indexer never sleeps. It rides the firehose of Solana RPC and pulls every swap, transfer, mint, and liquidity event tied to a queried contract, normalizes it, and writes it to a structured store keyed by address and block height. At 65k TPS the chain never stops talking, and the Indexer never stops listening. Nothing gets missed because nothing gets filtered.

The Scout works the social layer. It runs against public X data, captures every mention, every reply, every quote tweet, and tags each one to the contract it references and the account that posted it. Accounts with track records get weighted differently from noise. A call from a wallet that has been right ten times in a row carries more signal than a call from a fresh account with three followers, and the Scout knows the difference.

The Forensics clanker sits on top of the on-chain layer and runs wallet clustering. It surfaces dev wallets, sniper clusters, bundler activity, insider groups. It traces fund flows back through multi-hop paths to find origin wallets. It cross-references those wallets against every other contract in the database, so a dev who has launched ten coins before is never an unknown the eleventh time around.

The Writer takes the structured output of all of the above and turns it into something a human can actually read. Chart context. Holder breakdown. Narrative timeline. Risk score. Comparable launches. Plain English, written fast, updated in place.

The Watcher patrols the finished entries and rewrites them when something material happens. A liquidity pull. A dev wallet move. A volume spike outside the rolling baseline. A mention from an account with a real track record. Each one triggers a partial regeneration, so the entry you read today is never the entry you read yesterday.

The Stack

Underneath the fleet is a pipeline built to keep up with the fastest chain in production.

Ingestion runs on dedicated high-throughput RPC through Helius and Triton, with parallel workers parsing program logs and decoding instructions in real time. Raw events flow into a normalized event store, where they get keyed by contract address and block height so any token’s full history can be reconstructed in a single query.

The structured layer sits in Postgres, partitioned by contract for fast lookups across millions of tokens. Alongside it, a vector database holds embeddings of every entry, every tweet, and every wallet cluster, so semantic search works the same way exact search does. Ask for a contract address and get a contract. Ask for a pattern and get every token that fits it.

The social layer pulls from public X data through dedicated APIs, with rate-limit-aware workers running in parallel against the same contract queue the indexer uses, so on-chain and off-chain context arrive together instead of in two separate trips. Wallet clustering runs as a background job over the event store, continuously updating the graph as new transactions land.

The Writer and Watcher run on top of a model layer that takes the structured data from every other component and turns it into prose, risk scores, and timelines. Outputs are versioned, so every entry has a history and every update is traceable back to the event that triggered it.

The whole pipeline is built to compound. Every contract that gets queried adds events, embeddings, wallet edges, and prose to the archive. Every new entry makes the next forensic pass faster, because the wallets in it are already known. Every new wallet edge tightens the graph. The system gets smarter the more it is used, and it never gets smaller.

The chain remembers everything. Memepedia is the layer that finally lets you read it.