eth_getTransactionByHash - zkSync RPC Method

Returns the information about a transaction by transaction hash on zkSync Era.

Why zkSync? Build on Matter Labs' flagship zkEVM powering the Elastic Network of interoperable hyperchains with ZK Stack modular framework, hyperchain interoperability, native account abstraction, and $1.9B in tokenized real-world assets.

When to Use This Method

eth_getTransactionByHash is essential for ZK developers, RWA tokenization teams, and builders launching custom L2/L3 chains:

• Track pending and confirmed transaction status: Monitor the full lifecycle of a transaction from submission through finalization on zkSync Era
• Verify transaction parameters: Confirm the value, gas, and input data match your intent for RWA tokenization ($1.9B, 25% market share), hyperchain deployment via ZK Stack, and cross-chain DeFi
• 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 Matter Labs' flagship zkEVM powering the Elastic Network of interoperable hyperchains

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 zkSync Era. This is the standard pattern for tracking transaction finality.

import { JsonRpcProvider } from 'ethers';

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

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('0xc4c7231ab3f1d8feaaf4e2b9933696e37095d0af84cb6cc70f48493b38f3a731');

2. Display Transaction Details in a Wallet UI

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

from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://api-zksync-era-mainnet-full.n.dwellir.com/YOUR_API_KEY'))

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('0xc4c7231ab3f1d8feaaf4e2b9933696e37095d0af84cb6cc70f48493b38f3a731')
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 Matter Labs' flagship zkEVM powering the Elastic Network of interoperable hyperchains.

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-zksync-era-mainnet-full.n.dwellir.com/YOUR_API_KEY")

    txHash := common.HexToHash("0xc4c7231ab3f1d8feaaf4e2b9933696e37095d0af84cb6cc70f48493b38f3a731")
    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()))
    }
}

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