LaserStream Historical Replay: Backfill Missing Data

Recover from disconnections and backfill missing Solana blockchain data with LaserStream’s historical replay feature. Never miss a transaction again.

Never miss a beat: LaserStream’s Historical Replay ensures you can recover from disconnections and backfill missing data from the last 20 minutes of blockchain activity.

What is Historical Replay?

Historical Replay is LaserStream’s feature that lets you replay recent blockchain data from up to 3000 slots in the past (approximately 20 minutes of blockchain activity). This is particularly useful for handling disconnections and ensuring data continuity in real-time applications.

Limited Time Window: Historical replay is currently limited to the last 3000 slots (approximately 20 minutes of blockchain activity). You cannot replay data from arbitrary points in the past.

Handle Disconnections

Recover data lost during brief disconnections (up to 20 minutes)

Bootstrap Applications

Start applications with recent context from the last 20 minutes

Analyze Recent Events

Review recent transactions and account changes

Test with Recent Data

Use real recent data for testing and development

How It Works

1. Specify Starting Point

   Use the fromSlot parameter to set your replay starting point (must be within last 3000 slots)

2. Stream Historical Data

   LaserStream delivers all events from your specified slot forward

3. Catch Up to Real-Time

   Historical data streams until you reach the current slot

4. Continue Live Streaming

   Seamlessly transition to real-time data streaming

Automatic Reconnection: The LaserStream SDK handles reconnections and replay automatically. No additional code required!

Quick Start

gRPC

import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream';

const subscriptionRequest: SubscribeRequest = {
  transactions: {
    client: {
      accountInclude: ['TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'],
      vote: false,
      failed: false
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {},
  slots: {},
  blocks: {},
  blocksMeta: {},
  entry: {},
  accountsDataSlice: [],
  fromSlot: '224339000' // Start replay from this slot (must be within last 3000 slots)
};

const config: LaserstreamConfig = {
  apiKey: 'YOUR_API_KEY',
  endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
};

await subscribe(config, subscriptionRequest, 
  async (data) => {
    console.log('Received data:', data);
  }, 
  async (error) => {
    console.error('Error:', error);
  }
);

WebSocket (Soon)

const ws = new WebSocket('wss://laserstream-mainnet-ewr.helius-rpc.com/ws');

const subscribeMessage = {
  jsonrpc: '2.0',
  id: 1,
  method: 'transactionSubscribe',
  params: {
    transactions: {
      client: {
        accountInclude: ['6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P'],
        vote: false,
        failed: false
      }
    },
    commitment: 'confirmed',
    fromSlot: '224339000' // Start replay from this slot (must be within last 3000 slots)
  }
};

ws.onopen = () => {
  ws.send(JSON.stringify(subscribeMessage));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  console.log('Received data:', data);
};

Configuration Options

fromSlot · string · required

The slot number to start replaying from. Must be within the replay window (last 3000 slots from current slot).

Example: "224339000"

Important: The slot must be recent enough to fall within the 20-minute replay window.

Use Cases

Reconnection After Brief Disconnection

When your application reconnects after a short disconnection (under 20 minutes), you can use Historical Replay to ensure no data is missed:

// Store the last processed slot
let lastProcessedSlot = getLastProcessedSlot();

// Check if the slot is still within the replay window
const currentSlot = await getCurrentSlot();
const maxReplaySlot = currentSlot - 3000;

if (lastProcessedSlot < maxReplaySlot) {
  console.warn('Disconnection too long, some data may be lost');
  lastProcessedSlot = maxReplaySlot;
}

const subscriptionRequest: SubscribeRequest = {
  // ... your subscription config
  fromSlot: lastProcessedSlot.toString()
};

await subscribe(config, subscriptionRequest, 
  async (data) => {
    // Process data and update last processed slot
    await processData(data);
    lastProcessedSlot = data.slot;
    saveLastProcessedSlot(lastProcessedSlot);
  }
);

Bootstrap with Recent Context

Start your application with recent context from the last few minutes:

// Get a slot from 10 minutes ago (within the 20-minute window)
const currentSlot = await getCurrentSlot();
const startSlot = currentSlot - 1500; // ~10 minutes ago

const subscriptionRequest: SubscribeRequest = {
  // ... your subscription config
  fromSlot: startSlot.toString()
};

Testing with Recent Data

Use recent historical data for testing (limited to last 20 minutes):

// Test with data from the last 5 minutes
const currentSlot = await getCurrentSlot();
const testStartSlot = currentSlot - 750; // ~5 minutes ago
const testEndSlot = currentSlot - 150; // ~1 minute ago

const subscriptionRequest: SubscribeRequest = {
  // ... your subscription config
  fromSlot: testStartSlot.toString()
};

// Stop processing when reaching test end slot
await subscribe(config, subscriptionRequest, 
  async (data) => {
    if (data.slot >= testEndSlot) {
      // Stop processing
      return;
    }
    await processTestData(data);
  }
);

Next Steps

LaserStream gRPC

Learn more about gRPC streaming capabilities

SDK Documentation

View the complete SDK documentation

Contact Support

Get help with your implementation