Investigate a deployed contract on a pinned fork

Turn the chain question into fixed inputs

Write down the chain ID, address, function, expected result, caller, call value, and the time or event you are investigating. An address alone is not an identity because the same address can contain different code or no code on another network.

Choose a block before interpreting the result. If the block field is empty, the first successful fork run pins the current block. Keep that number for the rest of the investigation so code, storage, balances, and block context cannot drift.

Connect an RPC that can serve the snapshot

Solidity REPL does not choose a public RPC automatically. Select Fork, enter the chain ID, and run. If execution needs remote state and the endpoint is empty, the RPC prompt opens and resumes the pending run after you save a URL.

The provider must support the selected network, browser requests, and requested history. Older blocks may require archive access. Resolve a connection error, rate limit, unsupported method, or missing historical state before changing the Solidity conclusion.

Establish the interface and contract identity

Use the smallest interface that can answer the question. A narrow interface reduces irrelevant source and makes the selector easy to review. Cast the address only after confirming the network and that bytecode exists at the pinned block.

Verified-contract loading can retrieve sources from Sourcify and create a typed contract variable. Confirm its chain, address, compiler information, and exposed function before relying on it. Use a manual interface when verification is unavailable or only a few functions are needed.

interface IERC20View {
  function balanceOf(address) external view returns (uint256);
  function totalSupply() external view returns (uint256);
}

IERC20View token = IERC20View(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48)

Read enough state to test the hypothesis

Start with view functions that establish the configuration and account or pool state in question. Compare related values when one result can mislead: balance and total supply, allowance and owner balance, or implementation slot and exposed version.

Keep reads in separate entries so each value belongs to one selector and argument set. If a proxy is involved, identify whether the interface belongs to the proxy surface or implementation before simulating a state change.

token.totalSupply()
token.balanceOf(0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640)

Simulate the change and inspect its effects

Configure caller, value, timestamp, and other context before invoking a state-changing path. Fork execution reads the remote snapshot and runs locally in the browser EVM. It does not sign or broadcast a transaction, so simulated writes exist only inside the evaluation.

Inspect Calls to verify message flow, Logs to capture emitted arguments, and State to identify committed writes. A successful top-level return is not enough when the claim concerns an inner contract or durable state effect.

Package a result that survives a new RPC

Before exporting, confirm the chain ID, pinned block, compiler, caller, value, files, and address. State whether each conclusion came from observed fork state or a simulated local change. This prevents a simulation from being mistaken for an onchain transaction.

The exported session omits the RPC URL because endpoints can contain credentials. A reviewer supplies a compatible provider, restores the fixed inputs, and reruns the record. Include provider limitations such as archive depth when they affect reproduction.