トランザクション監視 - Helius LaserStream

トランザクション監視では、Solana全体のトランザクション実行、成功／失敗ステータス、プログラムとのインタラクション、トークン残高の変更をリアルタイムで追跡できます。このガイドでは、helius-laserstream SDKを使用したフィルタリング戦略と実践的な実装について説明します。

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

トランザクションのフィルタリングオプション

LaserStreamは、tokenAccounts（ATA展開）フィルターを含め、Yellowstone gRPCと同じフィルター形式を使用します。transactions.<label>内で設定するフィールドは次のとおりです。

accountInclude — これらのアカウントのいずれかが含まれる場合に一致します（論理OR）
accountRequired — これらのアカウントがすべて含まれる場合にのみ一致します（論理AND）
accountExclude — これらのアカウントのいずれかが含まれる場合は除外します
vote / failed — 投票トランザクションと失敗したトランザクション用のブールフラグです
tokenAccounts — 関連トークンアカウント（ATA）を明示的に展開します（"balanceChanged"、"all"、または"none"）。これにより、accountIncludeのウォレットがSPLトークン残高を所有しているトランザクションにも一致します。トークンアカウント（ATA）のフィルタリングと、以下のウォレットの監視タブを参照してください。
matchMints — アカウントリストをトランザクション前後のトークン残高に含まれるミントとも照合するオプトインフラグです。これにより、accountIncludeに含まれるミントが、そのトークンのすべての転送、スワップ、ミント、バーンに一致します。トークンミントのフィルタリングと、以下のトークンの監視タブを参照してください。

Program Filtering
Account-Specific
Advanced Filtering
Watching a Wallet
Watching a Token

特定のプログラムが関係するトランザクションを監視します対象のプログラムに関連するすべてのトランザクションを追跡します。

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

const subscriptionRequest: SubscribeRequest = {
  transactions: {
    "program-filter": {
      accountInclude: [
        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Token Program
        "11111111111111111111111111111111",              // System Program
        "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"  // Your program
      ],
      accountExclude: [],
      accountRequired: [],
      vote: false,
      failed: false
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {},
  slots: {},
  transactionsStatus: {},
  blocks: {},
  blocksMeta: {},
  entry: {},
  accountsDataSlice: [],
};

最適な用途： プログラム固有の監視、DeFiプロトコルの追跡、スマートコントラクトとのインタラクション。

特定のアカウントに影響するトランザクションを監視します

const subscriptionRequest: SubscribeRequest = {
  transactions: {
    "wallet-filter": {
      accountInclude: [
        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC mint
        "YourWalletAddress"                                // Your wallet
      ],
      accountExclude: [],
      accountRequired: [],
      vote: false,
      failed: true // Include failures to track errors
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {}, slots: {}, transactionsStatus: {},
  blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
};

ユースケース： ウォレットの監視、トークンミントの追跡、アカウントアクティビティのダッシュボード。

複数のフィルター条件を組み合わせます

const subscriptionRequest: SubscribeRequest = {
  transactions: {
    "advanced-filter": {
      accountInclude: ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"],
      accountRequired: ["YourProgramId"], // Must include this program
      accountExclude: ["VoteProgram"],     // Exclude vote-related txs
      vote: false,
      failed: false
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {}, slots: {}, transactionsStatus: {},
  blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
};

フィルターロジック： accountInclude（OR）AND accountRequired（AND）AND NOT accountExclude。

直接的なアクティビティだけでなく、受信トークン転送も検出しますaccountIncludeは、ウォレットがアカウントキーに直接含まれるトランザクションにのみ一致します。誰かがウォレットにSPLトークンを送信すると、転送ではウォレットの公開鍵ではなく、ウォレットの**関連トークンアカウント（ATA）**が使用されるため、単純なaccountInclude: [wallet]では検出できません。tokenAccountsを設定すると、ウォレットがトークン残高を所有しているトランザクションまで照合対象を拡張できます。文字列として次の値を指定します。

"balanceChanged" — 所有しているトークン残高が変更された場合、またはそのトークンアカウントが閉じられた場合に一致します。「実際に資金が移動したときに通知する」用途に最適です。対象範囲が狭く、データ量も少ないため、デフォルトとして推奨されます。
"all" — 所有しているトークン残高を参照するすべてのトランザクションに、残高が変更されていない場合でも一致します。データ量が大幅に増加します。
"none" — 展開しません（フィールドを省略した場合と同じです）。

const subscriptionRequest: SubscribeRequest = {
  transactions: {
    "wallet-with-tokens": {
      accountInclude: ["YourWalletAddress"],
      accountExclude: [],
      accountRequired: [],
      vote: false,
      failed: false,
      tokenAccounts: "balanceChanged" // also match the wallet's ATAs
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {}, slots: {}, transactionsStatus: {},
  blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
};

照合は所有者に基づきます。派生したATAアドレスだけでなく、ウォレットが所有するすべてのトークンアカウント（非正規のものを含む）が対象です。SDKが文字列をワイヤーレベルのTokenAccountExpansionControlFlag列挙型に変換します。

ミント名を含むものだけでなく、そのミントに関するすべてのトランザクションを検出します単純なaccountInclude: [mint]は、MintTo、Burn、TransferCheckedなど、アカウントキーにミントが含まれるトランザクションにのみ一致します。従来のSPL Transferはミントを参照しないため、そのトークンの転送の大半が見逃されます。matchMints: trueを設定すると、アカウントリストがトランザクションのpreTokenBalancesおよびpostTokenBalancesに含まれるミントとも照合されます。

const USDC = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';

const subscriptionRequest: SubscribeRequest = {
  transactions: {
    "usdc-activity": {
      accountInclude: [USDC],
      accountExclude: [],
      accountRequired: [],
      vote: false,
      failed: false,
      matchMints: true // also match via pre/post token-balance mints
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {}, slots: {}, transactionsStatus: {},
  blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
};

tokenAccountsと組み合わせると、1つのウォレットについて1つのトークンを監視できます。ウォレットをtokenAccounts: "balanceChanged"とともにaccountIncludeに指定し、ミントをmatchMints: trueとともにaccountRequiredに指定します。helius-laserstream 0.8.5以降（JS）、0.6.4以降（Rust）、またはgo/v0.3.0以降（Go）が必要です。完全なセマンティクスについては、トークンミントのフィルタリングを参照してください。

実践的な例

例1：DEXトランザクションを監視する

一般的なDEXプログラムに関連するトランザクションを追跡します。

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

async function monitorDEXTransactions() {
  const subscriptionRequest: SubscribeRequest = {
    transactions: {
      "dex-filter": {
        accountInclude: [
          "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8", // Raydium
          "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK", // Raydium CLMM
          "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"   // Jupiter
        ],
        accountExclude: [],
        accountRequired: [],
        vote: false,
        failed: false
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {}, slots: {}, transactionsStatus: {},
    blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
  };

  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) => {
    if (!data.transaction?.transaction) return;
    const tx = data.transaction.transaction;
    console.log(`\n🔄 DEX Transaction:`);
    console.log(`  Signature: ${bs58.encode(tx.signature)}`);
    console.log(`  Slot: ${data.transaction.slot}`);
    console.log(`  Status: ${tx.meta?.err ? 'Failed' : 'Success'}`);
    console.log(`  Fee: ${tx.meta?.fee || 0} lamports`);
    console.log(`  Compute Units: ${tx.meta?.computeUnitsConsumed || 0}`);

    // Token balance changes
    if (tx.meta?.preTokenBalances?.length > 0) {
      console.log(`  Token Balance Changes:`);
      tx.meta.preTokenBalances.forEach((preBalance: any, index: number) => {
        const postBalance = tx.meta.postTokenBalances[index];
        if (preBalance && postBalance) {
          const change = postBalance.uiTokenAmount.uiAmount - preBalance.uiTokenAmount.uiAmount;
          if (change !== 0) {
            console.log(`    ${preBalance.mint}: ${change > 0 ? '+' : ''}${change}`);
          }
        }
      });
    }
  }, async (error) => {
    console.error('Stream error:', error);
  });
}

monitorDEXTransactions().catch(console.error);

例2：失敗したトランザクションを監視する

失敗したトランザクションを追跡して、アプリケーションの問題を明らかにします。

async function monitorFailedTransactions() {
  const subscriptionRequest: SubscribeRequest = {
    transactions: {
      "failures": {
        accountInclude: ["YourProgramId"],
        accountExclude: [],
        accountRequired: [],
        vote: false,
        failed: true // Only failed transactions
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {}, slots: {}, 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.transaction?.transaction?.meta?.err) return;
    const tx = data.transaction.transaction;
    console.log(`\n❌ Failed Transaction:`);
    console.log(`  Signature: ${bs58.encode(tx.signature)}`);
    console.log(`  Slot: ${data.transaction.slot}`);
    console.log(`  Error: ${JSON.stringify(tx.meta.err)}`);
    console.log(`  Fee: ${tx.meta.fee} lamports`);
    console.log(`  Compute Units: ${tx.meta.computeUnitsConsumed || 0}`);
  }, async (error) => {
    console.error('Stream error:', error);
  });
}

例3：高額トランザクションを監視する

大量のSOLが転送されるトランザクションを追跡します。

async function monitorHighValueTransactions() {
  const subscriptionRequest: SubscribeRequest = {
    transactions: {
      "system-program": {
        accountInclude: ["11111111111111111111111111111111"],
        accountExclude: [],
        accountRequired: [],
        vote: false,
        failed: false
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {}, slots: {}, 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.transaction?.transaction?.meta) return;
    const tx = data.transaction.transaction;
    const preBalances = tx.meta.preBalances || [];
    const postBalances = tx.meta.postBalances || [];

    let maxChange = 0;
    preBalances.forEach((preBalance: number, index: number) => {
      const postBalance = postBalances[index] || 0;
      maxChange = Math.max(maxChange, Math.abs(postBalance - preBalance));
    });

    const changeInSOL = maxChange / 1e9;
    if (changeInSOL > 10) {
      console.log(`\n💰 High-Value Transaction:`);
      console.log(`  Signature: ${bs58.encode(tx.signature)}`);
      console.log(`  Slot: ${data.transaction.slot}`);
      console.log(`  Max SOL Transfer: ${changeInSOL.toFixed(2)} SOL`);
      console.log(`  Fee: ${tx.meta.fee / 1e9} SOL`);
    }
  }, async (error) => {
    console.error('Stream error:', error);
  });
}

例4：ウォレットを監視する（トークン転送を含む）

単純なaccountIncludeフィルターにtokenAccountsを追加することで、そのウォレットのATAを使用する受信SPLトークン転送を含め、ウォレットの資金を移動するすべてのトランザクションを監視します。

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

async function watchWallet(wallet: string) {
  const subscriptionRequest: SubscribeRequest = {
    transactions: {
      "wallet-activity": {
        accountInclude: [wallet],
        accountExclude: [],
        accountRequired: [],
        vote: false,
        failed: false,
        // Also match txs touching token accounts this wallet owns.
        // "balanceChanged" = only when an owned token balance actually moved.
        tokenAccounts: "balanceChanged"
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {}, slots: {}, 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.transaction?.transaction) return;
    const tx = data.transaction.transaction;
    console.log(`\n👛 Wallet activity:`);
    console.log(`  Signature: ${bs58.encode(tx.signature)}`);
    console.log(`  Slot: ${data.transaction.slot}`);

    // Surface token balances this wallet owns that changed in the tx
    const owned = (tx.meta?.postTokenBalances || []).filter((b: any) => b.owner === wallet);
    owned.forEach((post: any) => {
      const pre = (tx.meta.preTokenBalances || []).find(
        (b: any) => b.accountIndex === post.accountIndex
      );
      const before = pre?.uiTokenAmount?.uiAmount || 0;
      const after = post.uiTokenAmount?.uiAmount || 0;
      if (after !== before) {
        console.log(`  ${post.mint}: ${after - before > 0 ? '+' : ''}${after - before}`);
      }
    });
  }, async (error) => {
    console.error('Stream error:', error);
  });
}

トランザクションのデータ構造

Transaction Message Structure

{
  signature: string;
  isVote: boolean;
  transaction: {
    message: {
      accountKeys: string[];        // All accounts involved
      instructions: Instruction[];  // Program instructions
      recentBlockhash: string;
    };
    signatures: string[];
  };
  meta: {
    err: any;                      // Error details if failed
    fee: number;                   // Transaction fee in lamports
    computeUnitsConsumed: number;
    preBalances: number[];
    postBalances: number[];
    preTokenBalances: TokenBalance[];
    postTokenBalances: TokenBalance[];
    logMessages: string[];
  };
}

Token Balance Changes

{
  accountIndex: number;
  mint: string;
  owner: string;
  uiTokenAmount: {
    amount: string;
    decimals: number;
    uiAmount: number;
    uiAmountString: string;
  };
}

Instruction Details

{
  programIdIndex: number; // Index in accountKeys array
  accounts: number[];
  data: string;           // Instruction data (base58)
}

フィルターロジックのリファレンス

Include Logic (OR)

accountInclude： トランザクションには、これらのアカウントのいずれかが含まれている必要があります。["A", "B"]は、アカウントAまたはアカウントBが関係するトランザクションに一致します。

Required Logic (AND)

accountRequired： トランザクションには、これらのアカウントがすべて含まれている必要があります。["A", "B"]は、アカウントAとアカウントBの両方が関係するトランザクションに一致します。

Exclude Logic (NOT)

accountExclude： トランザクションには、これらのアカウントが1つも含まれていてはいけません。

Combined Logic

最終的なフィルター：(accountInclude OR empty) AND (accountRequired AND all) AND NOT (accountExclude OR any)。

パフォーマンスに関する考慮事項

Volume Management
Data Processing

トランザクションストリームは大量のデータを生成する可能性があります。処理を追いつかせるには、次の方法を使用します。

特定のプログラムフィルターから始めます（「すべてのトランザクション」を購読しないでください）
約1.5秒の追加レイテンシーを許容できる場合は、processedではなくconfirmedを使用します
カウンターを使用して処理能力を監視します
キューの背後で並列コンシューマーを実行することを検討します

let count = 0;
const startTime = Date.now();
// inside your subscribe handler:
count++;
if (count % 100 === 0) {
  const elapsed = (Date.now() - startTime) / 1000;
  console.log(`Processing ${(count / elapsed).toFixed(1)} tx/sec`);
}

メモリ使用量を抑えるため、必要なデータのみを抽出します。

import bs58 from 'bs58';

function extractTransactionData(tx: any) {
  return {
    signature: bs58.encode(tx.signature),
    slot: tx.slot,
    success: !tx.meta?.err,
    fee: tx.meta?.fee || 0,
    computeUnits: tx.meta?.computeUnitsConsumed || 0,
  };
}

エラー処理

Too Many Transactions

症状： トランザクション量が多すぎて処理しきれません。解決策： より厳密なフィルター（accountRequired、accountExclude）を追加します。より高いコミットメントを使用します。サンプリングまたはレート制限を実装します。非同期で処理します。

Missing Transactions

症状： 想定したトランザクションが表示されません。解決策： プログラムアドレスが正しいことを確認します。トランザクションが実際に存在することを確認します。更新を高速化するにはprocessedを試します。制限の厳しいaccountRequired/accountExcludeフィルターを緩和します。

Parse Errors

症状： トランザクションデータを解析できません。解決策： 欠落しているフィールドを適切に処理します。処理前に構造を検証します。解析処理をtry/catchでラップします。トランザクションデータのデコードを参照してください。

次のステップ

Slot & Block Monitoring

ネットワークのコンセンサスとブロック生成を追跡します。

Stream Pump AMM Data

実際の例として、Pump.fun AMMトランザクションを監視します。

Decoding Transaction Data

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

Yellowstone protocol reference

生のYellowstone gRPCプロトコルに対して同じワークフローを実行します。

ここから始める

リアルタイムデータ

低レイテンシ取引

履歴データとウォレットデータ

RPC メソッドガイド

本番環境への対応

Orb の使用

その他のハウツー

LaserStreamによるトランザクション監視

トランザクションのフィルタリングオプション

実践的な例

例1：DEXトランザクションを監視する

例2：失敗したトランザクションを監視する

例3：高額トランザクションを監視する

例4：ウォレットを監視する（トークン転送を含む）

トランザクションのデータ構造

フィルターロジックのリファレンス

Include Logic (OR)

Required Logic (AND)

Exclude Logic (NOT)

Combined Logic

パフォーマンスに関する考慮事項

エラー処理

次のステップ

Slot & Block Monitoring

Stream Pump AMM Data

Decoding Transaction Data

Yellowstone protocol reference

​トランザクションのフィルタリングオプション

​実践的な例

​例1：DEXトランザクションを監視する

​例2：失敗したトランザクションを監視する

​例3：高額トランザクションを監視する

​例4：ウォレットを監視する（トークン転送を含む）

​トランザクションのデータ構造

​フィルターロジックのリファレンス

Include Logic (OR)

Required Logic (AND)

Exclude Logic (NOT)

Combined Logic

​パフォーマンスに関する考慮事項

​エラー処理

​次のステップ

Slot & Block Monitoring

Stream Pump AMM Data

Decoding Transaction Data

Yellowstone protocol reference

トランザクションのフィルタリングオプション

実践的な例

例1：DEXトランザクションを監視する

例2：失敗したトランザクションを監視する

例3：高額トランザクションを監視する

例4：ウォレットを監視する（トークン転送を含む）

トランザクションのデータ構造

フィルターロジックのリファレンス

パフォーマンスに関する考慮事項

エラー処理

次のステップ