eth_getStorageAt | Hyperliquid EVM

The eth_getStorageAt JSON-RPC method returns the value stored at a specific storage position in a smart contract. On Hyperliquid EVM.

POST /evm

eth_getStorageAt

cURL

curl --request POST \
  --url https://hyperliquid-mainnet.core.chainstack.com/4f8d8f4040bdacd1577bff8058438274/evm \
  --header 'Content-Type: application/json' \
  --data '
{
  "jsonrpc": "2.0",
  "method": "eth_getStorageAt",
  "params": [
    "0x5555555555555555555555555555555555555555",
    "0x0",
    "latest"
  ],
  "id": 1
}
'

import requests

url = "https://hyperliquid-mainnet.core.chainstack.com/4f8d8f4040bdacd1577bff8058438274/evm"

payload = {
    "jsonrpc": "2.0",
    "method": "eth_getStorageAt",
    "params": ["0x5555555555555555555555555555555555555555", "0x0", "latest"],
    "id": 1
}
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'eth_getStorageAt',
    params: ['0x5555555555555555555555555555555555555555', '0x0', 'latest'],
    id: 1
  })
};

fetch('https://hyperliquid-mainnet.core.chainstack.com/4f8d8f4040bdacd1577bff8058438274/evm', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://hyperliquid-mainnet.core.chainstack.com/4f8d8f4040bdacd1577bff8058438274/evm",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jsonrpc' => '2.0',
    'method' => 'eth_getStorageAt',
    'params' => [
        '0x5555555555555555555555555555555555555555',
        '0x0',
        'latest'
    ],
    'id' => 1
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://hyperliquid-mainnet.core.chainstack.com/4f8d8f4040bdacd1577bff8058438274/evm"

	payload := strings.NewReader("{\n  \"jsonrpc\": \"2.0\",\n  \"method\": \"eth_getStorageAt\",\n  \"params\": [\n    \"0x5555555555555555555555555555555555555555\",\n    \"0x0\",\n    \"latest\"\n  ],\n  \"id\": 1\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://hyperliquid-mainnet.core.chainstack.com/4f8d8f4040bdacd1577bff8058438274/evm")
  .header("Content-Type", "application/json")
  .body("{\n  \"jsonrpc\": \"2.0\",\n  \"method\": \"eth_getStorageAt\",\n  \"params\": [\n    \"0x5555555555555555555555555555555555555555\",\n    \"0x0\",\n    \"latest\"\n  ],\n  \"id\": 1\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://hyperliquid-mainnet.core.chainstack.com/4f8d8f4040bdacd1577bff8058438274/evm")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"jsonrpc\": \"2.0\",\n  \"method\": \"eth_getStorageAt\",\n  \"params\": [\n    \"0x5555555555555555555555555555555555555555\",\n    \"0x0\",\n    \"latest\"\n  ],\n  \"id\": 1\n}"

response = http.request(request)
puts response.read_body

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x000000000000000000000000fc1286eeddf81d6955edad5c8d99b8aa32f3d2aa"
}

This method is available on Chainstack. Not all Hyperliquid methods are available on Chainstack, as the open-source node implementation does not support them yet — see Hyperliquid methods for the full availability breakdown.

The eth_getStorageAt JSON-RPC method returns the value stored at a specific storage position in a smart contract. This method provides direct access to contract storage, enabling contract state inspection, debugging, and advanced contract analysis.

Get your own node endpoint today

Start for free and get your app to production levels immediately. No credit card required.

You can sign up with your GitHub, X, Google, or Microsoft account.

Parameters

The method takes three parameters:

1. Address - The contract address to read storage from
2. Storage position - The storage slot position to read
3. Block parameter - The block at which to read the storage

Parameter details

• address (string, required) — The 20-byte contract address
• position (string, required) — The storage position as a hexadecimal string
• block (string, required) — Block identifier: "latest" (only the latest block is supported on Hyperliquid)

Response

The method returns the 32-byte value stored at the specified position as a hexadecimal string.

Response structure

Storage value:

• result — The 32-byte storage value as a hexadecimal string with 0x prefix

Data interpretation

Storage format:

• Always returns 32 bytes (64 hex characters + 0x prefix)
• Values are zero-padded to 32 bytes
• 0x0000000000000000000000000000000000000000000000000000000000000000 indicates empty/zero storage
• Actual data may be packed or encoded depending on variable type

Value decoding:

// Decode different data types
const decodeUint256 = (hex) => parseInt(hex, 16);
const decodeAddress = (hex) => "0x" + hex.slice(-40); // Last 20 bytes
const decodeBool = (hex) => parseInt(hex, 16) !== 0;
const decodeBytes32 = (hex) => hex; // Already in correct format

Storage layout

Solidity storage rules

Basic types:

• uint256, int256, bytes32 — Occupy full 32-byte slot
• uint128, uint64, etc. — Packed into slots when possible
• address — 20 bytes, often packed with other data
• bool — 1 byte, packed with other data

Complex types:

• Arrays — Length at base slot, elements at calculated positions
• Mappings — Values at keccak256(key, slot) positions
• Structs — Members packed sequentially starting from base slot

Storage slot calculation

Simple variables:

contract Example {
    uint256 public value1;     // Slot 0
    address public owner;      // Slot 1 (packed with next if possible)
    bool public active;        // Slot 1 (packed with owner)
    uint256 public value2;     // Slot 2
}

Arrays:

uint256[] public items;        // Length at slot 0
// items[i] at keccak256(0) + i

Mappings:

mapping(address => uint256) public balances;  // Slot 0
// balances[addr] at keccak256(addr, 0)

Contract state inspection

Variable reading

Direct variable access:

• Read public variables directly from their storage slots
• Decode packed variables using appropriate offsets
• Handle different data types and encodings
• Verify variable values against expected ranges

State verification:

• Compare storage values with expected contract state
• Verify contract initialization and configuration
• Check for state corruption or unexpected changes
• Validate contract upgrade states

Current state analysis

State inspection:

• Read current contract storage values
• Analyze current contract state and configuration
• Verify current variable values and settings
• Inspect current contract initialization state

Usage example

Basic implementation

// Get storage value from a contract on Hyperliquid
const getStorageAt = async (contractAddress, position) => {
  const response = await fetch('https://hyperliquid-mainnet.core.chainstack.com/YOUR_ENDPOINT/evm', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      method: 'eth_getStorageAt',
      params: [contractAddress, position, 'latest'], // Only 'latest' is supported
      id: 1
    })
  });
  
  const data = await response.json();
  return data.result;
};

// Read different data types from storage
const analyzeContractStorage = async (contractAddress) => {
  // Read first few storage slots
  const slot0 = await getStorageAt(contractAddress, '0x0');
  const slot1 = await getStorageAt(contractAddress, '0x1');
  const slot2 = await getStorageAt(contractAddress, '0x2');
  
  return {
    slot0: {
      raw: slot0,
      asUint256: parseInt(slot0, 16),
      asAddress: "0x" + slot0.slice(-40), // Last 20 bytes
      asBool: parseInt(slot0, 16) !== 0
    },
    slot1: {
      raw: slot1,
      asUint256: parseInt(slot1, 16),
      asAddress: "0x" + slot1.slice(-40),
      asBool: parseInt(slot1, 16) !== 0
    },
    slot2: {
      raw: slot2,
      asUint256: parseInt(slot2, 16),
      asAddress: "0x" + slot2.slice(-40),
      asBool: parseInt(slot2, 16) !== 0
    }
  };
};

// Calculate mapping storage position
const getMappingValueSlot = (key, baseSlot) => {
  // This requires a library like ethers.js or web3.js for keccak256
  // Example: mapping(address => uint256) at slot 0
  const encodedKey = ethers.utils.defaultAbiCoder.encode(['address', 'uint256'], [key, baseSlot]);
  return ethers.utils.keccak256(encodedKey);
};

// Read mapping value
const readMappingValue = async (contractAddress, key, baseSlot) => {
  const slot = getMappingValueSlot(key, baseSlot);
  const value = await getStorageAt(contractAddress, slot);
  return parseInt(value, 16);
};

// Calculate array element position
const getArrayElementSlot = (baseSlot, index) => {
  // Array length is at baseSlot, elements start at keccak256(baseSlot)
  const arrayStartSlot = ethers.utils.keccak256(
    ethers.utils.defaultAbiCoder.encode(['uint256'], [baseSlot])
  );
  return (BigInt(arrayStartSlot) + BigInt(index)).toString(16);
};

// Usage examples
const contractAddress = "0x5555555555555555555555555555555555555555";

analyzeContractStorage(contractAddress)
  .then(analysis => console.log('Storage Analysis:', analysis))
  .catch(error => console.error('Error:', error));

// Read a specific storage slot
getStorageAt(contractAddress, '0x0')
  .then(value => console.log('Slot 0 value:', value))
  .catch(error => console.error('Error:', error));

Hyperliquid-specific considerations

Block limitations

Latest block only:

• Only the "latest" block parameter is supported
• Historical storage queries are not available in the default implementation
• All storage reads are performed against the current state
• For historical analysis, consider using archive node implementations

Storage analysis

Current state inspection:

• Read contract storage values at current block
• Analyze current contract configuration and state
• Verify current variable values and settings
• Debug current contract behavior and issues

Data interpretation:

• Storage values are always 32 bytes (64 hex characters + “0x”)
• Values are zero-padded to 32 bytes
• Different data types require different decoding approaches
• Packed variables share storage slots for gas efficiency

Example request

This an example call with wrapped HYPE (wHYPE) on the Hyperliquid mainnet deployed at 0x5555555555555555555555555555555555555555.

Shell

curl -X POST \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_getStorageAt","params":["0x5555555555555555555555555555555555555555","0x0","latest"],"id":1}' \
  https://hyperliquid-mainnet.core.chainstack.com/4f8d8f4040bdacd1577bff8058438274/evm

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("YOUR_CHAINSTACK_ENDPOINT"))

value = w3.eth.get_storage_at(
    "0x5555555555555555555555555555555555555555",
    0,
    "latest",  # Only "latest" is supported on Hyperliquid
)

print(value.hex())

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("YOUR_CHAINSTACK_ENDPOINT");

// Only "latest" is supported on Hyperliquid
const value = await provider.getStorage(
  "0x5555555555555555555555555555555555555555",
  "0x0",
  "latest",
);

console.log(value);

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("YOUR_CHAINSTACK_ENDPOINT"),
});

const value = await client.getStorageAt({
  address: "0x5555555555555555555555555555555555555555",
  slot: "0x0",
  blockTag: "latest", // Only "latest" is supported on Hyperliquid
});

console.log(value);

Use your own endpoint in your code. The code examples use a placeholder Chainstack endpoint (YOUR_CHAINSTACK_ENDPOINT) — replace it with your own Hyperliquid node endpoint from the Chainstack console. The curl above uses a shared public endpoint for quick checks only; do not use it in production.

Use cases

The eth_getStorageAt method is essential for applications that need to:

• Contract debugging: Inspect current contract state during development and testing
• State verification: Verify current contract variables and configuration
• Security analysis: Analyze current contract storage for security vulnerabilities
• Contract auditing: Examine current contract state for audit and compliance
• Development tools: Build contract inspection and debugging tools
• Reverse engineering: Analyze unknown contracts by examining current storage
• Testing frameworks: Verify current contract state in automated tests
• Block explorers: Display current contract storage information
• Integration services: Provide current contract state data to external systems

On Hyperliquid, eth_getStorageAt only supports the latest block. Storage positions are calculated based on Solidity’s storage layout rules. Complex types like arrays and mappings require specific calculations to determine the correct storage positions.

Body

application/json

jsonrpc · enum<string> · default: 2.0 · required

JSON-RPC version

Available options: 2.0

method · enum<string> · default: eth_getStorageAt · required

The RPC method name

Available options: eth_getStorageAt

params · array · required

Parameters: [address, position, block]

id · integer · default: 1 · required

Request identifier

Response

200 - application/json

Successful response with the storage value

jsonrpc · string

JSON-RPC version

id · integer

Request identifier

result · string

The 32-byte storage value as a hexadecimal string