スロット＆ブロック監視

スロットとブロックの監視は、Solanaのネットワークコンセンサス、ブロック生成タイミング、全体的な健康状態を把握する手段です。LaserStreamを使用すると、スロットの進行、ブロックの確定化、ネットワークのパフォーマンス指標をリアルタイムで追跡できます。helius-laserstream SDKを使用します。

前提条件: このガイドは、LaserStream gRPC クイックスタートを完了し、APIキーを取得していることを前提としています。

監視の種類

スロット更新
ブロックデータ
ブロックメタデータ

ネットワークコンセンサスの進行を追跡コミットメントレベルにわたるスロットの進行を監視します。

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: [],
};

スロットデータに含まれるもの: スロット番号、親スロット、コミットメントステータス (processed / confirmed / finalized)、およびリーダー情報。

推奨用途: ネットワーク健全性の監視、スロットタイミングの分析、コンセンサス追跡。

完全なブロック情報を監視取引やアカウント更新を含むフルブロックをストリームします。

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

ブロックデータに含まれるもの: ブロックメタデータ、トランザクション、アカウント更新、ブロックタイミング。

高ボリューム: フルブロックストリームは大量のデータを生成します。accountIncludeフィルターを使用してボリュームを減らします。

軽量ブロック情報トランザクション詳細なしでブロックメタデータを取得します。

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

メタデータに含まれるもの: ブロックハッシュ、親ハッシュ、スロット、高さ、トランザクション数、報酬。

効率的: フルブロックストリーミングの低帯域代替。

実用例

例1: ネットワーク健康モニター

スロットの進行を追跡し、ネットワーク問題を特定します。

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);

例2: ブロック生成モニター

ブロック生成と取引量を追跡します。

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);
  });
}

例3: フィルタリングされたブロックモニター

特定のプログラム活動を含むブロックを監視します。

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);
  });
}

データ構造

スロットデータ構造

{
  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
}

各スロットは約400msのネットワーク時間を表します。3つのコミットメントレベルは段階的に強力な保証を反映しています: processed (初期)、confirmed (過半数投票済み)、finalized (不可逆)。

u64フィールド (スロット、親) はNumber.MAX_SAFE_INTEGERを超える精度を維持するために文字列として配信されます。算術が必要な場合はNumber(slot.slot)を使用して変換します。statusは数値列挙型であり、CommitmentLevel[slot.status]を使用して人間が読める名前にします。

ブロックメタデータ構造

{
  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
}

数値フィールド (スロット、親スロット、実行トランザクション数、エントリ数、blockHeightやblockTime内の値) はu64であるため文字列として出力されます。算術や比較にはNumber(...)を使用します。

フルブロック構造

{
  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
}

フルブロックにはすべてのトランザクションとアカウントを含む場合があり、数MBになることがあります。同じu64-as-stringの慣例が適用されます — 算術のために数値フィールドをNumber(...)でラップします。各トランザクション内では、meta.fee、meta.preBalances、meta.postBalancesなども文字列です。

パフォーマンスの考慮事項

スロットモニタリング

軽量：非常に低帯域、最小限の処理オーバーヘッド。監視ダッシュボードに適しています。

ブロックメタデータ

バランス：適度な帯域、ブロックレベルの洞察が得られます。アナリティクスに適しています。

フルブロック

高ボリューム：完全な取引データを含み、頑丈な処理が必要です。フィルターと組み合わせて使用します。

フィルタリングされたブロック

最適化: accountIncludeを使用し、必要のないincludeAccounts/includeEntriesを無効にします。

ユースケース

ネットワークモニタリング
分析とメトリクス
アプリケーション同期

ネットワークの健全性とパフォーマンスを追跡 — スロットタイミング、混雑、コンセンサス。

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

ブロックチェーン分析データを収集 — トランザクション量、料金分析、ブロックサイズ、活動パターン。

const dailyStats = {
  date: new Date().toDateString(),
  totalTransactions: 0,
  totalFees: 0,
  blockCount: 0
};

アプリケーションをネットワークと同期させる — スロットベースの更新、ブロック確認。

if (data.slot && data.slot.status === 'finalized') {
  updateApplicationState(data.slot.slot);
}

エラーハンドリング

スロットの欠落

症状: スロットの進行にギャップがあります。原因: ネットワーク接続問題、バリデータのダウンタイム、クライアント処理の遅延。ソリューション: スロットのギャップを追跡してアラートを設定する; 履歴リプレイを通じてキャッチアップロジックを実装する; 接続の健全性を監視する。

高ボリューム

症状: ブロックデータが多すぎます。ソリューション: フルブロックの代わりにブロックメタデータを使用; アカウントフィルターを適用; 不要な項目（エントリ、アカウント）を無効化; 非同期処理。

タイミングの問題

症状: スロットタイミングが不一致。分析: 移動平均を計算する; 偏差を追跡する; ネットワーク健康メトリクスを監視する; バリデータのパフォーマンスと相関を取る。

ベストプラクティス

プロダクションガイドライン:

メタデータから始める — フルブロックを購読する前にブロックメタデータを使用
フィルターを適用する — accountIncludeを使用して関係のないデータを削減
タイミングを監視する — スロットの進行をネットワーク健全性のカナリアとして追跡
ギャップを処理する — 履歴リプレイと組み合わせて欠けているスロットを再接続時に自動バックフィル
非同期処理 — 重い計算でストリーム処理をブロックしない
ニーズに合わせたコミットメント — 低レイテンシUIにはprocessed、状態書き込みにはconfirmed/finalized

次のステップ

トランザクションモニタリング

プログラム、アカウント、投票、または失敗ステータスでトランザクションをフィルタリングします。

ストリームポンプAMMデータ

実例: Pump AMMトランザクションを監視します。

トランザクションデータのデコード

バイナリtransactionUpdateペイロードを読み取り可能なSolanaトランザクションに解析します。

イエローストーンプロトコルリファレンス

生のイエローストーングRPCプロトコルに対する同じワークフロー。

はじめに

データストリーミングとイベントリスニング

データ API & RPC

トレーディング

トランザクションの送信

ウォレット・アズ・ア・サービス

ガイド

リソース

LaserStreamによるスロットおよびブロックの監視

監視の種類

実用例

例1: ネットワーク健康モニター

例2: ブロック生成モニター

例3: フィルタリングされたブロックモニター

データ構造

パフォーマンスの考慮事項

スロットモニタリング

ブロックメタデータ

フルブロック

フィルタリングされたブロック

ユースケース

エラーハンドリング

ベストプラクティス

次のステップ

トランザクションモニタリング

ストリームポンプAMMデータ

トランザクションデータのデコード

イエローストーンプロトコルリファレンス

​監視の種類

​実用例

​例1: ネットワーク健康モニター

​例2: ブロック生成モニター

​例3: フィルタリングされたブロックモニター

​データ構造

​パフォーマンスの考慮事項

スロットモニタリング

ブロックメタデータ

フルブロック

フィルタリングされたブロック

​ユースケース

​エラーハンドリング

​ベストプラクティス

​次のステップ

トランザクションモニタリング

ストリームポンプAMMデータ

トランザクションデータのデコード

イエローストーンプロトコルリファレンス

監視の種類

実用例

例1: ネットワーク健康モニター

例2: ブロック生成モニター

例3: フィルタリングされたブロックモニター

データ構造

パフォーマンスの考慮事項

ユースケース

エラーハンドリング

ベストプラクティス

次のステップ