state_getStorage

Description

Retrieves a storage value from the Moonriver state at a given key. Storage keys are constructed from pallet name, storage item name, and optional parameters. The returned value is SCALE-encoded and needs to be decoded according to the storage item's type.

Parameters

Parameter	Type	Required	Description
storageKey	string	Yes	Hex-encoded storage key
blockHash	string	No	Block hash to query state at. If omitted, uses latest block

Returns

Field	Type	Description
result	string	Hex-encoded SCALE-encoded storage value, or null if not exists

Request Example

{
  "jsonrpc": "2.0",
  "method": "state_getStorage",
  "params": [
    "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9"
  ],
  "id": 1
}

Response Example

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

Storage Key Construction

Storage keys follow the pattern:

twox128(pallet_name) + twox128(storage_item_name) + hasher(key_params)

Common Storage Keys

Storage	Key Prefix	Description
System.Account	0x26aa394eea5630e07c48ae0c9558cef7	Account information
Balances.TotalIssuance	0xc2261276cc9d1f8598ea4b6a74b15c2f	Total token supply
Staking.Validators	0x5f3e4907f716ac89b6347d15ececedca	Validator preferences
Staking.Nominators	0x5f3e4907f716ac89b6347d15ececedca	Nominator information

Code Examples

Python

from substrateinterface import SubstrateInterface
import json

# Using substrate-interface for easier key construction
substrate = SubstrateInterface(
    url="https://api-moonriver.n.dwellir.com/YOUR_API_KEY",
    extra_headers={"Authorization": "Bearer YOUR_API_KEY"}
)

# Query account info
def get_account_info(address):
    result = substrate.query(
        module='System',
        storage_function='Account',
        params=[address]
    )
    
    return {
        'nonce': result['nonce'],
        'free': result['data']['free'],
        'reserved': result['data']['reserved']
    }

# Direct RPC call
def get_storage_raw(storage_key):
    url = "https://api-moonriver.n.dwellir.com/YOUR_API_KEY"
    headers = {
        "Content-Type": "application/json"
    }
    
    payload = {
        "jsonrpc": "2.0",
        "method": "state_getStorage",
        "params": [storage_key],
        "id": 1
    }
    
    response = requests.post(url, headers=headers, data=json.dumps(payload))
    return response.json()["result"]

JavaScript

import { xxhashAsHex } from '@polkadot/util-crypto';

// Helper to construct storage key
const getStorageKey = (module, item, ...params) => {
  const moduleHash = xxhashAsHex(module, 128);
  const itemHash = xxhashAsHex(item, 128);
  // Add parameter hashing as needed
  return moduleHash + itemHash.slice(2);
};

// Query account balance
const getAccountInfo = async (address) => {
  // Construct storage key for System.Account
  const storageKey = '0x26aa394eea5630e07c48ae0c9558cef7' + 
    '9c1fc3b50141589e85322024b6e379f5' + 
    // Add blake2_128_concat hash of address
    address.slice(2);
  
  const response = await fetch('https://api-moonriver.n.dwellir.com/YOUR_API_KEY', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      method: 'state_getStorage',
      params: [storageKey],
      id: 1
    })
  });
  
  const data = await response.json();
  return data.result;
};

TypeScript (@polkadot/api)

import { ApiPromise, WsProvider } from '@polkadot/api';

async function queryStorage() {
  const provider = new WsProvider('wss://api-moonriver.n.dwellir.com/YOUR_API_KEY');
  const api = await ApiPromise.create({ provider });
  
  // High-level query
  const account = await api.query.system.account('ADDRESS');
  console.log('Account:', account.toHuman());
  
  // Raw storage query
  const storageKey = api.query.system.account.key('ADDRESS');
  const rawValue = await api.rpc.state.getStorage(storageKey);
  console.log('Raw storage:', rawValue.toHex());
  
  // Query at specific block
  const blockHash = await api.rpc.chain.getBlockHash(1000000);
  const historicalValue = await api.rpc.state.getStorage(
    storageKey,
    blockHash
  );
  
  await api.disconnect();
}

Common Storage Queries

Account Balance

// Storage key for System.Account
const key = '0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9' +
  // Add account address hash
  accountHash;

Total Issuance

// Storage key for Balances.TotalIssuance
const key = '0xc2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80';

Validator Count

// Storage key for Staking.ValidatorCount
const key = '0x5f3e4907f716ac89b6347d15ececedca9e6291df5932f5f9e8b539b69d9bc699';

Related Methods

• state_getMetadata - Get metadata for decoding
• chain_getBlock - Get block data
• chain_getBlockHash - Get block hash for queries
• system_health - Check node status

Notes

• Storage values are SCALE-encoded and require proper decoding
• Use high-level APIs when possible for automatic encoding/decoding
• Storage keys can be complex for map-type storage items
• Null result indicates the storage item doesn't exist