One Ethereum transaction can fill several explorer tabs. Those rows describe different parts of the same execution; counting them as separate payments can count the same action twice.
For readers comparing Ethereum internal transactions and logs, the useful question is what each record establishes. Start with the submitted instruction, then separate its receipt, emitted events and reconstructed call tree. Our transaction-reading guide covers the initial lookup. Here we follow one fictional contract interaction across the different views.
Four records, four questions
Ethereum's transaction documentation describes the signed instruction: sender, destination, native ETH value and input data. A contract destination can be an intermediary rather than the eventual token recipient.
| Record | Useful question | Limit |
|---|---|---|
| Transaction | What instruction did the sender submit? | Its destination is not necessarily the final token recipient |
| Receipt | Was this transaction included, and did top-level execution succeed? | Success does not certify every intended outcome |
| Event log | What event data did the emitting contract record? | A decoded event name does not identify a trustworthy asset |
| Call trace | Which nested calls ran, with what inputs and outcomes? | A trace is not a second set of signed transactions |
The JSON-RPC receipt reference exposes status, individual gasUsed, effectiveGasPrice and logs. A pending transaction has no included-transaction receipt. A call tree is not a field in that standard receipt response.
Logs record events, not every execution step
Solidity's event documentation explains that logs are associated with the emitting contract. Indexed parameters go into topics; other event arguments go into the data field. Decoding requires the relevant event layout, commonly described by its ABI, or application binary interface.
For the conventional non-anonymous ERC-20 Transfer event, the signature identifies the event shape, indexed parameters identify the token sender and recipient, and the remaining value is the raw token quantity. That quantity is not a native ETH transfer. Apply the particular token's units before displaying it.
Read the emitting contract address alongside the decoded label. Another contract can emit similar-looking data. A familiar event name is not proof of token identity, honest accounting or an exchange deposit. Our token-identity guide keeps contract and network separate from the ticker.
Internal transactions are an explorer view of calls
Etherscan's transaction guide uses Internal Transaction for ETH transferred through a contract intermediary. That describes its presentation, not a separate signed transaction format. The guide also contains historical mining and throughput discussion; those sections are not current Ethereum guidance and are not used here.
Solidity's call documentation distinguishes a contract-to-contract message call from a new transaction. Geth's callTracer reconstructs nested call frames, including the outer call. It reports call type, addresses, inputs, output and errors. Its supported frame types include CALL, STATICCALL and DELEGATECALL.
A call can carry zero ETH and still execute token logic. A delegated call executes another contract's code in a different context; do not sum every displayed value field as an independent ETH payment. The explorer's internal-transfer list and the full call tree need not contain identical rows.
Follow one fictional token transfer
Assume an ordinary, non-delegated sender A calls router R on Ethereum mainnet. R calls token contract T's transferFrom to move 25 T from A to B. Assume sufficient allowance and balance, successful conventional token behavior, no transfer charge and no other calls or token movements. T uses six decimals in this invented example.
These labels are not real addresses. There is no transaction hash, explorer capture or deployed example contract. All receipt and execution values below are assumed teaching inputs.
| View | Assumed observation | Interpretation |
|---|---|---|
| Transaction | A calls R; native value is 0 ETH | R receives the instruction, not 25 ETH |
| Nested call | R calls T with native value 0 ETH | Token logic can run without an ETH transfer |
| Receipt | Status 1; one token event | Top-level execution succeeded under the assumptions |
| Token log | Emitter T; Transfer(A, B, 25000000) | 25,000,000 raw units represent 25 T at six decimals |
| Trace | Outer A → R, then child R → T | Two call frames belong to one signed transaction |
The token log's from is A; the child call's from is R. Those fields answer different questions: whose token balance changes, and which address calls the token contract. They can differ without a contradiction.
The same 25-T transfer appearing in a decoded token list and in the receipt's logs is one token movement, not 50 T. In this example, neither call forwards ETH. Native ETH still pays for execution: if the final receipt reports 70,000 gas at 10 gwei per gas, the execution fee is 70,000 × 10 = 700,000 gwei = 0.0007 ETH.
That fee is separate from the 25 T. The figures do not predict any real router's gas usage. For actual fee reconciliation, use the individual receipt rather than adding gas figures from parent and child trace frames; see gas limit versus gas price.
Errors and missing rows need context
EIP-140 specifies rollback on REVERT, including discarded logs. If our fictional transaction instead reverts at top level, its attempted token movement and logs do not persist as the successful outcome shown above. A trace may still explain the attempted path. Reading an attempted call as a settled transfer would miss the rollback.
A caller can also handle a child failure and continue, as Solidity's exception rules describe. An error in a child frame is therefore not automatically receipt status 0. Our reverted-transaction explainer covers the separate fee consequences.
Geth's basic-trace documentation describes opcode traces and their processing cost. These detailed execution records differ from event logs despite the name structLogs. Client settings and provider support matter: onlyTopCall, for example, deliberately omits child frames in Geth's call tracer. An empty or unavailable trace view does not prove there were no internal calls.
Compare the same execution before drawing a conclusion
Keep the network, complete transaction hash, containing block and observation time together. Compare the receipt status with the exact emitting token contract, decoded arguments and units. For a trace, record the client or provider, tracer settings and any errors or omitted details.
If the views disagree, establish whether they describe the same record and the same scope. Do not add token events to ETH transfers, treat duplicate presentations as extra funds or interpret missing provider data as zero activity. Public transaction reading requires no recovery phrase or rescue signature.
Sources
Primary documentation checked October 29, 2026, Asia/Tbilisi. The account labels, router, token, amounts, receipt and illustration are fictional. No RPC request, node tracing, wallet connection, signature, token transfer or contract audit was performed. Geth behavior is implementation-specific; the cited Solidity pages identify a development documentation version. No explorer interface or receiving-service credit was tested.
- Ethereum.org: Transactions — submitted instruction and native-value fields.
- Ethereum.org: JSON-RPC API — receipt, gas and log fields; pending boundary.
- ERC-20: Token Standard — transfer event, allowance and token units.
- Geth: Built-in tracers — call frames, call types and configuration.
- Solidity: Calls and exception handling — message calls and handled child failures.
- Solidity: Events — emitter, topics, event layout and decoding limits.
- Etherscan: Understanding an Ethereum Transaction — its internal-transfer terminology only; historical lifecycle claims excluded.
- Geth: Basic traces — opcode traces and resource limits.
- EIP-140: REVERT — rollback and discarded execution logs.
See something wrong? Brokzi logs material changes. Prepare a correction note.




