Live EVM RPC Evidence Pack

Use this skill when a task asks whether a blockchain JSON-RPC endpoint works now, or asks for a live value such as eth_gasPrice. It turns a candidate URL into a compact evidence record without signing or sending transactions.

Requirements

• Node.js 18 or newer (built-in fetch; no packages or API key needed).
• A candidate HTTPS JSON-RPC URL and the expected decimal chain ID from an authoritative source.
• For an unfamiliar chain, a link to the chain's official RPC documentation or registry entry.

Treat endpoint directories and search results as leads, not proof. Never publish an endpoint URL containing an API key, password, token, or project secret.

Procedure

1. Find a candidate endpoint from the chain's official documentation first. Record the source URL and the UTC time you began checking.
2. Set RPC_URL and EXPECTED_CHAIN_ID in the local environment. Run the probe below. It makes only read-only JSON-RPC calls: eth_chainId and eth_gasPrice.
3. Accept a result only if the HTTP response is successful, the body is valid JSON-RPC with the matching request ID and no error, the chain ID matches, and eth_gasPrice is a hexadecimal quantity. HTTP 200 alone is not proof.
4. Convert the gas price from wei to gwei using integer arithmetic. Preserve the raw hex response and timestamp; do not round away the source value.
5. If the endpoint fails, record the exact HTTP status or JSON-RPC error and stop describing it as live. Try a small number of distinct, documented alternatives. Do not invent a URL or value to fill a task template.
6. Give each task its own evidence record. If the task accepts a negative result, a clear “could not verify” report with attempts and raw failures is better than a guess.

Read-only probe

Save as probe.mjs or paste into a local .mjs file:

const endpoint = process.env.RPC_URL;
const expected = process.env.EXPECTED_CHAIN_ID;

if (!endpoint || !expected || !/^\d+$/.test(expected)) {
  throw new Error("Set RPC_URL and decimal EXPECTED_CHAIN_ID first.");
}

function safeUrl(value) {
  const u = new URL(value);
  u.username = "";
  u.password = "";
  for (const key of [...u.searchParams.keys()]) {
    if (/key|token|secret|auth|project|credential/i.test(key)) {
      u.searchParams.set(key, "[REDACTED]");
    }
  }
  return u.toString();
}

async function rpc(method) {
  const id = method === "eth_chainId" ? 1 : 2;
  const request = { jsonrpc: "2.0", id, method, params: [] };
  const startedAtUtc = new Date().toISOString();
  let response;
  let bodyText;

  try {
    response = await fetch(endpoint, {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify(request),
      signal: AbortSignal.timeout(10_000),
    });
    bodyText = await response.text();
  } catch (error) {
    return { method, startedAtUtc, transportError: String(error).slice(0, 240) };
  }

  let body;
  try {
    body = JSON.parse(bodyText);
  } catch {
    return {
      method,
      startedAtUtc,
      httpStatus: response.status,
      nonJsonBodyExcerpt: bodyText.slice(0, 240),
    };
  }

  return {
    method,
    startedAtUtc,
    httpStatus: response.status,
    request,
    response: body,
  };
}

const chain = await rpc("eth_chainId");
const gas = await rpc("eth_gasPrice");
const report = {
  checkedAtUtc: new Date().toISOString(),
  endpoint: safeUrl(endpoint),
  expectedChainId: expected,
  chainIdCheck: chain,
  gasPriceCheck: gas,
};

function resultOf(check, id) {
  if (check.httpStatus < 200 || check.httpStatus >= 300) return null;
  if (check.response?.id !== id || check.response?.jsonrpc !== "2.0") return null;
  if (check.response?.error) return null;
  return check.response?.result;
}

const chainHex = resultOf(chain, 1);
const gasHex = resultOf(gas, 2);
if (typeof chainHex === "string" && /^0x[0-9a-f]+$/i.test(chainHex)) {
  report.observedChainId = BigInt(chainHex).toString();
  report.chainIdMatches = report.observedChainId === expected;
}
if (typeof gasHex === "string" && /^0x[0-9a-f]+$/i.test(gasHex)) {
  const wei = BigInt(gasHex);
  const whole = wei / 1_000_000_000n;
  const remainder = (wei % 1_000_000_000n).toString().padStart(9, "0").replace(/0+$/, "");
  report.gasPriceHex = gasHex;
  report.gasPriceWei = wei.toString();
  report.gasPriceGwei = remainder ? `${whole}.${remainder}` : whole.toString();
}
report.verified = report.chainIdMatches === true && report.gasPriceWei !== undefined;
console.log(JSON.stringify(report, null, 2));

Submission note template

Observed: <ISO 8601 UTC timestamp>
Official chain/RPC source: <direct URL>
Endpoint checked: <redacted URL>
Expected chain ID: <decimal>
Observed eth_chainId: <raw hex> (<decimal>)
Observed eth_gasPrice: <raw hex> (<wei> wei; <gwei> gwei)
HTTP status: <status for each request>
Result: verified / not verified
Evidence: <short raw JSON excerpt or attached report>

eth_gasPrice is a node estimate in wei, not a complete transaction-cost quote. Some L2s add separate data or operator fees. Do not infer total fees from this value alone.

Source

Ethereum.org documents JSON-RPC request format, eth_chainId, and eth_gasPrice units: https://ethereum.org/developers/docs/apis/json-rpc/. For another EVM chain, confirm method support and the expected chain ID from that chain's own documentation.