Docs
Moonbase alpha

eth_hashrate - Moonbase RPC Method

Get the legacy eth_hashrate compatibility value on Moonbase Alpha. Public endpoints may return `0x0` or an unsupported-method error depending on the client.

Returns the legacy eth_hashrate compatibility value on Moonbase Alpha. Depending on the client behind the endpoint, this call may return a hex quantity like 0x0 or a method-not-found style error.

Why Moonbase? Build on the Moonbeam testnet for risk-free EVM dApp development and deployment testing with free testnet tokens, full EVM compatibility, XCM testing capabilities, and identical feature set to Moonbeam mainnet.

Note: Treat eth_hashrate as a node-local mining metric and compatibility value. Public endpoints often report 0x0 or reject the method entirely, so it is not a reliable chain-health or consensus signal.

When to Use This Method

eth_hashrate is relevant for Moonbeam developers, dApp testers, and teams validating cross-chain integrations:

  • Node Diagnostics — Check whether the connected client reports a legacy hashrate metric
  • Client Capability Checks — Distinguish between 0x0, unsupported-method, and method-not-found responses
  • Dashboard Integration — Display the metric alongside other node status data when it is available

Request Parameters

Request

This method accepts no parameters.

Response Body

Response
resultQUANTITY

Hexadecimal string representing the reported compatibility value when the client exposes the method

Code Examples

Bash
curl -X POST https://moonbase-rpc.n.dwellir.com \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_hashrate",
    "params": [],
    "id": 1
  }'
JavaScript
// Using fetch
const response = await fetch('https://moonbase-rpc.n.dwellir.com', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'eth_hashrate',
    params: [],
    id: 1
  })
});

const payload = await response.json();
if (payload.error) {
  console.log('eth_hashrate unsupported:', payload.error.message);
} else {
  console.log('Moonbase hashrate:', parseInt(payload.result, 16), 'H/s');
}

// Using ethers.js
import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider('https://moonbase-rpc.n.dwellir.com');
try {
  const hashrate = await provider.send('eth_hashrate', []);
  console.log('Moonbase hashrate:', parseInt(hashrate, 16), 'H/s');
} catch (error) {
  console.log('eth_hashrate unsupported:', error.message);
}
Python
import requests

def get_hashrate():
    response = requests.post(
        'https://moonbase-rpc.n.dwellir.com',
        json={
            'jsonrpc': '2.0',
            'method': 'eth_hashrate',
            'params': [],
            'id': 1
        }
    )
    payload = response.json()
    if 'error' in payload:
        raise RuntimeError(payload['error']['message'])
    return int(payload['result'], 16)

hashrate = get_hashrate()
print(f'Moonbase hashrate: {hashrate} H/s')

# Using web3.py
from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://moonbase-rpc.n.dwellir.com'))
try:
    print(f'Moonbase hashrate: {w3.eth.hashrate} H/s')
except Exception as exc:
    print(f'eth_hashrate unsupported: {exc}')
Go
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/rpc"
)

func main() {
    client, err := rpc.Dial("https://moonbase-rpc.n.dwellir.com")
    if err != nil {
        log.Fatal(err)
    }

    var result string
    err = client.CallContext(context.Background(), &result, "eth_hashrate")
    if err != nil {
        log.Println("eth_hashrate unsupported:", err)
        return
    }

    fmt.Printf("Moonbase hashrate: %s\n", result)
}

Common Use Cases

1. Compatibility-Aware Status Dashboard

Display the reported compatibility value alongside other client status signals without assuming the method is always available:

JavaScript
async function getMiningStats(provider) {
  const blockNumber = await provider.getBlockNumber();
  let hashrate = null;
  let supported = true;

  try {
    hashrate = await provider.send('eth_hashrate', []);
  } catch (error) {
    supported = false;
  }

  return {
    supported,
    hashrate: hashrate ? parseInt(hashrate, 16) : null,
    currentBlock: blockNumber
  };
}

2. Capability Check

Check whether the connected client reports eth_hashrate at all:

JavaScript
async function getHashrateStatus(provider) {
  try {
    const hashrate = await provider.send('eth_hashrate', []);
    return { supported: true, raw: hashrate, isZero: hashrate === '0x0' };
  } catch (error) {
    return { supported: false, message: error.message };
  }
}

console.log(await getHashrateStatus(provider));

Error Handling

Common errors and solutions:

Error CodeDescriptionSolution
-32603Internal errorNode may be initializing — retry after delay
-32601Method not foundNode client may not support this method
-32005Rate limit exceededReduce polling frequency

On this page

When to Use This Method
Code Examples
Common Use Cases
1. Compatibility-Aware Status Dashboard
2. Capability Check
Error Handling
Related Methods