getTransaction verwenden

​

Häufige Anwendungsfälle

• Transaktionsprüfung: Bestätigen, dass eine Transaktion verarbeitet wurde, und ihr Ergebnis prüfen (Erfolg oder Fehlschlag).
• Anzeige des Transaktionsverlaufs: Nutzern in einer Wallet oder einem Explorer Details zu ihren vergangenen Transaktionen anzeigen.
• Prüfung und Analyse: Einzelheiten einer Transaktion untersuchen, darunter ausgeführte Anweisungen, gezahlte Gebühren und beteiligte Konten.
• Fehlgeschlagene Transaktionen debuggen: Die Felder logMessages und err in den Metadaten untersuchen, um die Ursache eines Transaktionsfehlers zu ermitteln.
• Datenindexierung: Bestimmte Informationen aus Transaktionen für die Off-Chain-Speicherung und Analyse extrahieren.

​

Parameter des request

1. transactionSignature (string, erforderlich): Die Base58-codierte Signatur der Transaktion, die du abfragen möchtest.
2. options (object, optional): Ein optionales Konfigurationsobjekt, das Folgendes enthalten kann:
   • commitment (string, optional): Legt das commitment-Level fest (z. B. "finalized", "confirmed"). Ohne Angabe wird das standardmäßige commitment des node verwendet (normalerweise "finalized").
   • encoding (string, optional): Die Codierung für die Daten in transaction. Häufige Werte:
     • "json": Gibt die Transaktionsdaten in einem strukturierten JSON-Format zurück. Anweisungen können jedoch weiterhin Base64-codiert sein.
     • "jsonParsed": Gibt die Transaktionsdaten zurück und parst nach Möglichkeit programmspezifische Anweisungen in eine menschenlesbare JSON-Struktur. Diese Codierung ist für Analysen oft am nützlichsten.
     • "base58": Gibt die Transaktionsdaten als Base58-codierten string zurück.
     • "base64": Gibt die Transaktionsdaten als Base64-codierten string zurück.
     • Wenn Helius keinen Wert angibt, wird standardmäßig "json" verwendet. Der Standardwert von Solana kann jedoch abweichen. Gib diesen Wert am besten explizit an.
   • maxSupportedTransactionVersion (number, optional): Die maximale Transaktionsversion, die der RPC endpoint verarbeiten soll.
     • Setze den Wert auf 1, um Legacy-, v0- und v1-Transaktionen einzubeziehen.
     • Wenn der Wert fehlt oder niedriger als die Version der Transaktion ist, schlägt der request mit dem JSON-RPC-Fehler -32015 (Transaction version (1) is not supported by the requesting client) fehl. Setze ihn immer auf 1. Siehe Unterstützung für Transaktion v1.

​

Struktur der response

• slot (u64): Die Nummer des slot, in dem die Transaktion in einen Block aufgenommen wurde.
• blockTime (i64 | null): Der geschätzte Unix-Zeitstempel (Sekunden seit Beginn der Unixzeit), zu dem der Block mit der Transaktion erzeugt wurde. Kann null sein, wenn er nicht verfügbar ist.
• meta (object | null): Ein Objekt mit Metadaten zur Ausführung der Transaktion. Kann null sein, wenn die Transaktion vor der Verarbeitung fehlgeschlagen ist oder keine Metadaten verfügbar sind.
  • err (object | null): Ein Fehlerobjekt, wenn die Transaktion fehlgeschlagen ist, andernfalls null.
  • fee (u64): Die für die Transaktion gezahlte Gebühr in Lamports.
  • preBalances (array of u64): Lamport-Kontostände der beteiligten Konten vor der Verarbeitung der Transaktion.
  • postBalances (array of u64): Lamport-Kontostände der beteiligten Konten nach der Verarbeitung der Transaktion.
  • preTokenBalances (array of objects | null): Token-Kontostände der beteiligten Token-Konten vor der Transaktion.
  • postTokenBalances (array of objects | null): Token-Kontostände der beteiligten Token-Konten nach der Transaktion.
  • innerInstructions (array of objects | null): Ein Array mit Anweisungen, die innerhalb dieser Transaktion im Rahmen von CPI (Cross-Program Invocations) ausgeführt wurden.
  • logMessages (array of string | null): Ein Array mit Protokollmeldungen, die von den Anweisungen der Transaktion und allen inneren Anweisungen ausgegeben wurden.
  • loadedAddresses (object, optional): Gibt die Konten an, die für diese Transaktion aus Adress-Lookup-Tabellen geladen wurden. Enthält die Arrays writable und readonly mit öffentlichen Schlüsseln.
  • returnData (object, optional): Daten, die von der Transaktion über sol_set_return_data und sol_get_return_data zurückgegeben wurden. Enthält programId (string) und data (array: [string, encoding]).
  • computeUnitsConsumed (u64, optional): Die Anzahl der von dieser Transaktion verbrauchten Recheneinheiten.
• transaction (object | array): Die Transaktionsstruktur selbst. Das Format hängt vom Parameter encoding ab:
  • Wenn encoding den Wert "jsonParsed" oder "json" hat: Ein Objekt mit message (enthält accountKeys, instructions, recentBlockhash usw.) und signatures (Array von strings).
  • Wenn encoding den Wert "base58" oder "base64" hat: Ein Array [encoded_string, encoding_format_string].
• version (“legacy” | number | undefined): Die Version der Transaktion. Kann für ältere Transaktionen "legacy" oder für versionierte Transaktionen eine Zahl (0 oder 1) sein. undefined, wenn maxSupportedTransactionVersion nicht gesetzt und die Transaktion versioniert ist. Eine v1-Transaktion enthält außerdem ein transactionConfig-Objekt in message mit dem Rechenbudget (computeUnitLimit, heapSize, loadedAccountsDataSizeLimit, priorityFee). Dieses Objekt ersetzt die Anweisungen des ComputeBudget-Programms. priorityFee gibt die Gesamtgebühr in Lamports an, nicht Mikro-Lamports pro Recheneinheit.

{
  "jsonrpc": "2.0",
  "result": {
    "blockTime": 1635900000,
    "meta": {
      "err": null,
      "fee": 5000,
      "innerInstructions": [],
      "logMessages": [
        "Program Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS invoke [1]",
        "Program log: Memo 'Hello, Solana!'",
        "Program Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS success"
      ],
      "postBalances": [
        499999999999994999, 
        1000000000
      ],
      "postTokenBalances": [],
      "preBalances": [
        500000000000000000, 
        1000000000
      ],
      "preTokenBalances": [],
      "rewards": [],
      "status": { "Ok": null },
      "computeUnitsConsumed": 200
    },
    "slot": 98765432,
    "transaction": {
      "message": {
        "accountKeys": [
          "SysvarRent111111111111111111111111111111111",
          "Vote111111111111111111111111111111111111111"
        ],
        "instructions": [
          {
            "parsed": {
              "type": "vote",
              "info": {
                "votePubkey": "Vote111111111111111111111111111111111111111",
                "slot": 123,
                "hash": "abc..."
              }
            },
            "program": "vote",
            "programId": "Vote111111111111111111111111111111111111111"
          }
        ],
        "recentBlockhash": "xyz..."
      },
      "signatures": [
        "sig1..."
      ]
    },
    "version": "legacy"
  },
  "id": 1
}

​

Codebeispiele

# Replace <TRANSACTION_SIGNATURE> with an actual signature
curl -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getTransaction",
    "params": [
      "<TRANSACTION_SIGNATURE>",
      {
        "encoding": "jsonParsed",
        "maxSupportedTransactionVersion": 1
      }
    ]
  }' \
  <YOUR_RPC_URL>

const { Connection } = require('@solana/web3.js');

async function getTransactionDetails(signature) {
  // Replace with your RPC endpoint
  const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');

  try {
    const transaction = await connection.getTransaction(signature, {
      maxSupportedTransactionVersion: 1, // Required for legacy, v0, and v1 transactions
      // commitment: 'confirmed', // Optional: specify commitment level
    });

    if (transaction) {
      console.log('Transaction Details:');
      console.log(`  Slot: ${transaction.slot}`);
      console.log(`  Block Time: ${transaction.blockTime ? new Date(transaction.blockTime * 1000).toLocaleString() : 'N/A'}`);
      console.log(`  Fee: ${transaction.meta ? transaction.meta.fee : 'N/A'} lamports`);
      console.log(`  Status: ${transaction.meta && transaction.meta.err ? 'Failed' : 'Success'}`);
      if (transaction.meta && transaction.meta.err) {
        console.log(`    Error: ${JSON.stringify(transaction.meta.err)}`);
      }
      // console.log(JSON.stringify(transaction, null, 2)); // Log full transaction details

      if (transaction.meta && transaction.meta.logMessages) {
        console.log('  Log Messages:');
        transaction.meta.logMessages.forEach(log => console.log(`    ${log}`));
      }

    } else {
      console.log('Transaction not found or not confirmed.');
    }
  } catch (error) {
    console.error(`Error fetching transaction ${signature}:`, error);
  }
}

// Replace with an actual transaction signature from Mainnet-beta or your test environment
const exampleSignature = '5h4zCwobYsdL3mY26FgfXy8c4rTPkX6gYVXW8w2tTjCXZMWzE9jX9p8Q2Y8Yj9p8ZQ8Yj9p8ZQ8Yj9p8ZQ8Yj9'; // Replace with a real signature
// getTransactionDetails(exampleSignature);

// Example of a known transaction (you'll need to find a recent one on an explorer)
// getTransactionDetails('2xNdnHjZDmJRy1L6jC1mF87K3V9nXZo2bY6vA8GzQ3T7bS9xU8cM7sR5eD3fG2hJ1aB0cE9lK6mN5pP4qR7');

console.log("Please replace 'exampleSignature' with a real transaction signature to run the example.");

​

Tipps für Entwickler

• Finalität der Transaktion: Frage mit einem geeigneten commitment-Level ab. Wenn eine Transaktion das angegebene commitment noch nicht erreicht hat, wird null zurückgegeben.
• Datenmenge: Das response-Objekt kann sehr groß sein, besonders bei komplexen Transaktionen mit vielen Anweisungen oder detaillierter Protokollierung. Berücksichtige dies bei der Verarbeitung der Daten.
• jsonParsed im Vergleich zu json: jsonParsed ist sehr praktisch. Die Parsing-Unterstützung hängt jedoch von den Fähigkeiten des RPC node für bestimmte Programme ab. Wenn ein Programm nicht erkannt wird, werden seine Anweisungen möglicherweise auch mit jsonParsed in einem weniger stark geparsten Format zurückgegeben.
• Versionierte Transaktionen: Setze in den Optionen deines request immer maxSupportedTransactionVersion: 1, damit deine Anwendung sowohl Legacy- als auch versionierte Transaktionen verarbeiten kann. Andernfalls fehlen dir möglicherweise Daten oder bei neueren Transaktionsformaten treten Fehler auf.
• Unterschiede zwischen RPC-Anbietern: Die grundlegende API ist standardisiert. Einige RPC-Anbieter bieten jedoch möglicherweise erweitertes Parsing oder zusätzliche Felder. Helius stellt beispielsweise umfangreiches Transaktions-Parsing bereit.