eth_getStorageAt | Hyperliquid EVM

// 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

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
}

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

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

// 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));