A block explorer transaction page is dense. Hashes, hex strings, tabs, gas numbers. Most people glance at the green "Success" badge and close the tab. But the page is also the best tool you have for understanding what a transaction actually did, whether it's yours, one you're about to sign, or one that drained a wallet.
In this post I'll go through each part of the page in the order that's useful, then show a small ethers v6 script that does the decoding by hand, so you can see where the readable text comes from. I decoded a test transaction on a simulated network; I haven't decoded a live mainnet one for this post.
The overview: who, what, how much
The top section answers the basic questions:
- Status. Success or failed. A failed transaction is still recorded and still costs gas, because the network did the work of trying.
- Block and timestamp. When it was included, and how many confirmations have followed.
- From. The account that signed and sent it. This is always a wallet (an externally owned account), never a contract.
- To. The recipient: another wallet, or a contract. If it's a contract and the explorer knows its name, you'll see it.
- Value. The amount of native currency (ETH on Ethereum) sent along. Note that for a token transfer this is usually zero, because the token amount is inside the input data, not in Value.
- Transaction fee and gas. Gas used times the gas price. The price is quoted in gwei, a billionth of an ETH.
One trap here: "Value: 0 ETH" does not mean "nothing moved". A token transfer, an approval, a swap and a contract call can all carry zero ETH and still move a lot of value. The rest of the page is where you find out.
Input data: what was asked
When a transaction calls a contract, the call is encoded as hex in the input data. The first four bytes, written as 8 hex digits after 0x, are the selector (Etherscan labels it "Method ID"): a fingerprint of the function name and its parameter types. The rest are the arguments, each padded to 32 bytes.
For example, an ERC-20 transfer(address,uint256) always has selector 0xa9059cbb, which my decoder confirmed below. If the contract is verified, the explorer knows the ABI (the contract's interface) and shows the function name and each argument. Etherscan's pages also offer a "Decode Input Data" view for this. If the contract is not verified, you only get raw hex, which is another reason to treat unverified contracts with suspicion.
What to look for: does the function match what you thought you were doing? Is the recipient who you expect? Is the amount right, and in the token's smallest units? An amount of 1500000000000000000 for an 18-decimal token is 1.5 tokens.
Logs: what actually happened
Input data says what was requested. Logs (also called events) say what the contract reported doing. Contracts emit events such as ERC-20's Transfer(from, to, value) and Approval(owner, spender, value), and they are stored in the transaction receipt. Each log has the emitting contract's address, "topics" (the event's fingerprint plus indexed arguments) and data (the remaining arguments).
The Logs tab decodes them when it can. For a complex transaction, such as a swap, the input might show a router call, but the logs show every token transfer that resulted. Logs are the easiest way to see the full list of tokens that moved. A word of caution: logs are produced by contract code, so a dishonest contract could emit misleading events. Treat them as strong evidence for well-known contracts, not as proof for unknown ones.
Internal transactions: contracts calling contracts
When a contract sends ETH, or calls another contract, as part of running your transaction, that's an internal transaction. They are not separate transactions on the chain; the explorer reconstructs them by tracing execution. They matter because the top-level transaction might show "you sent 1 ETH to a router", while internal transactions show where that ETH went next. If you ever wonder why a transaction touched a contract you never heard of, look here.
The decoder script
To understand where the readable version comes from, here is a short function that does it with ethers v6. It takes a transaction, its receipt and the contract's ABI. The Interface class matches the selector to a function and decodes the arguments, then does the same for each log:
decodeTx.ts
import { Interface, type TransactionReceipt, type TransactionResponse } from "ethers";
/// Turn raw "Input Data" and "Logs" (what Etherscan shows as hex) into readable text,
/// using the contract's ABI. On Etherscan the ABI comes from the verified source code.
export function describeTransaction(tx: Pick<TransactionResponse, "data" | "to" | "from" | "value">, receipt: TransactionReceipt, abi: any[]) {
const iface = new Interface(abi);
const call = iface.parseTransaction({ data: tx.data, value: tx.value });
const events = receipt.logs.map((log) => {
const parsed = iface.parseLog({ topics: [...log.topics], data: log.data });
return parsed ? { name: parsed.name, args: Object.fromEntries(parsed.fragment.inputs.map((i, n) => [i.name, String(parsed.args[n])])) } : null;
}).filter(Boolean);
return {
from: tx.from,
to: tx.to,
valueWei: tx.value.toString(),
method: call?.name,
methodArgs: call ? Object.fromEntries(call.fragment.inputs.map((i, n) => [i.name, String(call.args[n])])) : null,
selector: tx.data.slice(0, 10),
status: receipt.status === 1 ? "success" : "failed",
gasUsed: receipt.gasUsed.toString(),
events,
};
}
And a test that sends a token transfer on the simulated network, then decodes it from only the raw data and the ABI:
DecodeTx.ts
import { expect } from "chai";
import { network, artifacts } from "hardhat";
import { describeTransaction } from "../lib/decodeTx.js";
const { ethers } = await network.create();
describe("decodeTx", function () {
it("explains an ERC-20 transfer from raw input data and logs", async function () {
const [owner, alice] = await ethers.getSigners();
const token = await ethers.deployContract("TeamToken", [owner.address, ethers.parseEther("1000")]);
await token.mint(owner.address, ethers.parseEther("10"));
const sent = await token.transfer(alice.address, ethers.parseEther("1.5"));
const receipt = (await sent.wait())!;
const tx = (await ethers.provider.getTransaction(sent.hash))!;
const abi = (await artifacts.readArtifact("TeamToken")).abi;
const d = describeTransaction(tx, receipt, abi);
console.log(JSON.stringify(d, null, 2));
expect(d.selector).to.equal("0xa9059cbb"); // transfer(address,uint256)
expect(d.method).to.equal("transfer");
expect(d.methodArgs).to.deep.equal({ to: alice.address, value: ethers.parseEther("1.5").toString() });
expect(d.events[0]!.name).to.equal("Transfer");
expect(d.status).to.equal("success");
});
});
The test passed, and printed this decoded view of the transaction:
{
"method": "transfer",
"selector": "0xa9059cbb",
"methodArgs": {
"to": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
"value": "1500000000000000000"
},
"status": "success",
"gasUsed": "52267",
"events": [
{ "name": "Transfer", "args": { "from": "0xf39F...2266", "to": "0x7099...79C8", "value": "1500000000000000000" } }
]
}
Notice how the same information appears in two places: the input data said "transfer 1.5 tokens to this address", and the log confirmed that a Transfer event with those values was emitted. When these disagree, something interesting, or something malicious, is going on.
Reading a transaction in practice: a short routine
- Check the status and the "To" address. Is the contract the one you expected? Is it verified?
- Read the decoded function and arguments. Does the function name match your intent? Is it
approveorsetApprovalForAllwhen you expected a transfer? - Check the amounts against the token's decimals.
- Open the Logs. List which tokens moved, between whom. Does it match the story?
- Open the internal transactions if ETH moved or if the transaction touched unfamiliar contracts.
- Check fees. A simple transfer of the native coin uses 21,000 gas. Compare the gas used to what you'd expect for the operation.
What explorers can't tell you
- Intent. Decoding tells you what the call does mechanically, not whether it's a good idea. An
approvedecoded perfectly can still be the approval that empties your wallet; the token approvals post covers it. - Labels aren't verification. A friendly name tag on an address is a convenience from the explorer, not a guarantee of trustworthiness.
- Unverified contracts. Without the ABI you get hex. The explorer may guess the function name from a public signature database, but a guess is not decoding.
- Other chains differ. The tabs and terms are similar on explorers for other EVM chains, but details differ, so read each chain's own help pages.
Short checklist
- Status, From, To, Value, then fees.
- Input data for the request: selector, function, arguments.
- Logs for what the contract reports it did.
- Internal transactions for where ETH went next.
- Cross-check them: they should tell the same story.
Building tools around on-chain data?
I build dashboards, decoders and monitoring for contracts and wallets. If you have a data or tooling problem, get in touch.
See services Get in touchWhat I ran this against
- Hardhat 3.22.0 (Mocha + ethers template), @openzeppelin/contracts 5.6.1, ethers 6.17.0, solc 0.8.34, Node.js 24.22.1, run on 17 November 2026 on Hardhat's in-process simulated network. The decoder was tested against a transaction on the simulated network. One test passes: it decodes an ERC-20
transferfrom its raw input data and event log. - I did not decode a live mainnet transaction. The layout of Etherscan's page is described from its public pages and the sources below, which I read on 17 November 2026; the site's design changes.
- This is education, not financial or security advice. I'm a developer describing how these tools work; I can't see your situation, and you remain responsible for what you sign.
Sources checked
- Etherscan transaction pages (the Overview, Internal Txns, Logs and State tabs, the Input Data section with function name and Method ID, and the "Decode Input Data" option) viewed through public example transactions: for instance a public batch-deposit transaction.
- EIP-20, ERC-20 Token Standard (
transfer(address,uint256),transferFrom,approveand theTransferandApprovalevents): eips.ethereum.org/EIPS/eip-20. - ethers v6 documentation,
Interface(parsing transactions and logs with an ABI): docs.ethers.org/v6/api/abi.