Get raw transaction from hash

Question

I wonder if there is an equivalent to bitcoind's getrawtransaction, i.e., a command to dump a raw transaction in hex format, given its hash id.

I am working preferably in geth.

Answer 1

There is eth.getRawTransaction(<txhash>) now.

Edit: Please check that you're using an up-to-date version of geth. It's part of the current release (v.1.8.6) and was introduced some time ago. You can also see it in the source code: https://github.com/ethereum/go-ethereum/blob/ca64a122d33008c155c35a9d0e78cfbcafb1820a/internal/web3ext/web3ext.go (look for getRawTransaction)
https://github.com/ethereum/go-ethereum/blob/ec8ee611caefb5c5ad5d796178e94c1919260df4/internal/ethapi/api.go (look for GetRawTransactionByHash)

input: transaction hash
output: bytes of the corresponding transaction

Answer 2

There is an "undocumented" method eth_getRawTransactionByHash from JSON-RPC

curl -H "Content-Type: application/json" -X POST --data \
'{"jsonrpc":"2.0","method":"eth_getRawTransactionByHash","params":["<TX_HASH>"],"id":1}' http://localhost:8545

<TX_HASH> - transaction id

Answer 3

Have a look at getTransactionByHash() of the JSON-RPC API.

eth_getTransactionByHash

Returns the information about a transaction requested by transaction hash.

Parameters

DATA, 32 Bytes - hash of a transaction
params: [
   "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
]
Returns

Object - A transaction object, or null when no transaction was found:

hash: DATA, 32 Bytes - hash of the transaction.
nonce: QUANTITY - the number of transactions made by the sender prior to this one.
blockHash: DATA, 32 Bytes - hash of the block where this transaction was in. null when its pending.
blockNumber: QUANTITY - block number where this transaction was in. null when its pending.
transactionIndex: QUANTITY - integer of the transactions index position in the block. null when its pending.
from: DATA, 20 Bytes - address of the sender.
to: DATA, 20 Bytes - address of the receiver. null when its a contract creation transaction.
value: QUANTITY - value transferred in Wei.
gasPrice: QUANTITY - gas price provided by the sender in Wei.
gas: QUANTITY - gas provided by the sender.
input: DATA - the data send along with the transact

Answer 4

You can do it this way in Python:

import web3
from eth_account._utils.legacy_transactions import (
    encode_transaction,
    serializable_unsigned_transaction_from_dict,
)
w3 = web3.Web3(web3.HTTPProvider("https://eth-mainnet.alchemyapi.io/v2/XXXXXXXXXXXXXXXXXXXXXXXXXXX"))
hash = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
tx = w3.eth.getTransaction(hash)
def recover_raw_transaction(tx):
    """Recover raw transaction for replay.
Inspired by: https://github.com/ethereum/eth-account/blob/1d26f44f6075d6f283aeaeff879f4508c9a228dc/eth_account/_utils/signing.py#L28-L42
"""
transaction = {
    "chainId": tx["chainId"],
    "nonce": int(tx["nonce"], 16),
    "maxPriorityFeePerGas": int(tx["maxPriorityFeePerGas"], 16),
    "maxFeePerGas": int(tx["maxFeePerGas"], 16),
    "gas": int(tx["gas"], 16),
    "to": Web3.toChecksumAddress(tx["to"].lower()),
    "value": int(tx["value"], 16),
    "accessList": tx["accessList"],
}
if "data" in tx:
    transaction["data"] = tx["data"]
if "input" in tx:
    transaction["data"] = tx["input"]

v = int(tx["v"], 16)
r = int(tx["r"], 16)
s = int(tx["s"], 16)
unsigned_transaction = serializable_unsigned_transaction_from_dict(transaction)
return "0x" + encode_transaction(unsigned_transaction, vrs=(v, r, s)).hex()


raw_tx = recover_raw_transaction(tx)

If some basic fields like access_list are missing when you retried the tx by hash, add them manually.

Answer 5

You can also find the raw transaction hex on etherscan.io by going to a transaction, picking Tools & Utilities and choosing Get Raw TxHash. See for example:

https://etherscan.io/getRawTx?tx=0x248b16e4cb8a624ab4bb3125a3a2cf6bd6d21200b773e3d9c1f0738b1b09dd22

If you want to do this programatically with geth, I present a solution for that here: Can I get the raw transaction using Nethereum?

Answer 6

The node I'm consuming doesn't support eth_getTransactionByHash So similarly to Nikolay answer, this is how I did it using ethers.js v5 (and TypeScript) instead of web3.py

import { Transaction } from "@ethersproject/transactions";
/**

Serializes a transaction object into a raw transaction string.
This function takes a Transaction object, ensures it is fully signed,
constructs the unsigned transaction object, and then serializes it with the signature.
It also verifies the serialization process by comparing the computed transaction hash
with the original transaction hash.

@param {Transaction} transaction - The transaction object from Ethers.js.
@returns {string} The serialized raw transaction.

*/
const transactionToRawTransaction = (
  transaction: TransactionResponse,
): string => {
  const type0Fields = { gasPrice: transaction.gasPrice };
  const type1Fields = { ...type0Fields, accessList: transaction.accessList };
  const type2Fields = {
    accessList: transaction.accessList,
    maxFeePerGas: transaction.maxFeePerGas,
    maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
  };
  const typeFileds = [type0Fields, type1Fields, type2Fields];
  const extraFields = typeFileds[transaction.type ?? 0];
  const unsignedTx = {
    chainId: transaction.chainId,
    data: transaction.data,
    gasLimit: transaction.gasLimit,
    nonce: transaction.nonce,
    to: transaction.to,
    type: transaction.type,
    value: transaction.value,
    ...extraFields,
  };
  assert.ok(transaction.r);
  const signature = {
    r: transaction.r,
    s: transaction.s,
    v: transaction.v,
  };
  const serialized = ethers.utils.serializeTransaction(unsignedTx, signature);
  // double check things went well
  assert.strictEqual(ethers.utils.keccak256(serialized), transaction.hash);
  return serialized;
};
/**

Fetches a transaction from the blockchain using its hash and serializes it into a raw transaction string.
This function retrieves the transaction details using the provided hash, ensuring the transaction exists,
and then utilizes transactionToRawTransaction to serialize the transaction.
This is useful if we want to replay a raw transaction in local or in the tests.

@param {Provider} provider - The Ethers.js provider instance to interact with the blockchain.
@param {string} hash - The hash of the transaction to fetch and serialize.
@returns {Promise<string>} A promise that resolves to the serialized raw transaction string.

*/
const transactionHashToRawTransaction = async (
  provider: Provider,
  hash: string,
): Promise<string> => {
  const transaction = await provider.getTransaction(hash);
  const serialized = transactionToRawTransaction(transaction);
  return serialized;
};

It's much easier with Ethers v6 is much easier since the ethers.Transaction object has a serialized attribute.

import { TransactionResponseParams } from "ethers";
const transactionToRawTransaction = (
  transaction: TransactionResponseParams,
): string => {
  const serialized = Transaction.from(transaction).serialized;
  // double check things went well
  assert.strictEqual(keccak256(serialized), transaction.hash);
  return serialized;
};