Six months of building. The stack is running in production. The data is accurate. The bot is working. The docs site is up.

What's left is the last mile — tightening the APIs, finishing the docs, and making sure everything holds up before we open access.

Wire is in development. The data pipeline is live and stable. REST API and WebSocket are working. We're validating coverage and edge cases before opening the free tier.

Cipher is in internal testing. Insider detection is running on every new token launch. Signal filtering is working. The insider report widget is done. We're happy with the quality of the detection before we open this up.

Relay is in internal testing. The bot covers discovery, analytics, trading, copy trading, Hyperliquid, and AI analysis. Automated strategies are being tested. We want more time with it before it's in other people's hands.

The /insiders command output was text — useful but dense. This update adds a full visual interface: a network graph showing wallet relationships, fund flows, and pipeline structure at a glance.

The graph shows every wallet involved: CEX funding sources, buy wallets, transfer recipients, dump wallets, consolidation addresses. Edges show fund flow. Color indicates role. Pan and zoom to explore complex operations.

The pipeline breakdown shows each buy→transfer→dump chain individually — who bought, who received, who dumped, profit per pipeline, and whether the same wallets appear across multiple tokens.

The timeline shows the attack sequence in order. T+0: token created. T+1s: insiders buy. T+13s: fake price action. T+39s: transfers to dump wallets. T+63s: coordinated dump. The speed of these operations is striking when you see it laid out.

Available as a Telegram Mini App — tap the 🐀 button on any token card. Also available as an embeddable widget for teams building on top of Wire.

Token queries that previously took seconds now return in under 100ms. Filterable fields are maintained in a dedicated search index that updates as tokens trade — no computation on query.

Dead token filtering is on by default. Tokens with no recent trading activity, or tokens that have crashed more than 90% from ATH with no recovery, are excluded from discovery results. /discover bypasses this for the unfiltered feed.

Covered edge case scenarios for inactive tokens — volume windows now zero out automatically when a token stops trading.

We moved from development to dedicated production infrastructure. All services running, all data flowing, SSL everywhere, automated deployments on every push. The system has been running continuously without intervention.

What's live:

• Wire's data pipeline — ingesting and maintaining live state for every tracked token
• Wire's REST API and WebSocket proxy
• Cipher's insider detection — monitoring every new token launch
• Relay's Telegram bot — in internal testing

The pipeline is stable. The data is accurate. The bot is working.

Next: the public launch. We're finishing the docs site and cleaning up the last rough edges.

Cipher now does two things: detects insider activity on every new token, and uses that detection to filter the signal feed before anything reaches you.

Raw signals are noisy because most of them fire on compromised tokens. A volume surge looks the same whether it's organic or manufactured. Holder velocity looks the same whether wallets are accumulating or insiders are redistributing supply. Without the risk layer, signal and noise are indistinguishable.

Cipher's filter runs first. A volume surge on a token with 4 insider wallets holding 49% of supply doesn't fire. A volume surge on a token with zero insider flags does.

Signal types, now filtered:

• Volume surge — unusual volume on a token with clean insider metrics
• Holder velocity — rapid holder growth from organic wallets, not insider redistribution
• Curve approaching — bonding curve above 80%, migration imminent, insiders not holding significant supply
• Buy pressure — sustained buy/sell ratio spike from wallets that aren't flagged

Custom thresholds are coming — set your own insider % tolerance, sniper count limit, and dev wallet requirements.

Cipher is running. Every new token launch is monitored for insider wallet activity from the moment it's created. The results are embedded directly in every token response — no extra call, no separate tool.

Most coordinated dumps follow the same pattern: wallets funded from the same source buy on the bonding curve, transfer tokens to clean wallets that never touched the curve, and those wallets dump when momentum builds. The buy wallets look like normal traders. The dump wallets look like they appeared from nowhere. Without tracing the transfers, you can't connect them.

Cipher traces the transfers. Every wallet-to-wallet SPL token transfer on a newly launched token is captured. Wallets that receive tokens without buying on the curve are flagged. Funding sources are traced. The full pipeline is reconstructed.

On every token now: insider count, insider supply %, sniper count and supply %, dev wallet status, CEX funding source where identifiable.

/insiders command in Relay: full report for any token — pipeline breakdown, timeline of the attack sequence, cross-token repeat offender tracking.

Signal filtering: volume surge, holder velocity, curve approaching, and buy pressure signals are now checked against Cipher's risk data before reaching you. Tokens that don't pass are removed. What comes through is clean.

The pipeline had been running well, but we found failure modes that only show up under sustained load or after long uptimes. We fixed them.

Silent connection failures — where the connection appears alive but has stopped receiving data — now trigger automatic reconnection. This was causing occasional data gaps that were hard to notice but real.

Services now reset cleanly on restart. A previous bug left them in a degraded state after a stop/start cycle where events were processed but not emitted.

Error tracking is now consistent across all services. When something goes wrong, we know immediately.

Memory retention limits added across the board. The system stays lean over time instead of accumulating indefinitely.

None of this is visible externally. But it's the difference between a system that works most of the time and one that works all of the time.

Automated strategies are in internal testing. Define when to enter, define when to exit, and let the bot handle execution.

Entry conditions are built on Cipher's signal feed — volume surge, holder velocity, curve approaching, buy pressure. Set your thresholds. The strategy activates when criteria are met on a clean token.

Exit conditions: price target as a multiple of entry, stop loss as a percentage drawdown, time-based exit, or a combination. Take profit at 2x, stop loss at -30%, hard exit after 4 hours.

Position sizing: fixed SOL amount or a percentage of your configured budget. Multiple strategies can run simultaneously with independent budgets.

The core loop — signal fires, bot enters, conditions met, bot exits — is working in testing. The interface will improve before this opens up more broadly.

Full Hyperliquid perps and spot market support is live in the bot. Funding rates, open interest, liquidation events — all available via Telegram commands. Free for all tiers.

New commands: /perps, /perps <symbol>, /funding, /oi, /hlspot. Signal subscriptions for funding spikes, OI surges, and large liquidations.

On the Wire side, we fixed a long-standing issue with volume metrics. Volume windows (5m, 1h, 6h, 24h) were going stale when tokens stopped trading. They now zero out automatically when activity drops — what you see is always current.

Dead token filtering is on by default. Tokens with no recent activity or a 90%+ crash from ATH are excluded from discovery results. /discover bypasses this if you want the unfiltered feed.

14-day Pro trial provisioned automatically on first /start.

The filter system is rebuilt. The old version worked but didn't persist — you'd configure a filter, use it once, and lose it. The new version is named, saved, and composable.

Saved presets: name a filter configuration and load it with a single command. /hot my-setup applies it instantly. Multiple presets for different strategies.

Mini App widget: full UI for building filters without typing. Sliders for holder count, volume thresholds, bonding curve range, sniper protection, price direction. Save as a named preset. Opens inside Telegram.

Inline power syntax: still there for speed. /hot 5m min_holders:50 max_sniper_pct:3 — chain as many parameters as you want. One-shot overrides don't affect saved presets.

Tier-based limits are properly enforced. Free gets the core filters. Premium and Pro unlock deeper controls and more saved slots.

Traders screen is now an exit analytics dashboard — realized PnL distribution, exit timing, whale exits, sniper exits, exit velocity. Profitable exits concentrated in a short window tell a different story than exits spread over hours.

Holders screen shows concentration, PnL distribution, and behavior breakdown. How many holders are in profit vs loss. What percentage of supply the top wallets hold. Whether growth is organic or driven by a small number of large positions.

Price analytics replaced the raw candle dump — momentum, volatility, average cost basis, volume profile. Context that tells you whether a price move is meaningful or noise.

AI analysis now pulls from all of these screens. Ask "is this safe to enter?" and it synthesizes the full picture into a structured response.

The more you look at the data, the more you realize how much of what looks like market activity is a small number of wallets doing the same thing repeatedly.

Filters are now saved, named, and persistent. Load a preset with a single command. Modify it inline. The Mini App widget gives you sliders and toggles for every dimension — holder count, volume windows, bonding curve progress, sniper protection, price direction.

/discover is a new command for unfiltered search with no quality gates — useful when you want to see everything, not just the healthy tokens.

/wallet is live. Pass any wallet address and get their full Pump.fun trading history — every token they've touched, PnL on each, win rate, top wins and losses.

AI token analysis is working. Ask the bot anything about a token and get a structured response based on live data — holder picture, price action, risk metrics synthesized into a readable answer.

Tier-based access is enforced. Free gets the essentials. Premium and Pro unlock deeper filters and more saved presets.

Buy and sell tokens directly from Telegram. Every token card has buy buttons — tap one, confirm, done. No switching apps, no copying addresses. Slippage, priority fees, and wallet management are handled. You decide the size.

Copy trading is live. Point it at any wallet address and it mirrors that wallet's trades automatically. Set the position size and any token filters you want to apply. It runs in the background.

Automated strategies are in internal testing. Define entry conditions (volume surge, holder velocity, curve approaching) and exit conditions (price target, stop loss, time limit). The bot executes when criteria are met. We're testing this before opening it up.

Live: buy/sell from token cards, copy trading, transaction status updates in chat, wallet management.

In testing: automated entry/exit strategies, multi-wallet support.

The data is good. You can see everything you need to make a decision. What we found is that the decision itself is the bottleneck — you're looking at a token, the data looks clean, and you want to act. The fewer steps between "I want to buy this" and "I bought this", the better.

So the direction for Relay is clear: the bot isn't a dashboard you look at. It's a trading interface you act through. Data and execution in the same place.

What's working now:

• Token lookup by mint address or name
• /hot with enriched discovery cards
• Inline power syntax for fast filtering

What we're building next:

• Buy and sell directly from token cards
• Copy trading — mirror a wallet's positions automatically
• Automated strategies with configurable entry and exit conditions

Full-text search is live across all tracked tokens — by name, ticker, or contract address. Paste a mint and get the full picture. Search by name and get ranked results with live market data.

The Telegram bot has its first real commands. /hot surfaces trending tokens with volume, holder count, and risk indicators. Discovery cards show market cap, ATH drawdown, sniper count, and dev wallet status — everything needed to make a quick call.

Inline power syntax is already working: chain filters directly in the command without opening a widget. /hot 5m min_holders:20 sorts by 5-minute volume with a minimum holder threshold. The filter system is more capable than we expected at this stage.

Wire's REST API has its first working build. Pass a mint address, get back a full token snapshot — price, market cap, phase, bonding curve progress, holder count, volume across multiple windows, and the full holder list with positions and PnL.

Responses are fast. We're reading from live state maintained by the pipeline, so there's no database query on the hot path.

Working endpoints: token detail, trade history, OHLCV candles, holder list, holder count timeseries, and search by name or ticker.

Using it internally to validate data quality. So far the data looks right.

The WebSocket layer is working internally. Connect once, subscribe to what you care about, and events arrive as they happen.

Two subscription modes. Column-based: subscribe to a feed of tokens matching your criteria — new launches, tokens approaching migration, migrated tokens with rising volume. The feed updates live as tokens enter and exit your filters. Per-token: subscribe to a specific mint and receive every trade, OHLCV update, and holder change as it happens.

Both modes filter server-side. You define what you want once. Only matching events reach your handler.

Running against live Pump.fun data internally. Latency is good. Next step is stability testing before opening it up.

We're now ingesting and processing on-chain activity in real time across Pump.fun and other Solana launchpads. Every token launch, every trade, every holder change — captured, parsed, and stored.

Per token, we're tracking: price and market cap updated on every trade, bonding curve progress, holder count and per-wallet positions with entry price and unrealized PnL, volume across 5m / 1h / 6h / 24h windows, OHLCV candles at multiple resolutions, and the last 10,000 trades.

The WebSocket fan-out layer is working. Events reach connected clients in under a second from the on-chain transaction. We're running this internally against live data and the latency is consistently good.

Next: the API and the bot.

We spent time this week on the token data model. The question isn't just what fields to expose — it's how to structure state so reads are instant regardless of write volume.

We settled on clean separation: static metadata in one place, live market state in another, aggregated metrics in a third. Each part updates independently. A snapshot request never waits for a write to finish.

OHLCV candles work the same way — maintained live as trades come in, not computed on read. The current candle is always ready. Historical candles are already built.

None of this is visible yet. But it's the kind of decision that determines whether the system holds up at scale.

The Solana launchpad space moves fast. Tokens launch, trade, and die in minutes. The data is all on-chain — public, real-time, and largely unreadable without significant tooling. We decided to build that tooling properly.

The goal: any token, any metric, in under a second. Not a snapshot that refreshes on a timer. A live state that updates on every trade.

We started with the ingestion layer — subscribing to on-chain activity, parsing every relevant instruction, and maintaining live state for every tracked token. The pipeline is running. Tokens are flowing. The data looks right.

Nothing is public yet. Just building.