The engine · Operational
Nexus — the data intelligence engine.
Ingest, normalize, enrich, compute, and serve on-chain data from multiple Solana DEX — in real time. Deterministic parsing verified against the blockchain.
Pipeline
From validator edge to your stack — in five stages.
A single normalized path from raw Solana state to consumable APIs, real-time streams, and intelligent alerts.
2.4M
events / day
126K
wallets tracked
8.7K
tokens tracked
Ingestion
Yellowstone gRPC
Normalization
Deterministic parser
Computation
ClickHouse + PostgreSQL + Redis
Query
REST + WebSocket
Alerts
Real-time notifications
$ pipeline.nexus // operational
Capabilities
Seven layers, one engine.
Real-time ingestion
Solana state is streamed through Yellowstone gRPC, capturing swap transactions across multiple decentralized exchanges at the validator edge.
Events are filtered by protocol and normalized into a consistent 20-field schema as they arrive — no batched ETL, no overnight delay.
// specs
- latency
- sub-second
- chain
- solana mainnet
- protocol
- yellowstone gRPC
- status
- operational
Deterministic normalization
A proprietary parser identifies the trader, the tokens exchanged, and the exact amounts for every swap — using a deterministic method based on the transaction signer and balance changes.
The same method works across all supported DEX protocols because it relies on Solana protocol properties, not DEX-specific heuristics. Every field is verified against the blockchain.
// specs
- dex supported
- multiple protocols
- method
- deterministic
- verification
- field-by-field vs RPC
- language
- node.js
Computation layer
Ten independent workers process the normalized event stream in parallel. Price enrichment calculates token prices from swap ratios. FIFO position tracking computes realized P&L for every wallet.
Metrics aggregation produces rankings across multiple time windows. Each worker is stateless and event-driven — complexity is in the rules, not the runtime.
// specs
- workers
- 10 independent
- metrics
- wallets + tokens
- windows
- 7 time windows
- rankings
- 58 leaderboards
Storage
Immutable swap events are stored in a columnar analytics engine optimized for aggregation queries. Computed state — wallet metrics, token metrics, risk evaluations — lives in a relational database with ACID guarantees.
Pre-computed rankings and real-time cache are served from an in-memory store with sub-millisecond reads.
// specs
- analytics
- columnar engine
- state
- relational (primary + replica)
- cache
- in-memory store
- retention
- configurable
Query & API
REST endpoints serve wallet profiles, token analytics, rankings, and risk evaluations. A single profile request executes eight parallel queries and returns the complete picture of a wallet in under 50 milliseconds.
WebSocket channels deliver real-time alerts per user with sub-second delivery.
// specs
- access
- rest + websocket
- auth
- session + api keys
- endpoints
- 135+
- avg latency
- < 50ms
Risk evaluation
An independent risk evaluation engine analyzes wallet behavior through five modular fraud detectors: wash trading, sandwich bots, zero-loss anomaly, extreme frequency, and single-token dominance.
Every risk flag includes the specific evidence that triggered it — the numbers, thresholds, and patterns observed. Evaluation frequency adapts to wallet age: new wallets are checked every 5 minutes, established wallets every 6 hours.
// specs
- detectors
- 5 modular
- evidence
- auditable per-flag
- tiers
- adaptive frequency
- history
- transition log
Observability & security
The platform runs on a private network segmented into seven isolated layers with dedicated address spaces. Credentials are managed through an encrypted vault and injected at deployment time — never stored in code.
Monitoring covers system metrics, application metrics, and business metrics through a full observability stack with dashboards, log aggregation, and operational alerts.
// specs
- network
- 7 isolated layers
- secrets
- encrypted vault
- monitoring
- full stack
- access
- role-based