Generate a Yellowstone Vixen Parser with Codama

How-to generate Vixen parser with Codama

This guide walks you through generating a Vixen Parser using Codama, a tool for rendering Rust SDKs and parser implementations from IDLs.

Vixen is a framework for building real-time program data pipelines in Rust. This guide helps you scaffold a parser that can be used in the Vixen runtime to decode and process Solana program data.

✅ Prerequisites

1. Generate a Codama Rust SDK for your program using codama:rust-renderers.

2. You must have an idl.json file—either an Anchor-generated IDL or a custom one.

3. Install pnpm (or use npm/yarn if preferred).

📦 Installation

Install the required Codama packages:

pnpm install @codama/renderers-vixen-parser

For the parser generation script, you’ll also need:

pnpm install \
  @codama/nodes \
  @codama/nodes-from-anchor \
  @codama/renderers-core \
  @codama/visitors-core

🛠 Setup

1. Create a New Rust Parser Project

cargo new program-parser --lib

Move your idl.json file into the newly created project folder:

mv idl.json program-parser/

2. Initialize a JavaScript Project (for Codegen)

From within the parser directory:

pnpm init

Install all required JS dependencies (see Installation above).

3. Create a Parser Generation Script

Inside program-parser/, create a new file called script.cjs:

// script.cjs
const path = require("node:path");
const { rootNode } = require("@codama/nodes");
const { rootNodeFromAnchor } = require("@codama/nodes-from-anchor");
const { readJson } = require("@codama/renderers-core");
const { visit } = require("@codama/visitors-core");
const { renderVisitor } = require("@codama/renderers-vixen-parser");

const project = "program-parser"; // folder name
const idl = readJson(path.join(__dirname, "idl.json"));

// Use the appropriate node constructor based on your IDL type:
const node = rootNodeFromAnchor(idl); // for Anchor
// const node = rootNode(idl.program); // for non-Anchor

visit(
  node,
  renderVisitor(path.join(__dirname, "src", "generated"), {
    sdkName: "my_program_sdk", // snake_case SDK name
    crateFolder: __dirname,
    formatCode: true,
  })
);

💡 Tip: Replace "my_program_sdk" with the actual SDK crate name you generated with Codama.

4. Run the Code Generation Script

node script.cjs

You should see files generated in src/generated/.

5. Configure Your Rust Project

Update src/lib.rs:

mod generated;

Update Cargo.toml:

[dependencies]
yellowstone-vixen-core = "0.1.0"
solana-program = "2.1.6"
borsh = "0.10"
my_program_sdk = { path = "./my_program_sdk" } # or from crates.io

6. Build and Verify

cargo build

If successful, you now have a working parser for Solana account data using Yellowstone Vixen.

🎉 You’re Done!

You’ve successfully generated a custom Vixen parser. It can now be integrated into a Vixen pipeline for parsing and handling account state from your Solana program.

🧠 Notes

• Codama enables reproducible parser generation from your program’s IDL. Any time your program updates, just re-run the script.

• Generated code is idiomatic Rust and integrates directly with yellowstone-vixen-core.

• Parsers are composable and can be used in a source → parser → sink pipeline for high-throughput indexing.