eth_getProof

The eth_getProof method returns the account and storage values of a specific address, including cryptographic Merkle proofs. These proofs verify that the data is correctly included in the state trie without requiring trust in the data provider.

Use Cases

L2 solutions that require state verification
Cross-chain bridges and validation
Trustless blockchain data verification
Light client implementations
Stateless client development
Zero-knowledge proof systems
Fraud proof construction
Security audits and verification

Method Details

This method retrieves both account proofs and storage proofs for specified storage keys.

Response Example

1{
2	"jsonrpc": "2.0",
3	"id": 1,
4	"result": {
5		"address": "0x6B175474E89094C44Da98b954EedeAC495271d0F",
6		"accountProof": [
7			"0xf90211a0...",
8			"0xf90211a0...",
9			"0xf90211a0...",
10			"0xf90211a0...",
11			"0xf90211a0...",
12			"0xf90211a0...",
13			"0xf90131a0..."
14		],
15		"balance": "0x0",
16		"codeHash": "0x34eb8290afdbf2cea95f7afaefe0e2e8071e0b9a3ee4f106c8f3b6a45663e05d",
17		"nonce": "0x1",
18		"storageHash": "0x9588589599c2d368b2c109def4942d664838b3b681e80898fae7d2d140fe6a4c",
19		"storageProof": [
20			{
21				"key": "0x0000000000000000000000000000000000000000000000000000000000000002",
22				"value": "0x000000000000000000000000000000000000000001cc3c3beb2aa7ced800000",
23				"proof": ["0xf90211a0...", "0xf90211a0...", "0xf90211a0...", "0xf90211a0..."]
24			},
25			{
26				"key": "0x29ae811400000000000000000000000000000000000000000000000000000000",
27				"value": "0x0000000000000000000000000000000000000000000000000000000000000001",
28				"proof": ["0xf90211a0...", "0xf90211a0...", "0xf90211a0...", "0xf90211a0..."]
29			}
30		]
31	}
32}

Understanding Merkle Proofs

A Merkle proof allows verification that a piece of data is part of a Merkle tree without having the entire tree. In Ethereum:

The state trie root is a 32-byte hash stored in each block
Account data is stored in the state trie, with the account address as the key
Account storage is stored in a separate storage trie, with the storage key as the key
Proofs consist of a set of nodes that allow verification from the root hash to the target data

Practical Example

1// Example: Verify total supply of DAI using a proof
2const ethers = require('ethers');
3const RLP = require('rlp');
4const { keccak256 } = ethers.utils;
5 
6async function verifyTokenSupply(tokenAddress) {
7	// DAI token's totalSupply is stored at storage slot 2
8	const totalSupplySlot = '0x0000000000000000000000000000000000000000000000000000000000000002';
9 
10	// Get the latest block hash for reference
11	const blockData = await provider.send('eth_getBlockByNumber', ['latest', false]);
12	const blockHash = blockData.hash;
13 
14	// Get the proof
15	const proof = await provider.send('eth_getProof', [tokenAddress, [totalSupplySlot], 'latest']);
16 
17	console.log(`Block hash: ${blockHash}`);
18	console.log(`State root: ${blockData.stateRoot}`);
19	console.log(`Storage hash: ${proof.storageHash}`);
20 
21	// Extract total supply from the proof
22	const totalSupplyHex = proof.storageProof[0].value;
23	const totalSupply = BigInt(totalSupplyHex);
24	const totalSupplyDecimal = totalSupply / 10n ** 18n; // DAI has 18 decimals
25 
26	console.log(`Verified total supply: ${totalSupplyDecimal.toString()} DAI`);
27 
28	// To actually verify the proof cryptographically, we would need to:
29	// 1. Verify the account proof from stateRoot to storageHash
30	// 2. Verify the storage proof from storageHash to totalSupply value
31	// This requires implementing Merkle-Patricia trie verification
32 
33	return {
34		blockHash,
35		stateRoot: blockData.stateRoot,
36		storageHash: proof.storageHash,
37		totalSupply: totalSupplyDecimal.toString(),
38	};
39}
40 
41// Usage
42const daiProof = await verifyTokenSupply('0x6B175474E89094C44Da98b954EedeAC495271d0F');

Finding Storage Slots

For Solidity contracts, storage slots can be determined as follows:

Simple variables: Stored sequentially starting from slot 0
Mappings: keccak256(abi.encode(key, slot)) where slot is the position of the mapping declaration
Dynamic arrays: keccak256(slot) + index
ERC20 balances: Usually in a mapping, e.g., keccak256(abi.encode(userAddress, 3))