Transaktionsdaten decodieren – Helius LaserStream

Wenn du Transaktionsdaten von Laserstream empfängst, solltest du auf zwei wichtige Dinge achten:

Message → Was der Benutzer tun wollte (sein signierter Vorschlag)
Meta → Was tatsächlich passiert ist (das Ausführungsergebnis)

Die Herausforderung: Transaktionsrohdaten liegen als binäre Byte-Arrays wie <Buffer 00 bf a0 e8...> vor und nicht als lesbare Adressen und Signaturen. Dieser Leitfaden zeigt dir, wie du: Die Binärdaten in ein menschenlesbares Format decodierst, relevante Informationen extrahierst und den gesamten Ablauf einer Transaktion vom Vorschlag bis zur Ausführung verstehst.

Ein Live-stream ohne Decodierung

Führe den folgenden minimalen Client aus. Die Filter-Flags verwerfen Abstimmungs- und fehlgeschlagene Transaktionen. Das Array accountInclude beschränkt die Ergebnisse auf Aktivitäten, die die Jupiter-Programm-ID betreffen.

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

async function runTransactionSubscription() {
  const config: LaserstreamConfig = {
    apiKey: 'YOUR_API_KEY', // from https://dashboard.helius.dev/
    endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // pick the closest region
  };

  const request = {
    transactions: {
      "Jupiter-transactions": {
        vote: false,
        failed: false,
        accountInclude: ['JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4']
      }
    },
    commitment: CommitmentLevel.PROCESSED,
    accounts: {}, slots: {}, transactionsStatus: {}, blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: []
  };

  const stream = await subscribe(
    config,
    request,
    (u: SubscribeUpdate) => console.log('💸 Transaction update', u),
    console.error
  );

  console.log(`✅ stream id → ${stream.id}`);
  process.on('SIGINT', () => { stream.cancel(); process.exit(0); });
}
runTransactionSubscription().catch(console.error);

Deine Konsole zeigt jetzt einen Wrapper: filters, createdAt und einen transaction-Zweig, der zwei untergeordnete Elemente enthält:

transaction.transaction.transaction → die signierte Message
transaction.transaction.meta → die Meta der Ausführung

{
 filters: [ 'Jupiter-transactions' ],
  account: undefined,
  transaction: {
    transaction: {
      signature: <Buffer 00 bf a0 e8 9f cc 84 0c a4 83 e3 97 cd b7 57 e2 2b bc 1d ca 8c a6 1b ce b5 57 d7 47 5e ec 1f 46 ae b2 2d 6a 12 cb 88 48 1d 07 bf f6 b2 d3 a8 0b c9 04 ... 14 more bytes>,
      transaction: [Object],
      meta: [Object],
      index: '1177'
    },
    slot: '351704819'
  },
  transactionStatus: undefined,
  block: undefined,
  blockMeta: undefined,
  entry: undefined,
  ping: undefined,
  pong: undefined,
  createdAt: 2025-07-07T10:58:44.403Z
}

Alles, was wie Uint8Array aussieht, bleibt vorerst undurchsichtig. Wenn du das Skript mit der Decodierungsfunktion ausführst, siehst du die tatsächliche verschachtelte Struktur mit lesbaren Adressen:

{
  "filters": ["Jupiter-transactions"],
  "account": undefined,
  "transaction": {
    "transaction": {
      "signature": "5u62i53R1Hdc4thm6DQTNWNkyypuJJSaXSMwwQDxNqKMaAw62H1Xa3Md7QDhYjoPk5dCPg18fwz83kUR6TrMviTx",
      "transaction": {
        "message": {
          "header": {
            "numRequiredSignatures": 1,
            "numReadonlySignedAccounts": 0,
            "numReadonlyUnsignedAccounts": 8
          },
          "accountKeys": [
            "AF9KFSWQeKVxd3kVvFvysWXmATHyYzrN8zN8GtXn4qTF",
            "G9VzXwhDPQ8KRbQAJN6TyGf2gWukYDAvmnXJhPZFev4f",
            "ES9qPxWQVMRZkobJ9yr3U6XSrXzGNLJdSe6p6fS7b82T",
            "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4",
            "ComputeBudget111111111111111111111111111111",
            "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
            "So11111111111111111111111111111111111111112",
            "11111111111111111111111111111111",
            "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
          ],
          "recentBlockhash": "8sGjRxJHLJVWqpHt5UdN8qxtLLdgcnLKBpFj9Qrn5PNF",
          "instructions": [
            {
              "programIdIndex": 4,
              "accounts": [],
              "data": "3bjaAzoXPjbY"
            },
            {
              "programIdIndex": 3,
              "accounts": [0, 1, 2, 5, 6, 7, 8],
              "data": "2L1xoA2KEqBgWfGt3fwFJK8k4FPJRJzYHRgH4R3xC8A7"
            }
          ]
        },
        "signatures": [
          "5u62i53R1Hdc4thm6DQTNWNkyypuJJSaXSMwwQDxNqKMaAw62H1Xa3Md7QDhYjoPk5dCPg18fwz83kUR6TrMviTx"
        ]
      },
      "meta": {
        "err": null,
        "fee": 12500,
        "preBalances": [1075517572, 0, 207594496815, 0, 0, 0, 0, 0, 0],
        "postBalances": [1075502572, 1461600, 207594496815, 2001231920, 2039280, 0, 0, 0, 0],
        "innerInstructions": [
          {
            "index": 1,
            "instructions": [
              {
                "programIdIndex": 5,
                "accounts": [1, 2, 0],
                "data": "3Bxs4h24hBtQy9rw"
              }
            ]
          }
        ],
        "logMessages": [
          "Program ComputeBudget111111111111111111111111111111 invoke [1]",
          "Program ComputeBudget111111111111111111111111111111 success",
          "Program JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4 invoke [1]",
          "Program log: Instruction: Swap",
          "Program ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL invoke [2]",
          "Program log: Create",
          "Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA invoke [3]",
          "Program log: Instruction: GetAccountDataSize",
          "Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA consumed 1569 of 242833 compute units",
          "Program return: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA pQAAAAAAAAA=",
          "Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA success",
          "Program JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4 success"
        ],
        "preTokenBalances": [],
        "postTokenBalances": [],
        "computeUnitsConsumed": 182564
      },
      "index": "1177"
    },
    "slot": "351709933"
  },
  "transactionStatus": undefined,
  "block": undefined,
  "blockMeta": undefined,
  "entry": undefined,
  "ping": undefined,
  "pong": undefined,
  "createdAt": "2025-01-14T10:58:44.403Z"
}

Binärdaten decodieren

Warum decodieren? Laserstream-Rohdaten enthalten Signaturen, Kontoschlüssel und Hashes als binäre Uint8Array-Objekte, die nicht lesbar sind. Du musst sie in base58-Strings umwandeln, um die Transaktion nachvollziehen zu können. Die Lösung: Laserstream verwendet Yellowstone gRPC mit integrierten Hilfsfunktionen zur Decodierung. Statt für jeden Feldtyp einen eigenen Decoder zu schreiben, verwenden wir eine rekursive Funktion, die alle Binärdaten in ein menschenlesbares Format umwandelt.

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

// Recursive function to convert all Buffer/Uint8Array fields to base58
function convertBuffers(obj: any): any {
  if (!obj) return obj;
  if (Buffer.isBuffer(obj) || obj instanceof Uint8Array) {
    return bs58.encode(obj);
  }
  if (Array.isArray(obj)) {
    return obj.map(item => convertBuffers(item));
  }
  if (typeof obj === 'object') {
    return Object.fromEntries(
      Object.entries(obj).map(([key, value]) => [key, convertBuffers(value)])
    );
  }
  return obj;
}

async function runTransactionSubscription() {
  const config: LaserstreamConfig = {
    apiKey: 'YOUR_API_KEY', // from https://dashboard.helius.dev/
    endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // pick the closest region
  };

  const request = {
    transactions: {
      "Jupiter-transactions": {
        vote: false,
        failed: false,
        accountInclude: ['JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4']
      }
    },
    commitment: CommitmentLevel.PROCESSED,
    accounts: {}, slots: {}, transactionsStatus: {}, blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: []
  };

  const stream = await subscribe(
    config,
    request,
    (update: SubscribeUpdate) => {
      if (update.transaction) {
        // Convert all binary fields to human-readable format
        const decodedTransaction = convertBuffers(update.transaction);
        console.log('💸 Decoded transaction:', JSON.stringify(decodedTransaction, null, 2));
        
        // Or process specific fields
        processTransaction(update.transaction);
      }
    },
    console.error
  );

  console.log(`✅ stream id → ${stream.id}`);
  process.on('SIGINT', () => { stream.cancel(); process.exit(0); });
}

function processTransaction(txUpdate: any) {
  const tx = txUpdate.transaction;
  const meta = tx.meta;
  
  console.log('Transaction Details:');
  console.log('- Signature:', bs58.encode(tx.signature));
  console.log('- Slot:', txUpdate.slot);
  console.log('- Success:', meta.err === null);
  console.log('- Fee:', meta.fee, 'lamports');
  console.log('- Compute Units:', meta.computeUnitsConsumed);
  
  // Account keys are already available in the message
  const message = tx.transaction.message;
  if (message.accountKeys) {
    console.log('- Account Keys:');
    message.accountKeys.forEach((key: Uint8Array, index: number) => {
      console.log(`  ${index}: ${bs58.encode(key)}`);
    });
  }
  
  // Log messages are already UTF-8 strings
  if (meta.logMessages && meta.logMessages.length > 0) {
    console.log('- Log Messages:');
    meta.logMessages.forEach((log: string) => {
      console.log(`  ${log}`);
    });
  }
}

runTransactionSubscription();

Dieser Ansatz nutzt die integrierte Decodierung und verarbeitet zugleich die Binärfelder, die du manuell umwandeln musst. Die Transaktionsstruktur ist bereits geparst. Du musst nur noch die Binärfelder in ein menschenlesbares Format umwandeln.

Die Transaktionsstruktur verstehen

Da wir die decodierten Daten jetzt sehen können, sehen wir uns die beiden Hauptbestandteile jedes Laserstream-Transaktionsupdates an. Wie im ersten Beispiel gezeigt, enthält jede Transaktion zwei zentrale Objekte:

Message (Vorschlag) → transaction.transaction.transaction → die signierte Message (Vorschlag des Benutzers)
Meta (Ausführung) → transaction.transaction.meta → die Metadaten der Ausführung (response des Validators)

Diese zweiteilige Struktur erzählt die gesamte Geschichte: was der Benutzer angefordert hat und was tatsächlich passiert ist. Sehen wir uns beide Teile im Detail an.

Der Vorschlag: alles innerhalb von message

Der Benutzer erstellt eine Message, die festlegt, was, wer und bis wann. So decodierst du die einzelnen Teile:

Transaktions-Header

{
  "header": {
    "numRequiredSignatures": 1,
    "numReadonlySignedAccounts": 0,
    "numReadonlyUnsignedAccounts": 5
  }
}

numRequiredSignatures teilt dem Validator mit, wie viele Signaturen er verifizieren muss. Die beiden numReadonly*-Werte kennzeichnen Konten, die die Laufzeitumgebung als schreibgeschützt behandeln kann. Das ermöglicht eine parallele Ausführung.

Wörterbuch der Kontoschlüssel

{
  "accountKeys": [
    "7YttLkHDoNj9wyDur5pM1ejNaAvT9X4eqaYcHQqtj2G5",
    "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4",
    "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
    "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    "So11111111111111111111111111111111111111112",
    "11111111111111111111111111111111"
  ]
}

accountKeys ist eine einfache Liste öffentlicher Schlüssel, die als Nachschlagetabelle dient. Jede spätere Ganzzahl in der Transaktion – programIdIndex sowie jedes Element im accounts-Array einer Anweisung – verweist per Index auf diese Liste. Dadurch spart jede Message mehr als ein Kilobyte.

Schutz vor Wiederholung

{
  "recentBlockhash": "8sGjRxJHLJVWqpHt5UdN8qxtLLdgcnLKBpFj9Qrn5PNF"
}

recentBlockhash läuft ab, sobald er nicht mehr zu den letzten 150 Block-Hashes gehört. Das dauert im Mainnet ungefähr 90 Sekunden.

Anweisungen: die eigentlichen Befehle

{
  "instructions": [
    {
      "programIdIndex": 10,
      "data": "HnkkG7"
    },
    {
      "programIdIndex": 15,
      "accounts": "3vtmrQMafzDoG2CBz1iqgXPTnC",
      "data": "5jRcjdixRUDKQKUEt6oHJ747HCB3vWb5y"
    }
  ]
}

Jede Anweisung enthält drei zentrale Teile:

Programm-ID (programIdIndex): Verweist auf eine Adresse im accountKeys-Array (z. B. Index 10 = ComputeBudget111111111111111111111111111111)
Konten (accounts): Ein base58-codierter String, der angibt, auf welche Kontoindizes diese Anweisung zugreift
Daten (data): Die eigentlichen, als base58 codierten Anweisungsdaten

Aufgrund der Funktion convertBuffers erscheinen Konten als base58, enthalten tatsächlich aber Kontoindizes. Beispielsweise wird "3vtmrQMafzDoG2CBz1iqgXPTnC" zu den Indizes [21, 19, 12, 17, 2, 6, 1, 22] decodiert. Dank dieses Designs verweist jede Anweisung nur auf Positionen in der Nachschlagetabelle, statt vollständige 32-Byte-Adressen zu wiederholen.

Signaturen: Autorisierungsnachweis

{
  "signatures": [
    "5u62i53R1Hdc4thm6DQTNWNkyypuJJSaXSMwwQDxNqKMaAw62H1Xa3Md7QDhYjoPk5dCPg18fwz83kUR6TrMviTx"
  ]
}

signatures enthält die kryptografischen Signaturen, die belegen, dass die erforderlichen Konten diese Transaktion autorisiert haben. Die Anzahl der Signaturen muss mit header.numRequiredSignatures übereinstimmen.

Nachschlagen in Adresstabellen

{
  "addressTableLookups": [
    {
      "accountKey": "5Q544fKrFoe6tsEbD7S8EmxGTJYAKtTVhAW5Q5pge4j1",
      "writableIndexes": [0, 1],
      "readonlyIndexes": [2, 3, 4]
    }
  ],
  "versioned": true
}

Wenn versioned den Wert true hat, erscheint addressTableLookups mit einer On-Chain-Tabelle und zwei Indexlisten. Nachschlagetabellen erhöhen die feste Obergrenze für die Anzahl der Adressen auf mehrere Dutzend und halten das Paket zugleich unter der MTU von 1.232 Byte.

Transaktion v1: Compute-Budget im Header

Transaktion v1 (SIMD-0385, Agave 4.2) fügt der Message ein weiteres Feld hinzu: transactionConfig.

{
  "transactionConfig": {
    "computeUnitLimit": 200000,
    "heapSize": null,
    "loadedAccountsDataSizeLimit": 200000,
    "priorityFee": 50000
  },
  "versioned": true
}

Eine v1-Transaktion enthält ihr Compute-Budget hier und nicht in Anweisungen des ComputeBudget-Programms. Daher enthält das instructions-Array einer v1-Transaktion nie einen ComputeBudget111111111111111111111111111111-Eintrag. priorityFee ist die Gesamtgebühr in Lamports für die gesamte Transaktion und nicht die Anzahl der Mikro-Lamports pro Compute-Einheit. Ein null-Feld bedeutet, dass der Sender keinen Wert festgelegt hat. Legacy- und v0-Messages haben kein transactionConfig. Daher kennzeichnet die Anwesenheit dieses Felds eine v1-Transaktion. Prüfe in deinem Decoder zwei Dinge:

Prioritätsgebühr extrahieren. Lies transactionConfig.priorityFee, wenn es vorhanden ist. Durchsuche ComputeBudget-Anweisungen nur bei Legacy- und v0-Transaktionen als Fallback. Code, der ausschließlich Anweisungen durchsucht, interpretiert jede v1-Transaktion so, als würde sie keine Prioritätsgebühr zahlen.
Proto-Version. yellowstone-grpc-proto 12.6.0 ist die erste Version, die die v1-Felder überträgt. helius-laserstream 0.8.4 (JavaScript), 0.6.3 (Rust) und 0.2.0 (Go) sind die ersten darauf basierenden SDK-Versionen. Ältere Versionen verwerfen transactionConfig ohne Hinweis.

Unter Unterstützung für Transaktion v1 findest du die vollständige Liste der Änderungen.

So hängt alles zusammen: der Ablauf

Ausgehend von den Grundlagen passiert Folgendes:

Nachschlagetabelle erstellen: accountKeys listet alle Adressen auf, auf die diese Transaktion zugreift
Regeln festlegen: header legt fest, wie viele Signaturen erforderlich und welche Konten schreibgeschützt sind
Befehle erstellen: Jedes instruction verweist auf:
- Ein Programm (über programIdIndex → accountKeys[index])
- Die benötigten Konten (über accounts → mehrere accountKeys[index]-Positionen)
- Die Anweisungsdaten (codiert in data)
Autorisierung hinzufügen: signatures belegt, dass die erforderlichen Konten diese Transaktion genehmigt haben
Ablaufzeit festlegen: recentBlockhash verhindert, dass diese Transaktion später erneut abgespielt werden kann

Die Ausführung: alles innerhalb von meta

Die Message zeigt, was der Benutzer tun wollte. Die Meta zeigt dagegen, was tatsächlich passiert ist, als die Validatoren die Transaktion ausgeführt haben.

Grundlegende Ausführungsinformationen

Erfolg/Fehlschlag

{
  "err": null,
  "fee": 12500
}

err: null = Erfolg
err: {...} = Fehlschlag mit Fehlerdetails
fee = für diese Transaktion berechnete Lamports

Kontostandsänderungen

{
  "preBalances": [1075517572, 0, 207594496815, 0, 0, 0, 0, 0, 0],
  "postBalances": [1075502572, 1461600, 207594496815, 2001231920, 2039280, 0, 0, 0, 0]
}

Die Kontostands-Arrays entsprechen per Index dem accountKeys-Array:

Konto 0: 15000 Lamports verloren (Gebührenzahlung)
Konto 1: 1461600 Lamports erhalten (neues Konto erstellt)
Konto 3: 2001231920 Lamports erhalten (Programmkonto)

Compute-Nutzung

{
  "computeUnitsConsumed": 182564
}

Zeigt, wie viel des angeforderten Compute-Budgets verwendet wurde.

Erweiterte Ausführungsdetails

Innere Anweisungen

{
  "innerInstructions": [
    {
      "index": 1,
      "instructions": [
        {
          "programIdIndex": 5,
          "accounts": [1, 2, 0],
          "data": "3Bxs4h24hBtQy9rw"
        }
      ]
    }
  ]
}

Innere Anweisungen sind zusätzliche Anweisungen, die Programme während der Ausführung aufgerufen haben. Sie gehören nicht zur ursprünglichen Transaktion, sondern wurden durch die Hauptanweisungen ausgelöst. Logmeldungen

{
  "logMessages": [
    "Program ComputeBudget111111111111111111111111111111 invoke [1]",
    "Program ComputeBudget111111111111111111111111111111 success",
    "Program JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4 invoke [1]",
    "Program log: Instruction: Swap",
    "Program ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL invoke [2]",
    "Program log: Create",
    "Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA invoke [3]",
    "Program log: Instruction: GetAccountDataSize",
    "Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA consumed 1569 of 242833 compute units",
    "Program return: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA pQAAAAAAAAA=",
    "Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA success",
    "Program JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4 success"
  ]
}

Logmeldungen zeichnen die Programmausführung chronologisch auf. Sie zeigen, welche Programme aufgerufen wurden und welche benutzerdefinierten Logmeldungen sie ausgegeben haben. Änderungen des Token-Guthabens

{
  "preTokenBalances": [],
  "postTokenBalances": [
    {
      "accountIndex": 1,
      "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
      "owner": "7YttLkHDoNj9wyDur5pM1ejNaAvT9X4eqaYcHQqtj2G5",
      "uiTokenAmount": {
        "amount": "1000000",
        "decimals": 6,
        "uiAmount": 1.0,
        "uiAmountString": "1"
      }
    }
  ]
}

Änderungen des Token-Guthabens zeigen die Zustände von SPL-Token-Konten vor und nach der Transaktion. Dazu gehören menschenlesbare Beträge mit korrekter Dezimalstellenverarbeitung.

Praktische Decodierungsmuster

Hier sind gängige Muster, mit denen du nützliche Informationen aus decodierten Transaktionen extrahierst:

// Transaction Success
function isTransactionSuccessful(meta: any): boolean {
  return meta.err === null;
}

function getTransactionFee(meta: any): number {
  return meta.fee;
}

function getComputeUnitsUsed(meta: any): number {
  return meta.computeUnitsConsumed;
}

// Balance Changes
function getBalanceChanges(meta: any, accountKeys: string[]): Array<{account: string, change: number}> {
  const changes = [];
  
  for (let i = 0; i < meta.preBalances.length; i++) {
    const change = meta.postBalances[i] - meta.preBalances[i];
    if (change !== 0) {
      changes.push({
        account: accountKeys[i],
        change: change
      });
    }
  }
  
  return changes;
}

// Program Calls
function getInvokedPrograms(meta: any, accountKeys: string[]): string[] {
  const programs = new Set<string>();
  
  meta.logMessages.forEach((log: string) => {
    const match = log.match(/Program ([1-9A-HJ-NP-Za-km-z]{32,}) invoke/);
    if (match) {
      programs.add(match[1]);
    }
  });
  
  return Array.from(programs);
}

// Token Transfers
function getTokenTransfers(meta: any): Array<{mint: string, from: string, to: string, amount: number}> {
  const transfers = [];
  
  // Compare pre and post token balances
  const preBalances = new Map();
  const postBalances = new Map();
  
  meta.preTokenBalances.forEach((balance: any) => {
    preBalances.set(balance.accountIndex, balance);
  });
  
  meta.postTokenBalances.forEach((balance: any) => {
    postBalances.set(balance.accountIndex, balance);
  });
  
  // Find changes
  for (const [accountIndex, postBalance] of postBalances) {
    const preBalance = preBalances.get(accountIndex);
    const preAmount = preBalance ? parseInt(preBalance.uiTokenAmount.amount) : 0;
    const postAmount = parseInt(postBalance.uiTokenAmount.amount);
    
    if (preAmount !== postAmount) {
      transfers.push({
        mint: postBalance.mint,
        account: postBalance.owner,
        change: postAmount - preAmount,
        decimals: postBalance.uiTokenAmount.decimals
      });
    }
  }
  
  return transfers;
}

Vollständiges Beispiel: Decoder für Jupiter-Swaps

Hier ist ein vollständiges Beispiel, das Jupiter-Swap-Transaktionen decodiert und relevante Informationen extrahiert:

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

interface SwapInfo {
  signature: string;
  slot: number;
  user: string;
  inputMint: string;
  outputMint: string;
  inputAmount: number;
  outputAmount: number;
  fee: number;
  success: boolean;
}

function convertBuffers(obj: any): any {
  if (!obj) return obj;
  if (Buffer.isBuffer(obj) || obj instanceof Uint8Array) {
    return bs58.encode(obj);
  }
  if (Array.isArray(obj)) {
    return obj.map(item => convertBuffers(item));
  }
  if (typeof obj === 'object') {
    return Object.fromEntries(
      Object.entries(obj).map(([key, value]) => [key, convertBuffers(value)])
    );
  }
  return obj;
}

function decodeJupiterSwap(txUpdate: any): SwapInfo | null {
  const tx = txUpdate.transaction;
  const meta = tx.meta;
  const message = tx.transaction.message;
  
  // Convert binary fields to readable format
  const signature = bs58.encode(tx.signature);
  const accountKeys = message.accountKeys.map((key: any) => bs58.encode(key));
  
  // Check if this is a Jupiter transaction
  const jupiterProgram = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
  if (!accountKeys.includes(jupiterProgram)) {
    return null;
  }
  
  // Extract user (first account is typically the fee payer/user)
  const user = accountKeys[0];
  
  // Get token balance changes
  const tokenChanges = getTokenTransfers(meta);
  
  // Find input (negative change) and output (positive change)
  const inputChange = tokenChanges.find(change => change.change < 0);
  const outputChange = tokenChanges.find(change => change.change > 0);
  
  if (!inputChange || !outputChange) {
    return null;
  }
  
  return {
    signature,
    slot: parseInt(txUpdate.slot),
    user,
    inputMint: inputChange.mint,
    outputMint: outputChange.mint,
    inputAmount: Math.abs(inputChange.change),
    outputAmount: outputChange.change,
    fee: meta.fee,
    success: meta.err === null
  };
}

function getTokenTransfers(meta: any): Array<{mint: string, change: number}> {
  const transfers = [];
  
  const preBalances = new Map();
  const postBalances = new Map();
  
  meta.preTokenBalances.forEach((balance: any) => {
    preBalances.set(balance.accountIndex, balance);
  });
  
  meta.postTokenBalances.forEach((balance: any) => {
    postBalances.set(balance.accountIndex, balance);
  });
  
  for (const [accountIndex, postBalance] of postBalances) {
    const preBalance = preBalances.get(accountIndex);
    const preAmount = preBalance ? parseInt(preBalance.uiTokenAmount.amount) : 0;
    const postAmount = parseInt(postBalance.uiTokenAmount.amount);
    
    if (preAmount !== postAmount) {
      transfers.push({
        mint: postBalance.mint,
        change: postAmount - preAmount
      });
    }
  }
  
  return transfers;
}

async function runJupiterSwapMonitor() {
  const config: LaserstreamConfig = {
    apiKey: 'YOUR_API_KEY', // from https://dashboard.helius.dev/
    endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // pick the closest region
  };

  const request = {
    transactions: {
      "Jupiter-swaps": {
        vote: false,
        failed: false,
        accountInclude: ['JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4']
      }
    },
    commitment: CommitmentLevel.PROCESSED,
    accounts: {}, slots: {}, transactionsStatus: {}, blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: []
  };

  const stream = await subscribe(
    config,
    request,
    (update: SubscribeUpdate) => {
      if (update.transaction) {
        const swapInfo = decodeJupiterSwap(update.transaction);
        if (swapInfo) {
          console.log('🔄 Jupiter Swap:');
          console.log(`  User: ${swapInfo.user}`);
          console.log(`  Input: ${swapInfo.inputAmount} of ${swapInfo.inputMint}`);
          console.log(`  Output: ${swapInfo.outputAmount} of ${swapInfo.outputMint}`);
          console.log(`  Fee: ${swapInfo.fee} lamports`);
          console.log(`  Success: ${swapInfo.success}`);
          console.log(`  Signature: ${swapInfo.signature}`);
          console.log('---');
        }
      }
    },
    console.error
  );

  console.log(`✅ Jupiter swap monitor started (id: ${stream.id})`);
  process.on('SIGINT', () => { stream.cancel(); process.exit(0); });
}

runJupiterSwapMonitor().catch(console.error);

Dieses Beispiel zeigt, wie du die Decodierung der Message mit der Analyse der Meta kombinierst, um geschäftsrelevante Informationen aus komplexen DeFi-Transaktionen zu extrahieren.

Das Wichtigste

Zweiteilige Struktur: Jede Transaktion hat eine Message (was angefordert wurde) und eine Meta (was tatsächlich passiert ist)
Binärdaten decodieren: Verwende bs58.encode(), um Binärfelder in lesbare base58-Strings umzuwandeln
Kontoschlüssel nachschlagen: Anweisungen referenzieren Konten über ihren Index im accountKeys-Array
Kontostände verfolgen: Vergleiche preBalances und postBalances, um Änderungen zu erkennen
Transaktion v1: Lies das Compute-Budget und die Prioritätsgebühr aus transactionConfig, wenn es vorhanden ist. v1-Transaktionen enthalten keine ComputeBudget-Anweisungen

Um Solana-Transaktionen zu verstehen, musst du erkennen, dass sie auf Effizienz ausgelegt sind: Statt Adressen zu wiederholen, verwenden sie Nachschlagetabellen und Indizes. So minimieren sie die Transaktionsgröße und maximieren zugleich die Informationsdichte.

Hier starten

Echtzeitdaten

Trading mit niedriger Latenz

Historische Daten und Wallet-Daten

Anleitungen zu RPC-Methoden

Produktionsreife

Orb verwenden

Weitere Anleitungen

Transaktionsdaten decodieren und parsen

Ein Live-stream ohne Decodierung

Binärdaten decodieren

Die Transaktionsstruktur verstehen

Der Vorschlag: alles innerhalb von message

Transaktions-Header

Wörterbuch der Kontoschlüssel

Schutz vor Wiederholung

Anweisungen: die eigentlichen Befehle

Signaturen: Autorisierungsnachweis

Nachschlagen in Adresstabellen

Transaktion v1: Compute-Budget im Header

So hängt alles zusammen: der Ablauf

Die Ausführung: alles innerhalb von meta

Grundlegende Ausführungsinformationen

Erweiterte Ausführungsdetails

Praktische Decodierungsmuster

Vollständiges Beispiel: Decoder für Jupiter-Swaps

Das Wichtigste

​Ein Live-stream ohne Decodierung

​Binärdaten decodieren

​Die Transaktionsstruktur verstehen

​Der Vorschlag: alles innerhalb von message

​Transaktions-Header

​Wörterbuch der Kontoschlüssel

​Schutz vor Wiederholung

​Anweisungen: die eigentlichen Befehle

​Signaturen: Autorisierungsnachweis

​Nachschlagen in Adresstabellen

​Transaktion v1: Compute-Budget im Header

​So hängt alles zusammen: der Ablauf

​Die Ausführung: alles innerhalb von meta

​Grundlegende Ausführungsinformationen

​Erweiterte Ausführungsdetails

​Praktische Decodierungsmuster

​Vollständiges Beispiel: Decoder für Jupiter-Swaps

​Das Wichtigste

Ein Live-stream ohne Decodierung

Binärdaten decodieren

Die Transaktionsstruktur verstehen

Der Vorschlag: alles innerhalb von message

Transaktions-Header

Wörterbuch der Kontoschlüssel

Schutz vor Wiederholung

Anweisungen: die eigentlichen Befehle

Signaturen: Autorisierungsnachweis

Nachschlagen in Adresstabellen

Transaktion v1: Compute-Budget im Header

So hängt alles zusammen: der Ablauf

Die Ausführung: alles innerhalb von meta

Grundlegende Ausführungsinformationen

Erweiterte Ausführungsdetails

Praktische Decodierungsmuster

Vollständiges Beispiel: Decoder für Jupiter-Swaps

Das Wichtigste