Introduction

What is LYS Labs?

LYS Labs is a blockchain data infrastructure focused on both real-time structured data streams served under 14ms and contextualized, AI-ready data served in under 30ms. This allows clients - from high-frequency traders to AI model trainers - to react before the rest of the market even knows what happened.

Context Matters

In Web3, data is power. But raw data from the blockchain is fragmented, noisy, and hard to use in real time. Raw blockchain data is just noise without context.

LYS transforms every transaction, event, and state change into contextualized, correlated, and enriched metrics that tell the full story - who is acting, why they might be acting, and how it connects to market dynamics.

We provide:

• Real-time structured insights – every decoded trade, token launch, or wallet movement is available instantly.

• Custom ontologies & schemas – define the exact data models you need for your strategies.

• AI-ready pipelines – ontology-grounded graphs powering retrieval-augmented generation (RAG) for intelligent agents and trading models.

With <30ms end-to-end latency from chain to your API or WebSocket stream, we don’t just deliver fast data - we deliver fast answers.

Offering at a glance

• 14ms – ultra-low-latency structured blockchain data

• <30ms – fully contextualized & contextualized data with correlations, aggregations, and enriched metrics

Your journey through these docs

This documentation is structured to mirror your learning curve:

1

Start here

Understand the platform and use cases

2

Dive into the architecture

Learn how the stack is built

3

Explore the data

From raw Solana logs to decoded events

4

Use the APIs

Live data, streaming endpoints, and GraphQL

5

Build

Train AI models or build apps on top of LYS

Who we serve

LYS isn’t just another analytics dashboard - it’s an intelligence platform. Here's how different power users benefit:

⚡ Traders

For High Frequency Traders:

• Access structured wallet flows, PnL trails, and anomaly graphs in <14ms.

• Execute faster with contextual alpha; skip 90% of data munging.

• Use cases: Real PnL mapping, token flow velocity, backtestable signal construction.

👾AI Agents

For AI Agents and other automations:

• Plug agents directly into contextualized data graphs with no pre-processing.

• Deploy and monetize autonomous agents in hours.

• Use cases: Auto-traders, copy- trading bots, NLP research agents.

🤖 Bots

For Trading Bots:

• NLP + streaming insights → bots that react to smart wallet flows and token events.

• Build smarter bots without touching RPC.

• Use cases: Pump.fun snipers, whale-watch bots, token rotation alerts.

🧠 MEV

For MEV Searchers and Quants:

• Direct access to block sequencing and mempool

• Transaction ordering for sandwich/backrun detection

• Arbitrage routing across DEXs at millisecond precision

🌊 DeFi

For DeFi protocols and LPs:

• Direct access to block sequencing and mempool

• Transaction ordering for sandwich/backrun detection

• Arbitrage routing across DEXs at millisecond precision

🔒 Security

For Security and Compliance:

• AML wallet clustering and transaction tracing

• Multi-hop anomaly detection for exploits and market manipulation

• Fully auditable query layer for compliance reporting

📊 Research

For Researchers and Aggregators:

• Real-time Solana data at subgraph-level latency

• Cross-chain analytics and historical snapshots

• Build your own dashboards or run custom ML pipelines

Key capabilities

1. Real-time pipelines

• Solana decoded in 14ms

• Live trade and liquidity streaming

• Support for EVM chains (block-by-block) (coming soon)

2. Custom ontologies

• Define your own schema over blockchain activity

• Baseline templates provided for fast start

3. Knowledge graphs

• Multi-hop wallet, token, protocol relationships

• Graph-native queries for advanced insights

4. AI-Optimized retrieval

• Ontology-Grounded RAG (OG-RAG) integration

• Built for LLMs and autonomous agents

How it works: The LYS data journey

1. Raw data ingestion

• Direct from full nodes, mempool, or Geyser (for Solana)

• Avoids third-party APIs = lower latency, more control

2. Parsing & decoding

• Protocol-specific decoders identify real events (e.g. swaps, votes, liquidity adds)

• Outputs are normalized to shared schemas

3. Indexing & aggregation

• Events are indexed in real time and written to memory + database

• Aggregators summarize trends (OHLCV, buy/sell counts, rug flags)

4. Contextualization

• Link events across wallets and time

• Discover hidden correlations (e.g., airdrop farming, vote manipulation)

5. Delivery

• APIs and WSS streams deliver data to bots, dashboards, or AI agents

• Sandbox enables querying in natural language, Cypher, or via API

Example:

Token Launch Detection

Here’s what happens when a token launches on Pump.fun:

• Decoder detects token creation, wallet funding, and initial liquidity

• Aggregator tracks early buys/sells, bundle flags, price rise

• Sandbox shows key metrics like bonding % change or suspicious wallets

• AI agents receive this context and decide whether to trade, alert, or ignore

Getting started with LYS

You don’t need to be an engineer to use LYS. But if you are, we’ll give you every hook you need.

You can:

• Use prebuilt aggregations (volume spikes, rug detection, bundle counts)

• Subscribe to live streams of decoded Solana events

• Train models on historical, structured token activity

Up next

In the next section, we’ll explore the LYS Platform in detail - how it all connects, what we’ve built, and how every layer serves data.

Ready? Let’s go.