Missing Panic data on execution revert

[A2E9]

Hello, I am trying to get the panic message data hex code.

Proposal[] public proposals;

ballot.proposals(U256::from(1)).call().await;

Here is my response:

TransportError(ErrorResp(ErrorPayload { code: 3, message: "execution reverted", data: Some(RawValue("0x")) }))

I have tried forking a local node to Anvil, and using Sepolia on Infura and QuickNode.

According to the docs, I should get a Panic error.

https://docs.soliditylang.org/en/v0.8.5/control-structures.html#error-handling-assert-require-revert-and-exceptions

I do not understand what I am missing.

[DefiAudit0x]

TL;DR

Nothing is missing from the transport layer — the data: "0x" is the complete revert payload.
You are calling the compiler-generated getter proposals(1) when the array has fewer than 2
elements, and the auto-generated public accessor reverts with empty revert data — it does not
emit the Panic(uint256) error you'd expect from the Solidity panic
table.
The panic path only applies to array accesses written in Solidity code (proposals[i] inside a
contract), not to the accessors solc generates for public state variables.

Verified reproduction

contract Ballot {
    uint[] public arr;                 // stands in for Proposal[] public proposals
    constructor() { arr.push(100); }   // only index 0 exists
    // in-contract access: this is the path Panic(0x32) actually applies to
    function internalAccess(uint256 i) external view returns (uint256) {
        return arr[i];
    }
}

Raw RPC against the deployed contract (solc 0.8.28, so this is not a 0.8.5-era quirk):

$ cast call $ADDR 'arr(uint256)' 1
error code 3: execution reverted, data: "0x"
# ^ your exact ErrorPayload { code: 3, message: "execution reverted", data: Some(RawValue("0x")) }

$ cast call $ADDR 'internalAccess(uint256)' 1
error code 3: execution reverted: panic: array out-of-bounds access (0x32),
data: "0x4e487b7100000000000000000000000000000000000000000000000000000000000032"

$ cast call $ADDR 'arr(uint256)' 0
0x0000000000000000000000000000000000000000000000000000000000000064

And the same distinction expressed as Foundry assertions:

// generated getter, out of bounds -> EMPTY revert data
vm.expectRevert(bytes(""));
b.arr(1);

// in-contract access, out of bounds -> documented Panic(0x32)
vm.expectRevert(stdError.indexOOBError);
b.internalAccess(1);

Both pass, which pins down where each behavior lives.

Why this trips people up

The generated accessor performs its bounds check with a bare revert(0, 0) — empty data by
construction. The same empty payload is what you see for any untyped revert() in the call path,
so data: "0x" should be read as "reverted without a reason string or custom error", not as
"error data got lost somewhere between Anvil/Infura and my client". That's also why you saw the
identical payload on both a local Anvil fork and Sepolia: the shape of the revert is decided by the
compiled contract, not by the provider.

How to get useful failure info instead

• Guard the index client-side before calling the getter. Note that for a struct array like
  Proposal[] public proposals there is no bulk getter, so if you don't control the contract, track
  the count from the deployment script/events; if you do control it, expose
  proposals.length explicitly.
• Panic codes only show up on the Solidity-level paths. If you want them decoded client-side,
  look for data starting with the Panic(uint256) selector 0x4e487b71 followed by the
  uint256 code (e.g. 0x32 = out-of-bounds index).
• In alloy, match on the empty RawValue("0x") case explicitly rather than trying to decode it —
  there is nothing to decode.