Introducing Yellowstone Fumarole ♨️

We are thrilled to unveil Yellowstone Fumarole : a new persistent streaming solution that empowers you to subscribe to geyser event without losing any data, even in the event of network connection errors.

This blog post will go in depth on why we created Fumarole and why you would use it.

We love streaming ❤️🐉

The Solana ecosystem is filled with streaming solutions that allow developers to listen to blockchain events in real time. At Triton One, one of our most successful services is Yellowstone Dragon’s Mouth, a streaming solution widely used by traders, DEXs, APIs, and DeFi builders.

At Triton One, we strive to offer the best streaming service with the lowest possible latency. Building a gRPC interface on top of Geyser was a key decision, ensuring both high performance and maintainability for our customers.

Under the hood, we’ve gone through multiple iterations to optimize performance. We reduced unnecessary data copies, fine-tuned HTTP/2 settings, and rigorously tested different configurations to deliver the best possible performance.

While Yellowstone Dragon’s Mouth serves many use cases, we’ve noticed that many customers struggle with reliability and data persistence.

• What happens if I get disconnected from Dragon’s Mouth?
• How do I know if I missed data?
• How can I retrieve lost data?

These are all important questions, and, to be frank, answering them isn’t as straightforward as one might think.

High-availability ☁️✅

The new Yellowstone Fumarole service is designed for high availability, not just in terms of multiple endpoints to connect to, but also in how it fundamentally sources its data.

Under the hood, Fumarole aggregates data from multiple RPC nodes, coalescing everything into a single, consistent timeline of events.

This ensures that developers no longer need to worry about low-level redundancy challenges, such as subscribing to multiple RPC nodes or handling global deduplication of events.

Once you’re connected to Fumarole, you’re already receiving a highly available, reliable stream—without the extra complexity.

Persistence ⛰️

Persistence is by far the most important feature of Fumarole—blockchain data is stored in a distributed storage system, allowing our customers to query past events.

With Persistent Subscriber, Fumarole tracks your position in the data stream, ensuring that network issues won’t cause data loss. When you reconnect, you seamlessly resume from where you left off.

Persistent subscribers are cursors/point-in-time pointer of the internal Fumarole log architecture.

This is a feature many of our customers have been waiting for, and we believe it will be a game-changer for years to come.

Delivery guarantee

Fumarole is at-least-once delivery type of service. It’s a best-effort to avoid duplicated data.

Block-oriented

One of Fumarole’s key features that simplifies your workflow is this: you always receive the full block data before any slot status updates. If you’ve received a slot status, it means no more data will follow for that block—it’s that simple.

Back in Dragonsmouth, this was a common source of confusion for both the community and many of our customers: How can I tell if I’ve received everything for a block? Did I miss a transaction because of my filters? To answer that, you had to subscribe to additional intra-slot updates and build a state machine to track block reconstruction—a process that many users weren’t even aware they needed.

Fumarole eliminates that complexity. You’ll always receive transactions, accounts, and entries first, followed by the slot status updates (processed, confirmed, finalized). Always in that order.

New approach to public code : SDKs

Fumarole uses gRPC as the transport protocol between your client and the Fumarole servers. While the protobuf service definitions are publicly available, they are considered an internal implementation detail and not intended for direct use. These definitions may change at any time without notice.
For stability and forward compatibility, we recommend using the official client libraries, which provide a stable and well-supported interface.

Right now we have rust and python client.

Fumarole 🤝 Dragon’s mouth

We put a lot of effort into making Fumarole fully compatible with the Dragon’s Mouth API.

Not only does Yellowstone Fumarole output the same data as Dragon’s Mouth, but it also supports the same account and transaction filter APIs.

This ensures that developer integration requires minimal changes to existing code.

Follow the documentation instruction to create a dragonsmouth-like adapter from Fumarole

Getting started 🏃‍♀️🏃🏽‍♂️🏃🏿‍♀️

Start by downloading our Yellowstone fume CLI tool.

This tool will allow you to control your account in fumarole service and do necessary bookkeeping: create or delete persistent subscribers, list metadata and even streaming!

Download using pip:

cargo install yellowstone-fumarole-cli

Test it:

fume --version

The fume CLI is the tool you will be using as the control-plane of Fumarole.

This tool allows you to:

1. Create persistent subscribers;
2. List/Get persistent subscribers;
3. Delete persistent subscribers;
4. Streaming persistent subscribers.

For more details visit our crates.io where we host public Fumarole code.

Configuration file 📜

Fumarole CLI looks for a file in ~/.config/fume/config.yaml by default, you can change the path location by using fume --config <PATH>.

The configuration needed is simple, all you need is an endpoint and a token (contact your customer support channel for a token if you’re already a Triton customer, if not get in touch over Telegram):

endpoint: https://<FUMAROLE-PUBLIC-ENDPOINT>
x-token: "<YOUR X-TOKEN secret here>"

You can test your configuration file with test-config subcommand:

$ fume --config <path/to/config> test-config

or with custom config path:

$ fume --config path/to/config.yaml test-config

More details can be find using the --help option:

Yellowstone Fumarole CLI

Usage: fume [OPTIONS] <COMMAND>

Commands:
  test-config  Test the connection to the fumarole service
  get-info     Get Persistent Subscriber Info
  create       Create Persistent Subscriber
  delete       Delete a Persistent Subscriber
  list         List all persistent subscribers
  delete-all   Delete all persistent subscribers
  subscribe    Subscribe to fumarole events
  slot-range   Returns the slot range of remote fumarole service
  help         Print this message or the help of the given subcommand(s)

Options:
      --config <CONFIG>  Path to the config file. If not specified, the default config file will be used. The default config file is ~/.fumarole/config.yaml. You can also set the FUMAROLE_CONFIG environment variable to specify the config file. If the config file is not found, the program will exit with an error
  -v, --verbose...       Increase logging verbosity
  -q, --quiet...         Decrease logging verbosity
  -h, --help             Print help
  -V, --version          Print version

You can also visit docs.rs page for more example or our public repository.

Persistent subscriber staleness ⌛

Fumarole is essentially a log of blockchain events that gets prune at every moment to fit at most hours or days worth of blockchain data.

When you create a persistent subscriber, you actually create a point-in-time cursor over Fumarole’s internal log. If your cursor falls too much behind, it will become stale.

Once a subscriber is stale you cannot use it anymore and must delete it.

Wrapping up 🖖

Yellowstone Fumarole and Dragon’s Mouth are at the forefront of providing scalable, high-availability streaming solutions for blockchain data.

At Triton One, we are committed to continually enhancing the performance, reliability, and scalability of our services to meet the growing demands of blockchain developers.

We believe that with Fumarole, you now have the tools to ensure high-performance, fault-tolerant data streaming.

Check out other cool stuff Triton has!