Recommended Free Tools
No. A transaction hash is a lookup key, not an audit trail. It lets you retrieve a transaction from an Ethereum node, and from there you can fetch its receipt, its emitted logs and, on clients that support it, an execution trace. None of those artifacts records why your automation decided to act, which inputs it evaluated, which policy or code version it applied, or whether the outcome you intended is the outcome you got. An auditable onchain automation needs the chain evidence the hash leads to, joined to an offchain decision record under a stable run identifier.
What a hash can and cannot establish
The table separates the questions a hash can help answer from the ones it cannot. The field names and behaviour described below come from Ethereum’s JSON-RPC documentation and the Go Ethereum (Geth) client documentation. Other networks and clients differ in field names, finality labels and trace support, so check those details before reusing this model.
As an Amazon Associate I earn from qualifying purchases.
| Question | Answered by the hash alone? | Source of the answer |
|---|---|---|
| Was a transaction with this hash submitted to the network I queried? | Yes, if the lookup succeeds on that node | Transaction object from the node |
| Did it execute without failing? | No | Receipt status field |
| What facts did the contract emit? | No | Receipt logs, decoded against the contract ABI |
| Which internal calls and state changes occurred? | No | Execution trace from a tracing-capable client |
| Why did the automation submit it? | No | Your offchain decision record |
| Is the block it landed in still part of the canonical chain? | No | Repeated block observations with timestamps |
Layer 1: The transaction object
Start by calling eth_getTransactionByHash with the hash. Ethereum’s JSON-RPC documentation describes the returned object as including the block hash and number, sender, recipient, input data, nonce, value, gas and the transaction hash. That establishes what was submitted and, once it has been included, where. Store the response exactly as returned.
Two fields matter later. The input data is an encoded function call, not a readable instruction, and it must be decoded against the contract’s ABI before anyone can interpret it. The sender and nonce tie the transaction to a specific signing account and its ordering, which becomes important once retries are involved.
#1 Best Overall
Layer 2: The receipt
Retrieve the receipt separately with eth_getTransactionReceipt. Ethereum’s documentation lists the transaction hash, transaction and block position, sender and recipient, gas used, logs, logs bloom and status. A status of 1 means success and 0 means failure. A pending transaction has no receipt.
Read the status for exactly what it is: the transaction executed without failing at the EVM level. It does not show whether the price the automation accepted was acceptable, whether the recipient was the one your policy approved, or whether the automation should have run at all.
- Query the transaction object by hash and store the raw response.
- Query the receipt by the same hash. If no receipt is returned, record the observation as not yet available on that node, with the node identity and time, and schedule a re-check. Do not record the transaction as failed or successful.
- If the status is
0, record a failed execution and keep the hash linked to the run. The status alone does not reveal the reason. - If the status is
1, store the gas used and the complete logs array, then continue to decoding. - Decode the logs only after the raw data is stored, and keep the decoded view as a second representation beside it.
Layer 3: Logs and events
Events are declared in contract code, emitted during execution, and designed so applications can listen to and index them. Ethereum.org’s worked example is the ERC-20 Transfer event, which carries the sender, the recipient and the value. A decoded Transfer entry is therefore evidence that the contract emitted a transfer-shaped event with those values. It is not evidence of why an automation moved the tokens.
Three limitations need explicit handling:
- Emitter identity. Any contract can emit an event with the same name and shape. Check the log’s address against the contract you intended to call before trusting a decoded label.
- ABI version. Decoding depends on the ABI used. A wrong or outdated ABI can produce plausible but incorrect labels, so record the ABI version or source reference alongside the decoded output.
- Coverage. A contract emits only the events its authors chose to emit. A business condition that was never emitted will not appear in any log.
Layer 4: Traces for complex contract calls
Logs show what a contract chose to announce. For multi-step calls, an execution trace can show the path the transaction took, including internal calls. Go Ethereum’s EVM tracing documentation explains why a receipt is not enough:
Rank #3
“The transaction receipt contains a status code that shows whether the transaction succeeded or failed, but more detailed information is not readily available, meaning it is very difficult to know what a contract execution actually did, what data was modified and which addresses were touched.”
The page is published by the Go Ethereum project and does not credit an individual author.
Rank #4
On Geth, a trace is requested through the debug namespace, for example debug_traceTransaction. Not every endpoint exposes it, and some hosted RPC providers do not expose debug methods at all. A provider that does offer traces may run a different client or tracer, and trace output depends on the tracer used. Record the tracing client or provider, its version, the tracer and its parameters, and the retrieval time.
Treat a trace as diagnostic evidence from a specific producer, not as a canonical chain record. If a trace cannot be retrieved, record the error and keep the receipt and logs as the primary evidence. Do not reconstruct an execution path from assumptions.
Layer 5: Anchoring the evidence to a block
Block identity and chain context
Ethereum’s block documentation identifies the block hash, transaction root, receipts root and logs bloom as part of a block’s header data. Store the chain ID, block number and block hash alongside the transaction, receipt and logs. A hash alone does not name the network it came from, and a block number alone does not identify a block once reorganizations are possible.
Finality and reorganizations
Ethereum’s JSON-RPC reference documents the safe and finalized block tags for supported methods. Their availability and meaning vary by chain and client, so confirm them on the specific network you use. Record each observation as a set of block number, block hash, observation time and node, rather than a single “confirmed” flag. If a block hash you previously observed no longer appears at that height, record the replacement, because the transaction may now sit in a different block.
Verifiable log completeness
A filtered log query is only as complete as the node that answered it, and headers and blooms alone make it expensive to prove that nothing was omitted. EIP-7792, titled “Verifiable logs,” proposes verifiable eth_getLogs responses for that reason. It is a proposal, not a deployed guarantee: its record lists it as a Standards Track proposal with stagnant status, and not every provider supports verifiable log proofs. Check the current EIP status before building on it. In practice, record the filter range, the provider and the block tags used, and reconcile the logs for each transaction you submitted against that transaction’s receipt.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchWhat the operational record must add
Chain artifacts answer what the network recorded. The operational record must answer why the automation asked for it, under which rules, and what was done with the result. The grouping below is an engineering checklist, not an Ethereum or legal standard. Ethereum’s documentation does not prescribe a cross-chain audit schema, a retention period or a regulatory format, so those choices belong to the operator’s own policy.
Trigger and decision
- Automation run ID, trigger type and trigger time.
- Input data, upstream source, and the observed state or price and oracle values used.
- Policy or configuration version, decision result, reason codes, thresholds, and any human approval with its identifier and time.
Signing and submission
- Identifier of the service, wallet or key that signed (never the secret key), plus request, authorization and signing timestamps.
- Transaction hash, nonce, sender, destination, value, and calldata or a protected reference to it.
- Fee parameters, and retry or replacement links to every earlier hash from the same run.
Chain observations
- Receipt payload, status, block number and hash, transaction index and gas used.
- Raw logs, with the decoded representation stored as a separate field along with its ABI version.
- Each confirmation or finality observation with its timestamp, and any reorganization noticed.
- Trace payload where it was needed, with the tracing client or provider, client version, parameters and retrieval time.
Provider and outcome
- RPC or provider identity, client or API version where known, and the source of each observation.
- Errors and timeouts, recorded as observations rather than discarded.
- Resulting application action, reconciliation outcome, incident notes, and the retention and integrity controls your policy requires.
Comparing two evidence views
When a dashboard, indexer or RPC provider presents a transaction as settled, test its account against the axes below before accepting it.
Quick Recap
| Axis | Question to ask | What to store |
|---|---|---|
| Scope | Does it show submitted fields, the receipt and logs, or an internal trace? | The artifact type each displayed field came from |
| Provenance | Which chain, node, provider and decoding ABI supplied it? | Chain ID, provider name, ABI version |
| Completeness | Is it one transaction, or filtered logs across a range, and can completeness be verified? | Filter range, block tags used, verification status |
| Finality | Was the transaction only included, observed as safe or finalized, or later affected by a reorganization? | Block number, block hash and time of each observation |
| Intent linkage | Does the view connect the transaction to the run, trigger, inputs, policy version, signer, retries and outcome? | Run ID and the joins between records |
| Reproducibility | Can another operator retrieve the same transaction, receipt, logs and trace from the stored identifiers and context? | Hashes, block identifiers, client and provider details, retrieval times |
When the views disagree
- Receipt status is 0, but the application recorded success. The application treated submission as the outcome. Change the state machine so a run closes only on a receipt-based observation, and keep the failed hash linked to the run.
- A dashboard shows a transaction as final, but your node returns no receipt. Compare node identities, block tags and timestamps. Record both observations and do not overwrite one with the other.
- Two tools show different event names for the same log. Compare the emitting address and the ABI version before trusting either label.
- A run has more than one transaction hash. Keep every submitted hash linked to the run, and mark which one, if any, has a receipt.
- The trace cannot be retrieved. Record the provider error, keep the receipt and logs as primary evidence, and do not fill the gap with an inferred execution path.
|
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
