Slot Subscriptions

Stream slot progression events as the validator processes, confirms, and finalizes slots. Each slot emits multiple updates as it moves through the commitment pipeline: Processed, Confirmed, Finalized, and optionally Rooted. Dead slots (skipped by the leader) also emit an update with an error message.

Slot subscriptions provide the foundation for timing-sensitive applications. Use them to measure validator latency, track confirmation times, detect leader schedule gaps, and coordinate operations that depend on specific commitment levels.

Filter Parameters

ParameterTypeRequiredDescription
filter_by_commitmentboolNoIf true, only emit updates at the subscription's commitment level. If false, emit all status transitions (Processed, Confirmed, Finalized).
interleaveboolNoIf true, interleave slot updates with other subscription types in order.

Update Payload

FieldTypeDescription
slotuint64The slot number
parentuint64The parent slot number
statusCommitmentLevelThe new status: Processed (0), Confirmed (1), Finalized (2), or Rooted (3)
dead_errorstring (nullable)If the slot was dead (skipped), contains the error reason

Code Examples

Track All Slot Status Transitions (Node.js)

1stream.write({
2  accounts: {},
3  slots: {
4    allSlots: {
5      filter_by_commitment: false  // Get all status transitions
6    }
7  },
8  transactions: {},
9  transactionsStatus: {},
10  blocks: {},
11  blocksMeta: {},
12  commitment: 0,  // Processed -- see all updates
13  entry: {},
14  accountsDataSlice: [],
15  ping: null
16});
17
18stream.on('data', (update) => {
19  if (update.slot) {
20    const slot = update.slot;
21    const statusNames = ['Processed', 'Confirmed', 'Finalized', 'Rooted'];
22    console.log('Slot ' + slot.slot + ' -- ' + statusNames[slot.status] + ' (parent: ' + slot.parent + ')');
23    if (slot.dead_error) {
24      console.log('  Dead slot:', slot.dead_error);
25    }
26  }
27});

Monitor Slot Progression with Status (Rust)

1use yellowstone_grpc_client::GeyserGrpcClient;
2use yellowstone_grpc_proto::prelude::*;
3use std::collections::HashMap;
4use futures::StreamExt;
5
6#[tokio::main]
7async fn main() -> anyhow::Result<()> {
8    let mut client = GeyserGrpcClient::build_from_uri("http://88.216.36.108:[PORT]")
9        .connect()
10        .await?;
11
12    let mut slots = HashMap::new();
13    slots.insert("allSlots".to_string(), SubscribeRequestFilterSlots {
14        filter_by_commitment: Some(false),
15        interleave: None,
16    });
17
18    let request = SubscribeRequest {
19        accounts: HashMap::new(),
20        slots,
21        transactions: HashMap::new(),
22        transactions_status: HashMap::new(),
23        blocks: HashMap::new(),
24        blocks_meta: HashMap::new(),
25        commitment: Some(CommitmentLevel::Processed as i32),
26        entry: HashMap::new(),
27        accounts_data_slice: vec![],
28        ping: None,
29        from_slot: None,
30    };
31
32    let (_, mut stream) = client.subscribe_with_request(Some(request)).await?;
33
34    while let Some(msg) = stream.next().await {
35        match msg?.update_oneof {
36            Some(UpdateOneof::Slot(slot)) => {
37                let status = match slot.status {
38                    0 => "Processed",
39                    1 => "Confirmed",
40                    2 => "Finalized",
41                    3 => "Rooted",
42                    _ => "Unknown",
43                };
44                println!("Slot {} -- {} (parent: {})", slot.slot, status, slot.parent.unwrap_or_default());
45                if let Some(err) = &slot.dead_error {
46                    println!("  Dead slot: {}", err);
47                }
48            }
49            _ => {}
50        }
51    }
52
53    Ok(())
54}

Common Use Cases

Use CaseFilter Configuration
Track all slot transitionsfilter_by_commitment: false with commitment Processed
Only finalized slotsfilter_by_commitment: true with commitment Finalized
Measure confirmation latencyTrack time between Processed and Confirmed for same slot
Detect dead/skipped slotsCheck dead_error field for non-null values
Validator health monitorTrack slot production rate and gap between processed and finalized
Leader schedule trackerCorrelate slot numbers with expected leader schedule
PreviousProgramsNextBlocks