description: Tutorial on how to query transactions on the blockchain with Go.

Querying Transactions

In the previous section we learned how to read a block and all its data given the block number. We can read the transactions in a block by calling the Transactions method which returns a list of Transaction type. It’s then trivial to iterate over the collection and retrieve any information regarding the transaction.

  1. for _, tx := range block.Transactions() {
  2.   fmt.Println(tx.Hash().Hex())        // 0x5d49fcaa394c97ec8a9c3e7bd9e8388d420fb050a52083ca52ff24b3b65bc9c2
  3.   fmt.Println(tx.Value().String())    // 10000000000000000
  4.   fmt.Println(tx.Gas())               // 105000
  5.   fmt.Println(tx.GasPrice().Uint64()) // 102000000000
  6.   fmt.Println(tx.Nonce())             // 110644
  7.   fmt.Println(tx.Data())              // []
  8.   fmt.Println(tx.To().Hex())          // 0x55fE59D8Ad77035154dDd0AD0388D09Dd4047A8e
  9. }

In order to read the sender address, we need to call AsMessage on the transaction which returns a Message type containing a function to return the sender (from) address. The AsMessage method requires the EIP155 signer, which we derive the chain ID from the client.

  1. chainID, err := client.NetworkID(context.Background())
  2. if err != nil {
  3.   log.Fatal(err)
  4. }
  6. if msg, err := tx.AsMessage(types.NewEIP155Signer(chainID)); err == nil {
  7.   fmt.Println(msg.From().Hex()) // 0x0fD081e3Bb178dc45c0cb23202069ddA57064258
  8. }

Each transaction has a receipt which contains the result of the execution of the transaction, such as any return values and logs, as well as the status which will be 1 (success) or 0 (fail).

  1. receipt, err := client.TransactionReceipt(context.Background(), tx.Hash())
  2. if err != nil {
  3.   log.Fatal(err)
  4. }
  6. fmt.Println(receipt.Status) // 1
  7. fmt.Println(receipt.Logs) // ...

Another way to iterate over transaction without fetching the block is to call the client’s TransactionInBlock method. This method accepts only the block hash and the index of the transaction within the block. You can call TransactionCount to know how many transactions there are in the block.

  1. blockHash := common.HexToHash("0x9e8751ebb5069389b855bba72d94902cc385042661498a415979b7b6ee9ba4b9")
  2. count, err := client.TransactionCount(context.Background(), blockHash)
  3. if err != nil {
  4.   log.Fatal(err)
  5. }
  7. for idx := uint(0); idx < count; idx++ {
  8.   tx, err := client.TransactionInBlock(context.Background(), blockHash, idx)
  9.   if err != nil {
  10.     log.Fatal(err)
  11.   }
  13.   fmt.Println(tx.Hash().Hex()) // 0x5d49fcaa394c97ec8a9c3e7bd9e8388d420fb050a52083ca52ff24b3b65bc9c2
  14. }

You can also query for a single transaction directly given the transaction hash by using TransactionByHash.

  1. txHash := common.HexToHash("0x5d49fcaa394c97ec8a9c3e7bd9e8388d420fb050a52083ca52ff24b3b65bc9c2")
  2. tx, isPending, err := client.TransactionByHash(context.Background(), txHash)
  3. if err != nil {
  4.   log.Fatal(err)
  5. }
  7. fmt.Println(tx.Hash().Hex()) // 0x5d49fcaa394c97ec8a9c3e7bd9e8388d420fb050a52083ca52ff24b3b65bc9c2
  8. fmt.Println(isPending)       // false

Full code

transactions.go

  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  6.     "log"
  7.     "math/big"
  9.     "github.com/ethereum/go-ethereum/common"
  10.     "github.com/ethereum/go-ethereum/core/types"
  11.     "github.com/ethereum/go-ethereum/ethclient"
  12. )
  14. func main() {
  15.     client, err := ethclient.Dial("https://mainnet.infura.io")
  16.     if err != nil {
  17.         log.Fatal(err)
  18.     }
  20.     blockNumber := big.NewInt(5671744)
  21.     block, err := client.BlockByNumber(context.Background(), blockNumber)
  22.     if err != nil {
  23.         log.Fatal(err)
  24.     }
  26.     for _, tx := range block.Transactions() {
  27.         fmt.Println(tx.Hash().Hex())        // 0x5d49fcaa394c97ec8a9c3e7bd9e8388d420fb050a52083ca52ff24b3b65bc9c2
  28.         fmt.Println(tx.Value().String())    // 10000000000000000
  29.         fmt.Println(tx.Gas())               // 105000
  30.         fmt.Println(tx.GasPrice().Uint64()) // 102000000000
  31.         fmt.Println(tx.Nonce())             // 110644
  32.         fmt.Println(tx.Data())              // []
  33.         fmt.Println(tx.To().Hex())          // 0x55fE59D8Ad77035154dDd0AD0388D09Dd4047A8e
  35.         chainID, err := client.NetworkID(context.Background())
  36.         if err != nil {
  37.             log.Fatal(err)
  38.         }
  40.         if msg, err := tx.AsMessage(types.NewEIP155Signer(chainID)); err == nil {
  41.             fmt.Println(msg.From().Hex()) // 0x0fD081e3Bb178dc45c0cb23202069ddA57064258
  42.         }
  44.         receipt, err := client.TransactionReceipt(context.Background(), tx.Hash())
  45.         if err != nil {
  46.             log.Fatal(err)
  47.         }
  49.         fmt.Println(receipt.Status) // 1
  50.     }
  52.     blockHash := common.HexToHash("0x9e8751ebb5069389b855bba72d94902cc385042661498a415979b7b6ee9ba4b9")
  53.     count, err := client.TransactionCount(context.Background(), blockHash)
  54.     if err != nil {
  55.         log.Fatal(err)
  56.     }
  58.     for idx := uint(0); idx < count; idx++ {
  59.         tx, err := client.TransactionInBlock(context.Background(), blockHash, idx)
  60.         if err != nil {
  61.             log.Fatal(err)
  62.         }
  64.         fmt.Println(tx.Hash().Hex()) // 0x5d49fcaa394c97ec8a9c3e7bd9e8388d420fb050a52083ca52ff24b3b65bc9c2
  65.     }
  67.     txHash := common.HexToHash("0x5d49fcaa394c97ec8a9c3e7bd9e8388d420fb050a52083ca52ff24b3b65bc9c2")
  68.     tx, isPending, err := client.TransactionByHash(context.Background(), txHash)
  69.     if err != nil {
  70.         log.Fatal(err)
  71.     }
  73.     fmt.Println(tx.Hash().Hex()) // 0x5d49fcaa394c97ec8a9c3e7bd9e8388d420fb050a52083ca52ff24b3b65bc9c2
  74.     fmt.Println(isPending)       // false
  75. }