fuel-streams 0.0.24

📝 About The Project

Fuel Streams is a Rust library designed for working with streams of Fuel blockchain data. It provides an efficient and user-friendly interface for developers to interact with real-time and historical blockchain data, offering support for Fuel-specific data types and leveraging NATS for scalable streaming.

🚀 Features

• Real-time streaming of Fuel blockchain data
• Historical streaming of Fuel blockchain data
• Support for Fuel-specific data types
• Efficient data handling using NATS
• Easy-to-use API for subscribing to and processing blockchain events
• Customizable filters for targeted data retrieval
• Seamless integration with other Fuel ecosystem tools

🛠️ Installing

First, add these dependencies to your project:

cargo add fuel-streams futures tokio

📊 Usage

Here are some examples to get you started with Fuel Streams:

Basic Connection and Subscription

use fuel_streams::prelude::*;
use futures::StreamExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a client and establish connection
    let mut client = Client::new(FuelNetwork::Local).with_api_key("your_key");
    let mut connection = client.connect().await?;

    println!("Listening for blocks...");

    // Create a subject for all blocks
    let subject = BlocksSubject::new();

    // Subscribe to blocks with last delivery policy
    let mut stream = connection
        .subscribe::<Block>(subject, DeliverPolicy::New)
        .await?;

    while let Some(block) = stream.next().await {
        println!("Received block: {:?}", block);
    }

    Ok(())
}

Custom Connection Options

use fuel_streams::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create client with custom connection options
    let mut client = Client::new(FuelNetwork::Local).with_api_key("your_key");
    Ok(())
}

Subject Types and Filtering

Each data type has its own subject builder for filtering. Here's an example using transaction filtering:

use fuel_streams::prelude::*;
use futures::StreamExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = Client::new(FuelNetwork::Local).with_api_key("your_key");
    let mut connection = client.connect().await?;

    println!("Listening for transactions...");

    // Create a subject for script transactions
    let subject = TransactionsSubject::new()
        .with_kind(Some(TransactionKind::Script));

    // Subscribe to the filtered transaction stream
    let mut stream = connection
        .subscribe::<Transaction>(subject, DeliverPolicy::New)
        .await?;

    while let Some(transaction) = stream.next().await {
        println!("Received transaction: {:?}", transaction);
    }

    Ok(())
}

Available subject builders include:

• BlocksSubject::new()
• TransactionsSubject::new()
• InputsSubject::new()
• OutputsSubject::new()
• LogsSubject::new()
• UtxosSubject::new()

Each subject builder provides specific filtering methods relevant to its data type. For example, TransactionsSubject allows filtering by transaction kind using the with_kind() method.

DeliverPolicy Options

The DeliverPolicy enum provides control over message delivery in your subscriptions:

• All: Delivers all messages in the stream
• Last: Delivers only the last message for the selected subjects
• New: Delivers only new messages that arrive after subscription
• ByStartSequence(u64): Delivers messages starting from a specific sequence number
• ByStartTime(DateTime<Utc>): Delivers messages starting from a specific time

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

For more information on contributing, please see the CONTRIBUTING.md file in the root of the repository.

📜 License

This project is licensed under the Apache-2.0 license. See LICENSE for more information.