> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Pemantauan Slot & Blok dengan LaserStream

> Pantau konsensus jaringan Solana, produksi blok, dan perubahan status jaringan dengan LaserStream — waktu slot, metadata blok, dan blok lengkap yang difilter.

Pemantauan slot dan blok memberi Anda gambaran tentang konsensus jaringan Solana, waktu produksi blok, dan kondisi jaringan secara keseluruhan. Dengan LaserStream, Anda dapat melacak progres slot, finalisasi blok, dan metrik performa jaringan secara real-time menggunakan SDK [`helius-laserstream`](/docs/id/laserstream/clients).

<Info>
  **Prasyarat:** Panduan ini mengasumsikan bahwa Anda telah menyelesaikan [Panduan Memulai Cepat gRPC LaserStream](/docs/id/laserstream/grpc) dan memiliki kunci API.
</Info>

***

## Jenis Pemantauan

<Tabs>
  <Tab title="Slot Updates">
    **Lacak progres konsensus jaringan**

    Pantau perkembangan slot di berbagai tingkat komitmen:

    ```typescript theme={"system"}
    import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream';

    const subscriptionRequest: SubscribeRequest = {
      slots: {
        slotSubscribe: {
          filterByCommitment: false // Receive all commitment levels
        }
      },
      commitment: CommitmentLevel.CONFIRMED,
      accounts: {}, transactions: {}, transactionsStatus: {},
      blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
    };
    ```

    **Data slot mencakup:** nomor slot, slot induk, status komitmen (`processed` / `confirmed` / `finalized`), dan informasi pemimpin.

    <Note>
      **Paling sesuai untuk:** Pemantauan kondisi jaringan, analisis waktu slot, pelacakan konsensus.
    </Note>
  </Tab>

  <Tab title="Block Data">
    **Pantau informasi blok lengkap**

    Alirkan blok lengkap beserta transaksi dan pembaruan akun:

    ```typescript theme={"system"}
    const subscriptionRequest: SubscribeRequest = {
      blocks: {
        blockSubscribe: {
          accountInclude: [], // All accounts
          includeTransactions: true,
          includeAccounts: true,
          includeEntries: false
        }
      },
      commitment: CommitmentLevel.CONFIRMED,
      accounts: {}, transactions: {}, transactionsStatus: {},
      slots: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
    };
    ```

    **Data blok mencakup:** metadata blok, transaksi, pembaruan akun, waktu blok.

    <Warning>
      **Volume tinggi:** Aliran blok lengkap menghasilkan data dalam jumlah besar. Gunakan filter `accountInclude` untuk mengurangi volumenya.
    </Warning>
  </Tab>

  <Tab title="Block Metadata">
    **Informasi blok yang ringan**

    Dapatkan metadata blok tanpa detail transaksi:

    ```typescript theme={"system"}
    const subscriptionRequest: SubscribeRequest = {
      blocksMeta: {
        blockMetaSubscribe: {}
      },
      commitment: CommitmentLevel.CONFIRMED,
      accounts: {}, transactions: {}, transactionsStatus: {},
      slots: {}, blocks: {}, entry: {}, accountsDataSlice: [],
    };
    ```

    **Metadata mencakup:** hash blok, hash induk, slot, ketinggian, jumlah transaksi, imbalan.

    <Tip>
      **Efisien:** Alternatif dengan bandwidth lebih rendah dibandingkan aliran blok lengkap.
    </Tip>
  </Tab>
</Tabs>

***

## Contoh Praktis

### Contoh 1: Pemantau Kondisi Jaringan

Lacak progres slot dan identifikasi masalah jaringan:

```typescript [expandable] theme={"system"}
import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream';

let lastSlot = 0;
let lastTimestamp = Date.now();
const slotTimes: number[] = [];

// CommitmentLevel only ships the forward (name → number) mapping, so we keep
// a small reverse lookup for the numeric status the SDK returns on slot updates.
const STATUS_NAMES = ['PROCESSED', 'CONFIRMED', 'FINALIZED'] as const;

async function monitorNetworkHealth() {
  const subscriptionRequest: SubscribeRequest = {
    slots: {
      slotSubscribe: {
        filterByCommitment: true // Track processed commitment levels
      }
    },
    commitment: CommitmentLevel.PROCESSED,
    accounts: {}, transactions: {}, transactionsStatus: {},
    blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
  };

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

  await subscribe(config, subscriptionRequest, async (data) => {
    if (!data.slot) return;
    const slot = data.slot;
    // The SDK returns u64 fields as strings to preserve precision.
    const currentSlot = Number(slot.slot);
    const currentTime = Date.now();

    console.log(`\n📊 Slot Update:`);
    console.log(`  Slot: ${currentSlot}`);
    console.log(`  Parent: ${slot.parent}`);
    // slot.status is a numeric enum (0=processed, 1=confirmed, 2=finalized).
    console.log(`  Status: ${STATUS_NAMES[slot.status] ?? slot.status}`);

    if (lastSlot > 0) {
      const slotDiff = currentSlot - lastSlot;
      const timeDiff = currentTime - lastTimestamp;

      if (slotDiff === 1) {
        slotTimes.push(timeDiff);
        if (slotTimes.length > 100) slotTimes.shift();

        const avg = slotTimes.reduce((a, b) => a + b, 0) / slotTimes.length;
        console.log(`  Slot Time: ${timeDiff}ms`);
        console.log(`  Avg Slot Time: ${avg.toFixed(1)}ms`);

        if (timeDiff > 800) {
          console.log(`  ⚠️  SLOW SLOT: ${timeDiff}ms (normal ~400ms)`);
        }
      } else if (slotDiff > 1) {
        console.log(`  ⚠️  SKIPPED ${slotDiff - 1} SLOTS`);
      }
    }

    lastSlot = currentSlot;
    lastTimestamp = currentTime;
  }, async (error) => {
    console.error('Stream error:', error);
  });
}

monitorNetworkHealth().catch(console.error);
```

### Contoh 2: Pemantau Produksi Blok

Lacak produksi blok dan volume transaksi:

```typescript [expandable] theme={"system"}
async function monitorBlockProduction() {
  const subscriptionRequest: SubscribeRequest = {
    blocksMeta: {
      blockMetaSubscribe: {}
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {}, transactions: {}, transactionsStatus: {},
    slots: {}, blocks: {}, entry: {}, accountsDataSlice: [],
  };

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

  await subscribe(config, subscriptionRequest, async (data) => {
    if (!data.blockMeta) return;
    const blockMeta = data.blockMeta;

    console.log(`\n🧱 Block Produced:`);
    console.log(`  Slot: ${blockMeta.slot}`);
    // blockHeight is a wrapper object: { blockHeight: '397657352' }
    console.log(`  Block Height: ${blockMeta.blockHeight?.blockHeight}`);
    console.log(`  Block Hash: ${blockMeta.blockhash}`);
    console.log(`  Parent Slot: ${blockMeta.parentSlot}`);
    console.log(`  Parent Hash: ${blockMeta.parentBlockhash}`);
    console.log(`  Transactions: ${blockMeta.executedTransactionCount}`);
    console.log(`  Entries: ${blockMeta.entriesCount}`);
    if (blockMeta.blockTime?.timestamp) {
      // blockTime.timestamp is a u64 as a string (Unix seconds).
      console.log(`  Block Time: ${new Date(Number(blockMeta.blockTime.timestamp) * 1000).toISOString()}`);
    }

    // rewards is a wrapper object: { rewards: [...], numPartitions: number | null }
    if (blockMeta.rewards?.rewards?.length > 0) {
      console.log(`  Rewards:`);
      blockMeta.rewards.rewards.forEach((r: any) => {
        console.log(`    ${r.pubkey}: ${r.lamports} lamports (${r.rewardType})`);
      });
    }

    if (Number(blockMeta.executedTransactionCount) > 3000) {
      console.log(`  🔥 HIGH ACTIVITY: ${blockMeta.executedTransactionCount} transactions`);
    }
  }, async (error) => {
    console.error('Stream error:', error);
  });
}
```

### Contoh 3: Pemantau Blok yang Difilter

Pantau blok yang berisi aktivitas program tertentu:

```typescript [expandable] theme={"system"}
async function monitorDEXBlocks() {
  const subscriptionRequest: SubscribeRequest = {
    blocks: {
      blockSubscribe: {
        accountInclude: [
          "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8", // Raydium
          "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK", // Raydium CLMM
          "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"   // Jupiter
        ],
        includeTransactions: true,
        includeAccounts: false,
        includeEntries: false
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {}, transactions: {}, transactionsStatus: {},
    slots: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
  };

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

  await subscribe(config, subscriptionRequest, async (data) => {
    if (!data.block) return;
    const block = data.block;

    let successfulDexTx = 0;
    let totalFees = 0; // lamports
    block.transactions?.forEach((tx: any) => {
      if (tx.meta && !tx.meta.err) {
        successfulDexTx++;
        // tx.meta.fee is a u64 string — coerce before adding.
        totalFees += Number(tx.meta.fee ?? 0);
      }
    });

    console.log(`\n🔄 DEX Activity Block:`);
    console.log(`  Slot: ${block.slot}`);
    console.log(`  Block Height: ${block.blockHeight?.blockHeight}`);
    console.log(`  Block Hash: ${block.blockhash}`);
    console.log(`  Total transactions in block: ${block.executedTransactionCount}`);
    console.log(`  Matched DEX transactions: ${block.transactions?.length ?? 0}`);
    console.log(`  Successful DEX transactions: ${successfulDexTx}`);
    if (successfulDexTx > 0) {
      console.log(`  Total Fees: ${(totalFees / 1e9).toFixed(4)} SOL`);
      console.log(`  Avg Fee: ${(totalFees / successfulDexTx / 1e9).toFixed(6)} SOL`);
    }
  }, async (error) => {
    console.error('Stream error:', error);
  });
}
```

***

## Struktur Data

<Accordion title="Slot Data Structure">
  ```typescript theme={"system"}
  {
    slot: string;     // Current slot number (u64 as string)
    parent: string;   // Parent slot number (u64 as string)
    status: number;   // CommitmentLevel enum: 0 = processed, 1 = confirmed, 2 = finalized
  }
  ```

  Setiap slot mewakili \~400 md waktu jaringan. Ketiga tingkat komitmen mencerminkan jaminan yang semakin kuat: `processed` (awal), `confirmed` (telah dipilih oleh supermayoritas), `finalized` (tidak dapat dibatalkan).

  <Tip>
    Kolom u64 (slot, parent) diterima sebagai string untuk mempertahankan presisi yang melampaui `Number.MAX_SAFE_INTEGER`. Konversikan dengan `Number(slot.slot)` saat Anda memerlukan operasi aritmetika. `status` adalah enum numerik — gunakan `CommitmentLevel[slot.status]` untuk mendapatkan nama yang mudah dibaca.
  </Tip>
</Accordion>

<Accordion title="Block Metadata Structure">
  ```typescript theme={"system"}
  {
    slot: string;                                  // u64 as string
    blockhash: string;
    rewards: {
      rewards: Array<{
        pubkey: string;
        lamports: string;                          // u64 as string
        rewardType: string;                        // "fee" | "rent" | "voting" | "staking"
      }>;
      numPartitions: number | null;
    };
    blockTime: { timestamp: string };              // Unix seconds as a u64 string
    blockHeight: { blockHeight: string };          // u64 as string, wrapped
    parentSlot: string;                            // u64 as string
    parentBlockhash: string;
    executedTransactionCount: string;              // u64 as string
    entriesCount: string;                          // u64 as string
  }
  ```

  <Tip>
    Kolom numerik (slot, parentSlot, executedTransactionCount, entriesCount, nilai di dalam `blockHeight` dan `blockTime`) dikeluarkan sebagai string karena bertipe u64 dalam proto yang mendasarinya. Bungkus dengan `Number(...)` untuk operasi aritmetika atau perbandingan.
  </Tip>
</Accordion>

<Accordion title="Full Block Structure">
  ```typescript theme={"system"}
  {
    slot: string;                                  // u64 as string
    blockhash: string;
    rewards: {
      rewards: Array<{
        pubkey: string;
        lamports: string;                          // u64 as string
        rewardType: string;
      }>;
      numPartitions: number | null;
    };
    blockTime: { timestamp: string };              // Unix seconds (u64 string)
    blockHeight: { blockHeight: string };          // u64 as string, wrapped
    parentSlot: string;                            // u64 as string
    parentBlockhash: string;
    executedTransactionCount: string;              // total executed tx in the block (u64 as string)
    updatedAccountCount: string;                   // total account updates in the block (u64 as string)
    entriesCount: string;                          // u64 as string
    transactions: Array<{
      signature: Buffer;                           // base58-encode for display
      isVote: boolean;
      transaction: TransactionMessage;             // full transaction payload
      meta: TransactionMeta;                       // execution metadata (fee, err, balances, …)
      index: string;                               // u64 as string
    }>;
    accounts: AccountUpdate[];                     // populated when includeAccounts: true
    entries: Entry[];                              // populated when includeEntries: true
  }
  ```

  Ukuran blok lengkap dapat mencapai beberapa MB karena memuat semua transaksi dan akun. Konvensi u64-sebagai-string yang sama juga berlaku — bungkus kolom numerik dengan `Number(...)` untuk operasi aritmetika. Di dalam setiap transaksi, `meta.fee`, `meta.preBalances`, `meta.postBalances`, dan lainnya juga berupa string.
</Accordion>

***

## Pertimbangan Performa

<CardGroup cols={2}>
  <Card title="Slot Monitoring" icon="clock">
    Ringan: bandwidth sangat rendah, overhead pemrosesan minimal. Cocok untuk dasbor pemantauan.
  </Card>

  <Card title="Block Metadata" icon="info">
    Seimbang: bandwidth sedang, wawasan tingkat blok tanpa data lengkap. Cocok untuk analitik.
  </Card>

  <Card title="Full Blocks" icon="database">
    Volume tinggi: data transaksi lengkap, memerlukan pemrosesan yang tangguh. Selalu gunakan bersama filter.
  </Card>

  <Card title="Filtered Blocks" icon="filter">
    Dioptimalkan: gunakan `accountInclude`, nonaktifkan `includeAccounts`/`includeEntries` yang tidak Anda perlukan.
  </Card>
</CardGroup>

***

## Kasus Penggunaan

<Tabs>
  <Tab title="Network Monitoring">
    Lacak kondisi dan performa jaringan — waktu slot, kemacetan, konsensus.

    ```typescript theme={"system"}
    const targetSlotTime = 400; // ms
    const tolerance = 200; // ms
    if (Math.abs(slotTime - targetSlotTime) > tolerance) {
      console.log(`Network performance issue detected`);
    }
    ```
  </Tab>

  <Tab title="Analytics & Metrics">
    Kumpulkan data analitik blockchain — volume transaksi, analisis biaya, ukuran blok, pola aktivitas.

    ```typescript theme={"system"}
    const dailyStats = {
      date: new Date().toDateString(),
      totalTransactions: 0,
      totalFees: 0,
      blockCount: 0
    };
    ```
  </Tab>

  <Tab title="Application Synchronization">
    Jaga agar aplikasi tetap sinkron dengan jaringan — pembaruan berbasis slot, konfirmasi blok.

    ```typescript theme={"system"}
    if (data.slot && data.slot.status === 'finalized') {
      updateApplicationState(data.slot.slot);
    }
    ```
  </Tab>
</Tabs>

***

## Penanganan Kesalahan

<Accordion title="Missing Slots">
  **Gejala:** Terdapat celah dalam progres slot.

  **Penyebab:** Masalah konektivitas jaringan, waktu henti validator, keterlambatan pemrosesan klien.

  **Solusi:** Lacak celah slot dan buat peringatan; implementasikan logika untuk mengejar ketertinggalan melalui [pemutaran ulang historis](/docs/id/laserstream/historical-replay); pantau kondisi koneksi.
</Accordion>

<Accordion title="High Volume">
  **Gejala:** Data blok terlalu banyak.

  **Solusi:** Gunakan metadata blok sebagai pengganti blok lengkap; terapkan filter akun; nonaktifkan penyertaan yang tidak diperlukan (entri, akun); proses secara asinkron.
</Accordion>

<Accordion title="Timing Issues">
  **Gejala:** Waktu slot tidak konsisten.

  **Analisis:** Hitung rata-rata bergerak; lacak penyimpangan; pantau metrik kondisi jaringan; korelasikan dengan performa validator.
</Accordion>

***

## Praktik Terbaik

<Note>
  **Pedoman Produksi:**

  * **Mulai dengan metadata** — gunakan metadata blok sebelum berlangganan blok lengkap
  * **Terapkan filter** — gunakan `accountInclude` untuk membuang data yang tidak relevan
  * **Pantau waktu** — lacak progres slot sebagai indikator awal kondisi jaringan
  * **Tangani celah** — gabungkan dengan [pemutaran ulang historis](/docs/id/laserstream/historical-replay) agar slot yang hilang otomatis diisi kembali saat koneksi tersambung ulang
  * **Proses secara asinkron** — jangan hambat pemrosesan aliran dengan komputasi berat
  * **Sesuaikan komitmen dengan kebutuhan** — `processed` untuk UI berlatensi rendah, `confirmed`/`finalized` untuk penulisan status
</Note>

***

## Langkah Berikutnya

<CardGroup cols={2}>
  <Card title="Transaction Monitoring" icon="receipt" href="/docs/id/laserstream/guides/transaction-monitoring">
    Filter transaksi berdasarkan program, akun, suara, atau status kegagalan.
  </Card>

  <Card title="Stream Pump AMM Data" icon="chart-line" href="/docs/id/laserstream/guides/stream-pump-amm-data">
    Contoh dunia nyata: pantau transaksi Pump AMM.
  </Card>

  <Card title="Decoding Transaction Data" icon="binary" href="/docs/id/laserstream/guides/decoding-transaction-data">
    Uraikan payload biner `transactionUpdate` menjadi transaksi Solana yang mudah dibaca.
  </Card>

  <Card title="Yellowstone protocol reference" icon="book" href="/docs/id/grpc/slot-and-block-monitoring">
    Alur kerja yang sama terhadap protokol gRPC Yellowstone mentah.
  </Card>
</CardGroup>