Yellowstone Vixen

Yellowstone Vixen is a comprehensive framework for building program-aware, real-time Solana data pipelines. It provides the core components—runtime, parser definitions, and handler interfaces—needed to transform raw on-chain events into structured, actionable data. Vixen supports the registration of custom data sources, allowing developers to integrate various data streams seamlessly.

Solana change events, following the Yellowstone gRPC specification, are received from the source and routed through pluggable parsers. This enables developers to log, store, or stream enriched data for indexing, analytics, and downstream consumption.

Table of Contents

• Yellowstone Vixen
  • Table of Contents
  • Problem Solving
  • Features
  • Quick Start
  • Official Parsers
  • Official Sources
  • Developer Resources
  • Maintainers

Problem Solving

Yellowstone Vixen solves core challenges for Solana dApp developers:

• Cost Efficiency: Share Dragon's Mouth subscriptions and filter only the data you care about.
• Operational Simplicity: Lightweight setup, minimal external dependencies.
• Observability: Built-in Prometheus metrics for lag, throughput, and error tracking.
• Composability: Independent, reusable parser crates that can deserialize complex cross-program interactions (CPI).

Features

• 🛠 Parser + Handler Architecture: Build pipelines that transform raw Solana events into structured models and trigger custom logic.
• 🔥 Flexible Source Integration: Register custom data sources or use existing ones like Dragon's Mouth for Solana Geyser streams.
• 📈 Metrics Support: Prometheus /metrics endpoint available out-of-the-box.
• 🧪 Offline Testing with Fixtures: Test parsers without connecting to live Solana nodes using devnet fixtures.
• 🔄 gRPC Streaming API: Serve parsed program events directly to external systems or clients.

Quick Start

A minimal example using Token Program parsers and a Logger handler:

use std::path::PathBuf;

use clap::Parser;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
use yellowstone_vixen::Pipeline;
use yellowstone_vixen_parser::token_program::{AccountParser, InstructionParser};
use yellowstone_vixen_yellowstone_grpc_source::YellowstoneGrpcSource;

#[derive(clap::Parser)]
#[command(version, author, about)]
pub struct Opts {
    #[arg(long, short)]
    config: PathBuf,
}

#[derive(Debug)]
pub struct Logger;

impl<V: std::fmt::Debug + Sync> yellowstone_vixen::Handler<V> for Logger {
    async fn handle(&self, value: &V) -> yellowstone_vixen::HandlerResult<()> {
        tracing::info!(?value);
        Ok(())
    }
}

fn main() {
    tracing_subscriber::registry()
        .with(tracing_subscriber::EnvFilter::from_default_env())
        .with(tracing_subscriber::fmt::layer())
        .init();

    let Opts { config } = Opts::parse();
    let config = std::fs::read_to_string(config).expect("Error reading config file");
    let config = toml::from_str(&config).expect("Error parsing config");

    yellowstone_vixen::Runtime<YellowstoneGrpcSourc>::builder()
        .account(Pipeline::new(AccountParser, [Logger]))
        .instruction(Pipeline::new(InstructionParser, [Logger]))
        .build(config)
        .run();
}

RUST_LOG=info cargo run -- --config "./Vixen.toml"

Prometheus metrics are served on the /metrics endpoint. To collect metrics, we have setup a prometheus server as a docker container. You can access the metrics at http://localhost:9090 after running the prometheus server using docker-compose.

To run prometheus, you need to have docker and docker-compose installed on your machine. To start the services, run the following command:

sudo docker-compose up

Supported Programs

Official Sources

Yellowstone Vixen supports several official data sources for ingesting Solana account and transaction data. Each source is provided as a Rust crate and can be configured in your Vixen pipeline. Below is a summary of the available sources:

Refer to the crate documentation for setup instructions and configuration options.

Developer Resources

• Mock Testing for Parsers: Load and replay devnet accounts or transactions offline.
• Usage Examples: A variety of example projects that demonstrate how to use the features.
• Example Vixen Configuration: Starter TOML file for pipeline configuration.
• Generate Parsers from IDL: Use Codama to automatically generate Vixen parsers from Anchor or custom IDL files.

Maintainers

This project is developed by ABK Labs and Triton One.