> ## 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 Transaksi dengan LaserStream

> Alirkan transaksi Solana secara real-time dengan LaserStream — pemfilteran program, detail eksekusi, perubahan saldo token, dan pemutaran ulang yang aman saat koneksi tersambung kembali.

Pemantauan transaksi memungkinkan Anda melacak eksekusi transaksi, status berhasil/gagal, interaksi program, dan perubahan saldo token di seluruh Solana secara real-time. Panduan ini membahas strategi pemfilteran dan implementasi praktis menggunakan SDK [`helius-laserstream`](/docs/id/laserstream/clients).

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

***

## Opsi Pemfilteran Transaksi

LaserStream menggunakan bentuk filter yang sama dengan Yellowstone gRPC, termasuk filter `tokenAccounts` (perluasan ATA). Berikut adalah bidang yang akan Anda atur di dalam `transactions.<label>`:

* **`accountInclude`** — cocok jika salah satu akun ini muncul (OR logis)
* **`accountRequired`** — cocok hanya jika semua akun ini muncul (AND logis)
* **`accountExclude`** — abaikan jika salah satu akun ini muncul
* **`vote` / `failed`** — flag boolean untuk transaksi vote dan transaksi yang gagal
* **`tokenAccounts`** — perluasan akun token terkait (ATA) yang harus diaktifkan secara eksplisit (`"balanceChanged"`, `"all"`, atau `"none"`), sehingga dompet `accountInclude` juga cocok dengan transaksi tempat dompet tersebut memiliki saldo token SPL. Lihat [Pemfilteran Akun Token (ATA)](/docs/id/laserstream/token-account-filtering) dan tab **Memantau Dompet** di bawah.
* **`matchMints`** — flag yang harus diaktifkan secara eksplisit dan juga mencocokkan daftar akun dengan mint dalam saldo token sebelum/sesudah transaksi, sehingga mint dalam `accountInclude` menangkap setiap transfer, swap, mint, dan burn untuk token tersebut. Lihat [Pemfilteran Mint Token](/docs/id/laserstream/mint-filtering) dan tab **Memantau Token** di bawah.

<Tabs>
  <Tab title="Program Filtering">
    **Pantau transaksi yang melibatkan program tertentu**

    Lacak semua transaksi yang menyentuh program yang Anda minati:

    ```typescript theme={"system"}
    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: [],
    };
    ```

    **Paling sesuai untuk:** Pemantauan khusus program, pelacakan protokol DeFi, dan interaksi kontrak pintar.
  </Tab>

  <Tab title="Account-Specific">
    **Pantau transaksi yang memengaruhi akun tertentu**

    ```typescript theme={"system"}
    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: [],
    };
    ```

    **Kasus penggunaan:** Pemantauan dompet, pelacakan mint token, dan dasbor aktivitas akun.
  </Tab>

  <Tab title="Advanced Filtering">
    **Gabungkan beberapa kriteria filter**

    ```typescript theme={"system"}
    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: [],
    };
    ```

    **Logika filter:** `accountInclude` (OR) **AND** `accountRequired` (AND) **AND NOT** `accountExclude`.
  </Tab>

  <Tab title="Watching a Wallet">
    **Tangkap transfer token masuk, bukan hanya aktivitas langsung**

    `accountInclude` hanya cocok dengan transaksi ketika dompet muncul secara langsung dalam kunci akun. Ketika seseorang mengirim token SPL ke dompet, transfer tersebut menyentuh **akun token terkait (ATA)** milik dompet, bukan pubkey dompet — sehingga `accountInclude: [wallet]` biasa tidak akan mendeteksinya.

    Atur `tokenAccounts` untuk memperluas pencocokan ke transaksi ketika dompet **memiliki** saldo token. Bidang ini menerima string:

    * **`"balanceChanged"`** — cocok ketika saldo token yang dimiliki berubah (atau akun tokennya ditutup). Paling sesuai untuk "beri tahu saya ketika dana benar-benar berpindah" — lebih sempit, volumenya lebih rendah, dan merupakan pilihan default yang disarankan.
    * **`"all"`** — cocok dengan setiap transaksi yang merujuk pada saldo token yang dimiliki, meskipun saldonya tidak berubah. Volumenya jauh lebih tinggi.
    * **`"none"`** — tanpa perluasan (sama seperti menghilangkan bidang tersebut).

    ```typescript theme={"system"}
    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: [],
    };
    ```

    <Note>
      Pencocokan didasarkan pada pemilik — pencocokan ini menangkap setiap akun token yang dimiliki dompet (termasuk akun nonkanonis), bukan hanya alamat ATA turunan. SDK mengonversi string tersebut menjadi enum `TokenAccountExpansionControlFlag` tingkat wire untuk Anda.
    </Note>
  </Tab>

  <Tab title="Watching a Token">
    **Tangkap setiap transaksi untuk suatu mint, bukan hanya transaksi yang menyebutkannya**

    `accountInclude: [mint]` biasa hanya cocok dengan transaksi yang kunci akunnya memuat mint, seperti `MintTo`, `Burn`, atau `TransferChecked`. `Transfer` SPL klasik tidak pernah merujuk pada mint, sehingga sebagian besar transfer token tidak terdeteksi.

    Atur `matchMints: true` agar daftar akun juga dicocokkan dengan mint dalam `preTokenBalances` dan `postTokenBalances` transaksi:

    ```typescript theme={"system"}
    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: [],
    };
    ```

    Gabungkan dengan `tokenAccounts` untuk memantau satu token bagi satu dompet: tempatkan dompet di `accountInclude` dengan `tokenAccounts: "balanceChanged"`, dan mint di `accountRequired` dengan `matchMints: true`. Memerlukan `helius-laserstream` 0.8.5+ (JS), 0.6.4+ (Rust), atau `go/v0.3.0`+ (Go). Lihat [Pemfilteran Mint Token](/docs/id/laserstream/mint-filtering) untuk semantik lengkap.
  </Tab>
</Tabs>

***

## Contoh Praktis

### Contoh 1: Pantau Transaksi DEX

Lacak transaksi yang menyentuh program DEX populer:

```typescript [expandable] theme={"system"}
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);
```

### Contoh 2: Pantau Transaksi yang Gagal

Lacak transaksi yang gagal untuk mengungkap masalah aplikasi:

```typescript [expandable] theme={"system"}
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);
  });
}
```

### Contoh 3: Pantau Transaksi Bernilai Tinggi

Lacak transaksi dengan transfer SOL yang signifikan:

```typescript [expandable] theme={"system"}
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);
  });
}
```

### Contoh 4: Pantau Dompet (termasuk transfer token)

Pantau semua aktivitas yang memindahkan dana untuk suatu dompet — termasuk transfer token SPL masuk yang menyentuh ATA-nya — dengan menambahkan `tokenAccounts` ke filter `accountInclude` biasa:

```typescript [expandable] theme={"system"}
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);
  });
}
```

***

## Struktur Data Transaksi

<Accordion title="Transaction Message Structure">
  ```typescript theme={"system"}
  {
    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[];
    };
  }
  ```
</Accordion>

<Accordion title="Token Balance Changes">
  ```typescript theme={"system"}
  {
    accountIndex: number;
    mint: string;
    owner: string;
    uiTokenAmount: {
      amount: string;
      decimals: number;
      uiAmount: number;
      uiAmountString: string;
    };
  }
  ```
</Accordion>

<Accordion title="Instruction Details">
  ```typescript theme={"system"}
  {
    programIdIndex: number; // Index in accountKeys array
    accounts: number[];
    data: string;           // Instruction data (base58)
  }
  ```
</Accordion>

***

## Referensi Logika Filter

<CardGroup cols={2}>
  <Card title="Include Logic (OR)" icon="plus">
    **`accountInclude`:** Transaksi harus melibatkan SALAH SATU akun ini.

    `["A", "B"]` cocok dengan transaksi yang melibatkan akun A OR akun B.
  </Card>

  <Card title="Required Logic (AND)" icon="check">
    **`accountRequired`:** Transaksi harus melibatkan SEMUA akun ini.

    `["A", "B"]` cocok dengan transaksi yang melibatkan akun A AND akun B.
  </Card>

  <Card title="Exclude Logic (NOT)" icon="minus">
    **`accountExclude`:** Transaksi TIDAK boleh melibatkan satu pun akun ini.
  </Card>

  <Card title="Combined Logic" icon="code">
    Filter akhir: `(accountInclude OR empty) AND (accountRequired AND all) AND NOT (accountExclude OR any)`.
  </Card>
</CardGroup>

***

## Pertimbangan Performa

<Tabs>
  <Tab title="Volume Management">
    Aliran transaksi dapat memiliki volume tinggi. Agar dapat mengimbanginya:

    * Mulai dengan filter program tertentu (jangan berlangganan "semua transaksi")
    * Gunakan `confirmed` alih-alih `processed` jika Anda dapat menoleransi latensi tambahan sekitar 1,5 detik
    * Pantau kapasitas pemrosesan Anda dengan penghitung
    * Pertimbangkan untuk menjalankan beberapa konsumen secara paralel di belakang antrean

    ```typescript theme={"system"}
    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`);
    }
    ```
  </Tab>

  <Tab title="Data Processing">
    Ekstrak hanya data yang Anda perlukan agar penggunaan memori tetap rendah:

    ```typescript theme={"system"}
    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,
      };
    }
    ```
  </Tab>
</Tabs>

***

## Penanganan Kesalahan

<Accordion title="Too Many Transactions">
  **Gejala:** Volume transaksi terlalu besar.

  **Solusi:** Tambahkan filter yang lebih ketat (`accountRequired`, `accountExclude`); gunakan tingkat komitmen yang lebih tinggi; terapkan sampling atau pembatasan laju; proses secara asinkron.
</Accordion>

<Accordion title="Missing Transactions">
  **Gejala:** Transaksi yang diharapkan tidak muncul.

  **Solusi:** Pastikan alamat program sudah benar; periksa bahwa transaksi tersebut benar-benar ada; coba `processed` untuk mendapatkan pembaruan lebih cepat; longgarkan filter `accountRequired`/`accountExclude` yang terlalu ketat.
</Accordion>

<Accordion title="Parse Errors">
  **Gejala:** Data transaksi tidak dapat diuraikan.

  **Solusi:** Tangani bidang yang tidak ada dengan baik; validasi struktur sebelum memproses; bungkus penguraian dalam try/catch; lihat [Mendekode Data Transaksi](/docs/id/laserstream/guides/decoding-transaction-data).
</Accordion>

***

## Langkah Berikutnya

<CardGroup cols={2}>
  <Card title="Slot & Block Monitoring" icon="cube" href="/docs/id/laserstream/guides/slot-and-block-monitoring">
    Lacak konsensus jaringan dan produksi blok.
  </Card>

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

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

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