eth_getTransactionByHash - TRON RPC Method

Returns the information about a transaction by transaction hash on TRON.

Why TRON? Build on the TVM-compatible Layer 1 for TRC-20 payments, wallet APIs, and low-cost smart contract execution with TVM compatibility paired with native TRON wallet APIs, DPoS block production, and low-cost transaction flows.

When to Use This Method

eth_getTransactionByHash is essential for TRON developers building payment rails, exchanges, and consumer crypto applications:

• Track pending and confirmed transaction status: Monitor the full lifecycle of a transaction from submission through finalization on TRON
• Verify transaction parameters: Confirm the value, gas, and input data match your intent for TRC-20 transfers, wallet operations, and EVM-compatible smart contract integrations
• Wallet transaction history display: Show detailed transaction records with sender, receiver, value, and status for end users
• Debug failed transactions: Inspect raw transaction data to diagnose reverted calls and unexpected behavior on the TVM-compatible Layer 1 for TRC-20 payments, wallet APIs, and low-cost smart contract execution

Common Use Cases

1. Wait for Transaction Confirmation with Polling

Poll eth_getTransactionByHash until the transaction's blockNumber becomes non-null, indicating it has been mined on TRON. This is the standard pattern for tracking transaction finality.

import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider('https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/jsonrpc');

async function waitForConfirmation(txHash, interval = 2000) {
  while (true) {
    const tx = await provider.getTransaction(txHash);

    if (tx && tx.blockNumber) {
      console.log(`Transaction confirmed in block #${tx.blockNumber}`);
      return tx;
    }

    console.log('Transaction pending, waiting...');
    await new Promise(r => setTimeout(r, interval));
  }
}

waitForConfirmation('0xdcfaa73d566d819ff95b8a9ae944e34c011fb16dd55bce7830a80016c54acf71');

2. Display Transaction Details in a Wallet UI

Fetch and format transaction data for display in a wallet or explorer on TRON. Extract the key fields: sender, recipient, value, gas, and confirmation status.

from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/jsonrpc'))

def get_transaction_details(tx_hash):
    tx = w3.eth.get_transaction(tx_hash)

    if not tx:
        return {'status': 'not found'}

    return {
        'hash': tx['hash'].hex(),
        'from': tx['from'],
        'to': tx['to'],
        'value_ether': w3.from_wei(tx['value'], 'ether'),
        'gas': tx['gas'],
        'gas_price_gwei': w3.from_wei(tx['gasPrice'], 'gwei'),
        'block': tx.get('blockNumber'),
        'confirmed': tx.get('blockNumber') is not None,
    }

details = get_transaction_details('0xdcfaa73d566d819ff95b8a9ae944e34c011fb16dd55bce7830a80016c54acf71')
for key, value in details.items():
    print(f'{key}: {value}')

3. Decode Transaction Input Data for Contract Interaction Analysis

When a transaction's input field contains encoded function calls, decode it using a contract ABI to understand what action was performed on the TVM-compatible Layer 1 for TRC-20 payments, wallet APIs, and low-cost smart contract execution.

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    client, _ := ethclient.Dial("https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/jsonrpc")

    txHash := common.HexToHash("0xdcfaa73d566d819ff95b8a9ae944e34c011fb16dd55bce7830a80016c54acf71")
    tx, isPending, _ := client.TransactionByHash(context.Background(), txHash)

    fmt.Printf("Pending: %v\n", isPending)
    fmt.Printf("From: %s\n", tx.From().Hex())
    fmt.Printf("Value: %s wei\n", tx.Value().String())
    fmt.Printf("Gas limit: %d\n", tx.Gas())

    if len(tx.Data()) > 0 {
        // First 4 bytes are the function selector
        selector := tx.Data()[:4]
        fmt.Printf("Function selector: 0x%x\n", selector)
        fmt.Printf("Input data length: %d bytes\n", len(tx.Data()))
    }
}

Sample Freshness

Use a recent transaction hash when you test this method in your own environment. If the transaction is no longer available on the node you are querying, TRON can return null, so replace placeholders with a fresh transaction hash whenever you re-run the examples.

Best Practices

• Check if blockNumber is null to detect pending transactions: A null blockNumber indicates the transaction has been submitted but not yet mined; use this to drive polling or loading states in your UI
• For mined transactions, cross-reference with receipt for confirmation count: Once a block number is available, use eth_getTransactionReceipt to get the final status, gas used, and emitted logs
• Cache confirmed transaction data indefinitely: Transaction data is immutable once mined; cache it permanently to avoid redundant RPC calls for historical lookups
• Use eth_getTransactionReceipt for post-confirmation data: After a transaction is confirmed, call eth_getTransactionReceipt to get gas used, logs, status code, and effective gas price

Code Examples

Error Handling

Related Methods

• eth_getTransactionReceipt - Get transaction receipt
• eth_sendRawTransaction - Send transaction