> ## Documentation Index
> Fetch the complete documentation index at: https://docs.monad.xyz/llms.txt
> Use this file to discover all available pages before exploring further.

# JSON-RPC Playground

> Interactive JSON-RPC request builder for all Monad RPC methods

export const RpcForm = ({allMethods}) => {
  const [selectedMethodName, setSelectedMethodName] = useState(() => {
    if (typeof window !== 'undefined') {
      const search = new URLSearchParams(window.location.search);
      const urlMethod = search.get('method');
      if (urlMethod && allMethods.some(m => m.name === urlMethod)) return urlMethod;
    }
    return allMethods[0]?.name;
  });
  const activeMethodName = selectedMethodName;
  const activeParams = allMethods.find(m => m.name === selectedMethodName)?.params ?? [];
  function getDefaultParamValue(param) {
    if (param.schema.type === 'boolean') {
      return param.required ? true : undefined;
    }
    if (param.schema.type === 'number-array') return '25, 75';
    if (param.schema.type === 'object') return JSON.stringify(getDefaultObjectValue(param.schema), null, 2);
    return param.schema.default ?? '';
  }
  function getDefaultObjectValue(schema) {
    if (!schema?.properties) return {};
    const obj = {};
    for (const [key, propSchema] of Object.entries(schema.properties)) {
      obj[key] = getDefaultTypeValue(propSchema);
    }
    return obj;
  }
  function getDefaultTypeValue(fieldSchema) {
    if (fieldSchema.default !== undefined) return fieldSchema.default;
    if (fieldSchema.enum) return fieldSchema.enum[0];
    if (fieldSchema.type === 'boolean') return undefined;
    if (fieldSchema.type === 'block-tag') return 'latest';
    if (fieldSchema.type === 'object') return {};
    return '';
  }
  function buildInitialValues(paramList) {
    const vals = {};
    for (const param of paramList) {
      vals[param.name] = getDefaultParamValue(param);
    }
    return vals;
  }
  function toHex(value) {
    if (typeof value !== 'string') return value;
    const trimmed = value.trim();
    if (trimmed === '' || trimmed.startsWith('0x') || trimmed.startsWith('0X')) return trimmed;
    const n = parseInt(trimmed, 10);
    if (isNaN(n)) return trimmed;
    return '0x' + n.toString(16);
  }
  function stripEmpty(obj) {
    if (typeof obj !== 'object' || obj === null) return obj;
    const out = {};
    for (const [k, v] of Object.entries(obj)) {
      if (v === '' || v === undefined) continue;
      out[k] = typeof v === 'object' && v !== null ? stripEmpty(v) : v;
    }
    return out;
  }
  function serialize(schema, rawValue) {
    if (schema.type === 'object') return stripEmpty(JSON.parse(rawValue));
    if (schema.type === 'boolean') return rawValue == null ? rawValue : Boolean(rawValue);
    if (schema.type === 'number-array') return rawValue.split(',').map(s => parseFloat(s.trim()));
    if (schema.type === 'quantity' || schema.type === 'block-tag') return toHex(rawValue);
    return rawValue;
  }
  const inputClass = 'w-full rounded-lg border border-gray-950/10 dark:border-white/10 bg-background-light dark:bg-background-dark text-sm px-3 py-2';
  const selectWrapperClass = 'relative';
  const selectClass = `${inputClass} cursor-pointer pr-7`;
  const badgeBase = 'px-2 py-0.5 rounded text-xs border transition-colors';
  const badgeActive = `${badgeBase} border-primary bg-primary/10`;
  const badgeInactive = `${badgeBase} border-gray-950/10 dark:border-white/10 text-gray-600 dark:text-gray-400 hover:border-primary/50`;
  const linkIcon = <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className="ml-1 -mr-1">
      <path d="M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71" /><path d="M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71" />
    </svg>;
  const selectChevron = <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className="pointer-events-none absolute right-2 top-1/2 -translate-y-1/2 text-gray-400">
      <path d="m7 15 5 5 5-5" /><path d="m7 9 5-5 5 5" />
    </svg>;
  const componentRefs = useRef({});
  if (!componentRefs.current.BlockTagInput) {
    componentRefs.current.BlockTagInput = ({value, onChange}) => {
      const BLOCK_TAGS = ['latest', 'safe', 'finalized', 'pending'];
      return <div className="flex flex-col gap-2">
          <div className="flex gap-1 flex-wrap">
            {BLOCK_TAGS.map(tag => {
        const isActive = value === tag;
        return <button key={tag} type="button" onClick={() => onChange(tag)} className={isActive ? badgeActive : badgeInactive}>
                  {tag}
                </button>;
      })}
          </div>
          <input type="text" value={value} onChange={e => onChange(e.target.value)} className={inputClass} />
        </div>;
    };
  }
  if (!componentRefs.current.ObjectFieldInput) {
    componentRefs.current.ObjectFieldInput = ({fieldSchema, value, onChange, depth}) => {
      const {BlockTagInput, ObjectField} = componentRefs.current;
      if (fieldSchema.enum) {
        return <div className={selectWrapperClass}>
            <select value={value} onChange={e => onChange(e.target.value)} className={selectClass}>
              {fieldSchema.enum.map(v => <option key={v} value={v}>{v}</option>)}
            </select>
            {selectChevron}
          </div>;
      }
      if (fieldSchema.type === 'boolean') {
        return <div className="flex gap-1">
            {[true, false].map(opt => {
          const isActive = value === undefined ? false : value === opt;
          return <button key={String(opt)} type="button" onClick={() => onChange(opt)} className={isActive ? badgeActive : badgeInactive}>
                  {String(opt)}
                </button>;
        })}
          </div>;
      }
      if (fieldSchema.type === 'block-tag') {
        return <BlockTagInput value={value ?? 'latest'} onChange={onChange} />;
      }
      if (fieldSchema.type === 'object' && fieldSchema.properties && depth < 4) {
        return <ObjectField schema={fieldSchema} value={value} onChange={onChange} depth={depth + 1} />;
      }
      return <input type="text" value={value ?? ''} onChange={e => onChange(e.target.value)} className={inputClass} />;
    };
  }
  if (!componentRefs.current.ObjectField) {
    componentRefs.current.ObjectField = ({schema, value, onChange, depth = 0}) => {
      const {ObjectFieldInput} = componentRefs.current;
      if (!schema?.properties) return null;
      const obj = typeof value === 'object' && value !== null ? value : {};
      function setField(key, fieldVal) {
        onChange({
          ...obj,
          [key]: fieldVal
        });
      }
      return <div className="flex flex-col gap-2.5 rounded-lg p-3 bg-gray-500/[0.04] dark:bg-white/[0.02]">
          {Object.entries(schema.properties).map(([key, fieldSchema]) => {
        const fieldVal = obj[key] !== undefined ? obj[key] : getDefaultTypeValue(fieldSchema);
        return <div key={key} className="flex flex-col gap-1">
                <label className="text-xs font-medium text-gray-700 dark:text-gray-300">{key}</label>
                {fieldSchema.description && <p className="text-xs text-gray-500 dark:text-gray-400">{fieldSchema.description}</p>}
                <ObjectFieldInput fieldSchema={fieldSchema} value={fieldVal} onChange={v => setField(key, v)} depth={depth} />
              </div>;
      })}
        </div>;
    };
  }
  if (!componentRefs.current.ParamInput) {
    componentRefs.current.ParamInput = ({param, value, onChange, parseError}) => {
      const {BlockTagInput, ObjectField} = componentRefs.current;
      const schema = param.schema;
      if (schema.type === 'boolean') {
        return <div className="flex gap-1">
            {[true, false].map(opt => {
          const isActive = value === undefined ? false : value === opt;
          return <button key={String(opt)} type="button" onClick={() => onChange(opt)} className={isActive ? badgeActive : badgeInactive}>
                  {String(opt)}
                </button>;
        })}
          </div>;
      }
      if (schema.type === 'block-tag') {
        return <BlockTagInput value={value} onChange={onChange} />;
      }
      if (schema.type === 'object') {
        if (schema.properties) {
          let parsed = {};
          try {
            parsed = JSON.parse(value);
          } catch {}
          return <ObjectField schema={schema} value={parsed} onChange={obj => onChange(JSON.stringify(obj, null, 2))} />;
        }
        return <div className="flex flex-col gap-2">
            <textarea rows={4} value={value} onChange={e => onChange(e.target.value)} className={`${inputClass} resize-y`} />
            {parseError && <p className="text-xs text-red-500">{parseError}</p>}
          </div>;
      }
      if (schema.type === 'number-array') {
        return <div className="flex flex-col gap-2">
            <input type="text" value={value} onChange={e => onChange(e.target.value)} placeholder="25, 75" className={inputClass} />
            {parseError && <p className="text-xs text-red-500">{parseError}</p>}
          </div>;
      }
      if (schema.enum) {
        return <div className={selectWrapperClass}>
            <select value={value} onChange={e => onChange(e.target.value)} className={selectClass}>
              {schema.enum.map(v => <option key={v} value={v}>{v}</option>)}
            </select>
            {selectChevron}
          </div>;
      }
      return <input type="text" value={value} onChange={e => onChange(e.target.value)} className={inputClass} />;
    };
  }
  const {ParamInput} = componentRefs.current;
  const RPC_ENDPOINTS = {
    mainnet: 'https://rpc.monad.xyz',
    testnet: 'https://testnet-rpc.monad.xyz'
  };
  const initialSearch = useMemo(() => {
    if (typeof window === 'undefined') return new URLSearchParams();
    return new URLSearchParams(window.location.search);
  }, []);
  const [chain, setChain] = useState(() => {
    const urlChain = initialSearch.get('chain');
    return urlChain === 'mainnet' || urlChain === 'testnet' ? urlChain : 'mainnet';
  });
  const [values, setValues] = useState(() => {
    const defaults = buildInitialValues(activeParams);
    for (const param of activeParams) {
      const urlVal = initialSearch.get(`p.${param.name}`);
      if (urlVal === null) continue;
      const t = param.schema.type;
      if (t === 'boolean') {
        defaults[param.name] = urlVal === 'true' ? true : urlVal === 'false' ? false : undefined;
      } else {
        defaults[param.name] = urlVal;
      }
    }
    return defaults;
  });
  const [loading, setLoading] = useState(false);
  const [response, setResponse] = useState(null);
  const [duration, setDuration] = useState(null);
  const [error, setError] = useState(null);
  const [parseErrors, setParseErrors] = useState({});
  useEffect(() => {
    if (typeof window === 'undefined') return;
    const params = new URLSearchParams();
    params.set('method', selectedMethodName);
    if (chain !== 'mainnet') params.set('chain', chain);
    for (const param of activeParams) {
      const val = values[param.name];
      if (val === undefined || val === '') continue;
      params.set(`p.${param.name}`, String(val));
    }
    const qs = params.toString();
    const newUrl = window.location.pathname + (qs ? '?' + qs : '');
    window.history.replaceState(null, '', newUrl);
  }, [selectedMethodName, chain, values, activeParams]);
  function handleMethodChange(newMethodName) {
    const newParams = allMethods.find(m => m.name === newMethodName)?.params ?? [];
    setSelectedMethodName(newMethodName);
    setValues(buildInitialValues(newParams));
    setResponse(null);
    setError(null);
    setParseErrors({});
  }
  function setValue(name, val) {
    setValues(prev => ({
      ...prev,
      [name]: val
    }));
  }
  const previewParams = activeParams.map(p => {
    const raw = values[p.name];
    const schema = p.schema;
    if (schema.type === 'object') {
      try {
        return stripEmpty(JSON.parse(raw));
      } catch {
        return raw;
      }
    }
    if (schema.type === 'boolean') return raw == null ? raw : Boolean(raw);
    if (schema.type === 'number-array') return raw.split(',').map(s => parseFloat(s.trim()));
    if (schema.type === 'quantity' || schema.type === 'block-tag') return toHex(raw);
    return raw;
  });
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method: activeMethodName,
    params: previewParams
  };
  const isDisabled = loading || activeParams.some(p => {
    const t = p.schema.type;
    return p.required && (t === 'string' || t === 'block-tag' || t === 'integer' || t === 'quantity') && !values[p.name];
  });
  async function send() {
    const errors = {};
    for (const p of activeParams) {
      if (p.schema.type === 'object') {
        try {
          JSON.parse(values[p.name]);
        } catch (e) {
          errors[p.name] = `Invalid JSON: ${e.message}`;
        }
      }
      if (p.schema.type === 'number-array') {
        const parts = values[p.name].split(',').map(s => parseFloat(s.trim()));
        if (parts.some(n => isNaN(n))) {
          errors[p.name] = 'Must be comma-separated numbers (e.g. 25, 75)';
        }
      }
    }
    if (Object.keys(errors).length > 0) {
      setParseErrors(errors);
      return;
    }
    setParseErrors({});
    setDuration(null);
    setLoading(true);
    const t0 = performance.now();
    try {
      const serialized = activeParams.map(p => serialize(p.schema, values[p.name]));
      const body = {
        jsonrpc: '2.0',
        method: activeMethodName,
        id: 1,
        params: serialized
      };
      const res = await fetch(RPC_ENDPOINTS[chain], {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(body)
      });
      const data = await res.json();
      setResponse(data);
      setError(null);
    } catch (e) {
      setResponse(null);
      setError(e.message);
    } finally {
      setDuration(Math.round(performance.now() - t0));
      setLoading(false);
    }
  }
  const endpoint = RPC_ENDPOINTS[chain];
  const jsonRequest = JSON.stringify(requestBody, null, 2);
  const curlRequest = `curl -X POST ${endpoint} \\\n  --header 'Content-Type: application/json' \\\n  --data @- <<'JSON'\n${JSON.stringify(requestBody, null, 2)}\nJSON`;
  const jsonResponse = JSON.stringify(response, null, 2);
  const [copiedRequest, setCopiedRequest] = useState(false);
  const [copiedResponse, setCopiedResponse] = useState(false);
  const [copiedShare, setCopiedShare] = useState(false);
  const [requestTab, setRequestTab] = useState('curl');
  function copyToClipboard(text, setCopied) {
    navigator.clipboard.writeText(text).then(() => {
      setCopied(true);
      setTimeout(() => setCopied(false), 1500);
    });
  }
  const preCodeClass = 'border border-gray-950/10 dark:border-white/10 rounded-lg p-3 m-0 text-xs font-mono overflow-auto whitespace-pre text-gray-900 dark:text-gray-50';
  const preCodeBg = 'rgba(107,114,128,0.02)';
  const preCodeBgDark = 'rgba(255,255,255,0.02)';
  const isDark = typeof document !== 'undefined' && document.documentElement.classList.contains('dark');
  const preCodeStyle = {
    backgroundColor: isDark ? preCodeBgDark : preCodeBg
  };
  const btnClass = 'text-xs font-sans px-2 py-0.5 border border-gray-950/10 dark:border-white/10 bg-gray-50 dark:bg-gray-800 text-gray-600 dark:text-gray-400 hover:text-gray-800 dark:hover:text-gray-200 hover:bg-gray-100 dark:hover:bg-gray-700 transition-colors';
  const selectedBtnClass = 'text-xs font-sans px-2 py-0.5 border border-gray-950/20 dark:border-white/20 bg-gray-100 dark:bg-gray-700 text-gray-800 dark:text-gray-200 transition-colors';
  return <div className="rpc-sandbox grid grid-cols-1 lg:grid-cols-2 gap-6">
      {}
      <div className="flex flex-col gap-4">
        <div className="flex flex-row gap-4">
          {}
          <div className="flex flex-col gap-2 w-[100px]">
            <label className="text-xs font-sans font-semibold text-gray-500 uppercase tracking-wide">Chain</label>
            <div className={selectWrapperClass}>
              <select value={chain} onChange={e => setChain(e.target.value)} className={`${selectClass} w-full`}>
                <option value="mainnet">Mainnet</option>
                <option value="testnet">Testnet</option>
              </select>
              {selectChevron}
            </div>
          </div>

          {}
          <div className="flex-1 flex flex-col gap-2">
            <label className="text-xs font-sans font-semibold text-gray-500 uppercase tracking-wide">Method</label>
            <div className={selectWrapperClass}>
              <select value={selectedMethodName} onChange={e => handleMethodChange(e.target.value)} className={`w-full ${selectClass}`}>
                {allMethods.map(m => <option key={m.name} value={m.name}>{m.name}</option>)}
              </select>
              {selectChevron}
            </div>
          </div>
        </div>

        {}
        <div className="flex flex-col gap-2">
          <label className="text-xs font-sans font-semibold text-gray-500 uppercase tracking-wide">Parameters</label>
          {activeParams.length > 0 ? <div className="flex flex-col gap-2">
              {activeParams.map((param, index) => <div key={param.name} className="bg-gray-500/[0.02] dark:bg-white/[0.02] border border-gray-950/10 dark:border-white/10 rounded-lg p-3 pr-2 flex flex-col gap-2">
                  <div className="flex items-center gap-2">
                    <span className="text-xs text-gray-400 dark:text-gray-500 select-none shrink-0">[{index}]</span>
                    <label className="flex items-center gap-1 text-sm font-sans">
                      <span className="font-medium">{param.name}</span>
                      {param.required && <span className="text-red-500">*</span>}
                    </label>
                  </div>
                  {param.schema.description && <p className="text-xs text-gray-500 dark:text-gray-400">{param.schema.description}</p>}
                  <ParamInput param={param} value={values[param.name]} onChange={val => setValue(param.name, val)} parseError={parseErrors[param.name]} />
                </div>)}
            </div> : <div className="bg-gray-500/[0.02] dark:bg-white/[0.02] border border-gray-950/10 dark:border-white/10 rounded-lg p-3">
              <p className="text-sm text-gray-500 dark:text-gray-400">This method has no parameters.</p>
            </div>}
        </div>
      </div>

      {}
      <div className="flex flex-col gap-4">
        {}
        <div className="flex flex-col gap-2">
          <p className="text-xs font-sans font-semibold text-gray-500 uppercase tracking-wide">Request</p>
          <div className="relative">
            <div className="absolute top-2 left-2 z-10 flex">
              <button type="button" onClick={() => setRequestTab('curl')} className={`${requestTab === 'curl' ? `${selectedBtnClass}` : btnClass} rounded-l-md`}>
                cURL
              </button>
              <button type="button" onClick={() => setRequestTab('json')} className={`${requestTab === 'json' ? `${selectedBtnClass}` : btnClass} rounded-r-md`}>
                JSON
              </button>
            </div>
            <button type="button" onClick={() => copyToClipboard(requestTab === 'json' ? jsonRequest : curlRequest, setCopiedRequest)} className={`absolute top-2 right-2 z-10 rounded-md ${btnClass}`}>
              {copiedRequest ? 'Copied' : 'Copy'}
            </button>
            <div className={preCodeClass} style={{
    ...preCodeStyle,
    paddingTop: "40px"
  }}>
              {requestTab === 'json' ? jsonRequest : curlRequest}
            </div>
          </div>
        </div>

        {}
        <div className="flex justify-end gap-2">
          <button type="button" onClick={() => copyToClipboard(window.location.href, setCopiedShare)} className="flex items-center gap-1.5 rounded-lg px-4 py-2 text-sm font-sans font-semibold border border-gray-950/10 dark:border-white/10 text-gray-700 dark:text-gray-300 hover:bg-gray-50 dark:hover:bg-white/5 transition-colors">
            {copiedShare ? 'Copied URL' : 'Share request'}
            {linkIcon}
          </button>
          <button onClick={send} disabled={isDisabled} className="bg-primary hover:opacity-90 transition-opacity rounded-lg px-4 py-2 w-[150px] text-sm font-sans font-semibold text-white disabled:opacity-50 disabled:cursor-not-allowed">
            {loading ? 'Sending…' : 'Send request'}
          </button>
        </div>

        {}
        {error && <p className="text-sm font-sans text-red-500">{error}</p>}

        {}
        <div className="flex flex-col gap-2">
          <div className="flex items-center justify-between">
            <p className="text-xs font-sans font-semibold text-gray-500 uppercase tracking-wide">Response</p>
            {response && duration != null && <span className="text-xs font-sans text-gray-600 dark:text-gray-400">{duration} ms</span>}
          </div>
          <div className="relative">
            {response && <button type="button" onClick={() => copyToClipboard(jsonResponse, setCopiedResponse)} className={`absolute top-2 right-2 z-10 rounded-md ${btnClass}`}>
                {copiedResponse ? 'Copied' : 'Copy'}
              </button>}
            <div className={`${preCodeClass} max-h-80`} style={preCodeStyle}>
              {response ? jsonResponse : 'Send a request to see the response.'}
            </div>
          </div>
        </div>
      </div>
    </div>;
};

<RpcForm
  allMethods={[
{
  "name": "eth_blockNumber",
  "params": []
},
{
  "name": "eth_call",
  "params": [
    {
      "name": "transaction",
      "required": true,
      "schema": {
        "type": "object",
        "properties": {
          "from": {
            "type": "string"
          },
          "to": {
            "type": "string"
          },
          "gas": {
            "type": "string"
          },
          "maxFeePerGas": {
            "type": "string"
          },
          "maxPriorityFeePerGas": {
            "type": "string"
          },
          "value": {
            "type": "string"
          },
          "input": {
            "type": "string"
          },
          "data": {
            "type": "string"
          },
          "nonce": {
            "type": "string"
          },
          "chainId": {
            "type": "string"
          },
          "accessList": {
            "type": "string"
          },
          "authorizationList": {
            "type": "string"
          }
        },
        "description": "Transaction call object."
      }
    },
    {
      "name": "block",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    }
  ]
},
{
  "name": "eth_chainId",
  "params": []
},
{
  "name": "eth_createAccessList",
  "params": [
    {
      "name": "transaction",
      "required": true,
      "schema": {
        "type": "object",
        "properties": {
          "from": {
            "type": "string"
          },
          "to": {
            "type": "string"
          },
          "gas": {
            "type": "string"
          },
          "maxFeePerGas": {
            "type": "string"
          },
          "maxPriorityFeePerGas": {
            "type": "string"
          },
          "value": {
            "type": "string"
          },
          "input": {
            "type": "string"
          },
          "data": {
            "type": "string"
          },
          "nonce": {
            "type": "string"
          },
          "chainId": {
            "type": "string"
          },
          "accessList": {
            "type": "string"
          },
          "authorizationList": {
            "type": "string"
          }
        },
        "description": "Transaction call object."
      }
    },
    {
      "name": "block",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    }
  ]
},
{
  "name": "eth_estimateGas",
  "params": [
    {
      "name": "tx",
      "required": true,
      "schema": {
        "type": "object",
        "properties": {
          "from": {
            "type": "string"
          },
          "to": {
            "type": "string"
          },
          "gas": {
            "type": "string"
          },
          "maxFeePerGas": {
            "type": "string"
          },
          "maxPriorityFeePerGas": {
            "type": "string"
          },
          "value": {
            "type": "string"
          },
          "input": {
            "type": "string"
          },
          "data": {
            "type": "string"
          },
          "nonce": {
            "type": "string"
          },
          "chainId": {
            "type": "string"
          },
          "accessList": {
            "type": "string"
          },
          "authorizationList": {
            "type": "string"
          }
        },
        "description": "Transaction call object."
      }
    },
    {
      "name": "block",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    }
  ]
},
{
  "name": "eth_feeHistory",
  "params": [
    {
      "name": "block_count",
      "required": true,
      "schema": {
        "type": "quantity",
        "default": "0x1",
        "description": "Number of blocks in the requested range (hex-encoded integer)."
      }
    },
    {
      "name": "newest_block",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest",
        "description": "Highest block number (hex) or tag: `latest`, `safe`, `finalized`, `pending`."
      }
    },
    {
      "name": "reward_percentiles",
      "required": true,
      "schema": {
        "type": "number-array",
        "default": null,
        "description": "Array of percentile values (floats between 0 and 100) to sample effective priority fees. Can be `null`."
      }
    }
  ]
},
{
  "name": "eth_fillTransaction",
  "params": [
    {
      "name": "tx",
      "required": true,
      "schema": {
        "type": "object",
        "properties": {
          "from": {
            "type": "string"
          },
          "to": {
            "type": "string"
          },
          "gas": {
            "type": "string"
          },
          "maxFeePerGas": {
            "type": "string"
          },
          "maxPriorityFeePerGas": {
            "type": "string"
          },
          "value": {
            "type": "string"
          },
          "input": {
            "type": "string"
          },
          "data": {
            "type": "string"
          },
          "nonce": {
            "type": "string"
          },
          "chainId": {
            "type": "string"
          },
          "accessList": {
            "type": "string"
          },
          "authorizationList": {
            "type": "string"
          }
        },
        "description": "Transaction call object."
      }
    }
  ]
},
{
  "name": "eth_gasPrice",
  "params": []
},
{
  "name": "eth_getBalance",
  "params": [
    {
      "name": "account",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
        "description": "20-byte account address (hex-encoded)."
      }
    },
    {
      "name": "block_number",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    }
  ]
},
{
  "name": "eth_getBlockByHash",
  "params": [
    {
      "name": "block_hash",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
        "description": "32-byte block hash (hex-encoded)."
      }
    },
    {
      "name": "return_full_txns",
      "required": true,
      "schema": {
        "type": "boolean",
        "description": "If `true`, returns full transaction objects; if `false`, returns only transaction hashes."
      }
    }
  ]
},
{
  "name": "eth_getBlockByNumber",
  "params": [
    {
      "name": "block_number",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    },
    {
      "name": "return_full_txns",
      "required": true,
      "schema": {
        "type": "boolean",
        "description": "If `true`, returns full transaction objects; if `false`, returns only transaction hashes."
      }
    }
  ]
},
{
  "name": "eth_getBlockReceipts",
  "params": [
    {
      "name": "block",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    }
  ]
},
{
  "name": "eth_getBlockTransactionCountByHash",
  "params": [
    {
      "name": "block_hash",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
        "description": "32-byte block hash (hex-encoded)."
      }
    }
  ]
},
{
  "name": "eth_getBlockTransactionCountByNumber",
  "params": [
    {
      "name": "block_tag",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest",
        "description": "Block number (hex) or tag: `latest`, `safe`, `finalized`, `pending`."
      }
    }
  ]
},
{
  "name": "eth_getCode",
  "params": [
    {
      "name": "account",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
        "description": "20-byte account address (hex-encoded)."
      }
    },
    {
      "name": "block",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    }
  ]
},
{
  "name": "eth_getLogs",
  "params": [
    {
      "name": "filters",
      "required": true,
      "schema": {
        "type": "object",
        "properties": {
          "fromBlock": {
            "type": "string"
          },
          "toBlock": {
            "type": "string"
          },
          "address": {
            "type": "string"
          },
          "topics": {
            "type": "number-array"
          }
        },
        "description": "Log filter object."
      }
    }
  ]
},
{
  "name": "eth_getStorageAt",
  "params": [
    {
      "name": "account",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
        "description": "20-byte account address (hex-encoded)."
      }
    },
    {
      "name": "position",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0x0",
        "description": "Storage position (hex-encoded 256-bit integer)."
      }
    },
    {
      "name": "block",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    }
  ]
},
{
  "name": "eth_getTransactionByBlockHashAndIndex",
  "params": [
    {
      "name": "block_hash",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
        "description": "32-byte block hash (hex-encoded)."
      }
    },
    {
      "name": "index",
      "required": true,
      "schema": {
        "type": "quantity",
        "default": "0x1",
        "description": "Transaction index position (hex-encoded integer)."
      }
    }
  ]
},
{
  "name": "eth_getTransactionByBlockNumberAndIndex",
  "params": [
    {
      "name": "block_tag",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest",
        "description": "Block number (hex) or tag: `latest`, `safe`, `finalized`, `pending`."
      }
    },
    {
      "name": "index",
      "required": true,
      "schema": {
        "type": "quantity",
        "default": "0x1",
        "description": "Transaction index position (hex-encoded integer)."
      }
    }
  ]
},
{
  "name": "eth_getTransactionByHash",
  "params": [
    {
      "name": "tx_hash",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
        "description": "32-byte transaction hash (hex-encoded)."
      }
    }
  ]
},
{
  "name": "eth_getTransactionCount",
  "params": [
    {
      "name": "account",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
        "description": "20-byte account address (hex-encoded)."
      }
    },
    {
      "name": "block",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    }
  ]
},
{
  "name": "eth_getTransactionReceipt",
  "params": [
    {
      "name": "tx_hash",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
        "description": "32-byte transaction hash (hex-encoded)."
      }
    }
  ]
},
{
  "name": "eth_maxPriorityFeePerGas",
  "params": []
},
{
  "name": "eth_sendRawTransaction",
  "params": [
    {
      "name": "hex_tx",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0x",
        "description": "Signed transaction data (hex-encoded)."
      }
    }
  ]
},
{
  "name": "eth_sendRawTransactionSync",
  "params": [
    {
      "name": "hex_tx",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0x",
        "description": "Signed transaction data (hex-encoded)."
      }
    },
    {
      "name": "timeout_ms",
      "required": true,
      "schema": {
        "type": "integer",
        "default": null
      }
    }
  ]
},
{
  "name": "eth_syncing",
  "params": []
},
{
  "name": "debug_getRawBlock",
  "params": [
    {
      "name": "block",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    }
  ]
},
{
  "name": "debug_getRawHeader",
  "params": [
    {
      "name": "block",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    }
  ]
},
{
  "name": "debug_getRawReceipts",
  "params": [
    {
      "name": "block",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    }
  ]
},
{
  "name": "debug_getRawTransaction",
  "params": [
    {
      "name": "tx_hash",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
        "description": "32-byte transaction hash (hex-encoded)."
      }
    }
  ]
},
{
  "name": "debug_traceBlockByHash",
  "params": [
    {
      "name": "block_hash",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
        "description": "32-byte block hash (hex-encoded)."
      }
    },
    {
      "name": "tracer",
      "required": true,
      "schema": {
        "type": "object",
        "properties": {
          "tracer": {
            "type": "string",
            "enum": [
              "callTracer",
              "prestateTracer"
            ]
          },
          "tracerConfig": {
            "type": "object",
            "properties": {
              "onlyTopCall": {
                "type": "boolean",
                "description": "onlyTopCall for callTracer, ignored for prestateTracer",
                "default": false
              },
              "diffMode": {
                "type": "boolean",
                "description": "diff mode for prestateTracer, ignored for callTracer",
                "default": false
              },
              "withLog": {
                "type": "boolean",
                "description": "log for callTracer, ignored for prestateTracer",
                "default": false
              }
            }
          }
        },
        "description": "Tracer configuration object."
      }
    }
  ]
},
{
  "name": "debug_traceBlockByNumber",
  "params": [
    {
      "name": "block_number",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    },
    {
      "name": "tracer",
      "required": true,
      "schema": {
        "type": "object",
        "properties": {
          "tracer": {
            "type": "string",
            "enum": [
              "callTracer",
              "prestateTracer"
            ]
          },
          "tracerConfig": {
            "type": "object",
            "properties": {
              "onlyTopCall": {
                "type": "boolean",
                "description": "onlyTopCall for callTracer, ignored for prestateTracer",
                "default": false
              },
              "diffMode": {
                "type": "boolean",
                "description": "diff mode for prestateTracer, ignored for callTracer",
                "default": false
              },
              "withLog": {
                "type": "boolean",
                "description": "log for callTracer, ignored for prestateTracer",
                "default": false
              }
            }
          }
        },
        "description": "Tracer configuration object."
      }
    }
  ]
},
{
  "name": "debug_traceCall",
  "params": [
    {
      "name": "transaction",
      "required": true,
      "schema": {
        "type": "object",
        "properties": {
          "from": {
            "type": "string"
          },
          "to": {
            "type": "string"
          },
          "gas": {
            "type": "string"
          },
          "maxFeePerGas": {
            "type": "string"
          },
          "maxPriorityFeePerGas": {
            "type": "string"
          },
          "value": {
            "type": "string"
          },
          "input": {
            "type": "string"
          },
          "data": {
            "type": "string"
          },
          "nonce": {
            "type": "string"
          },
          "chainId": {
            "type": "string"
          },
          "accessList": {
            "type": "string"
          },
          "authorizationList": {
            "type": "string"
          }
        },
        "description": "Transaction call object."
      }
    },
    {
      "name": "block",
      "required": true,
      "schema": {
        "type": "block-tag",
        "default": "latest"
      }
    },
    {
      "name": "tracer",
      "required": true,
      "schema": {
        "type": "object",
        "properties": {
          "tracer": {
            "type": "string",
            "enum": [
              "callTracer",
              "prestateTracer"
            ]
          },
          "tracerConfig": {
            "type": "object",
            "properties": {
              "onlyTopCall": {
                "type": "boolean",
                "description": "onlyTopCall for callTracer, ignored for prestateTracer",
                "default": false
              },
              "diffMode": {
                "type": "boolean",
                "description": "diff mode for prestateTracer, ignored for callTracer",
                "default": false
              },
              "withLog": {
                "type": "boolean",
                "description": "log for callTracer, ignored for prestateTracer",
                "default": false
              }
            }
          }
        },
        "description": "Tracer configuration object."
      }
    }
  ]
},
{
  "name": "debug_traceTransaction",
  "params": [
    {
      "name": "tx_hash",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
        "description": "32-byte transaction hash (hex-encoded)."
      }
    },
    {
      "name": "tracer",
      "required": true,
      "schema": {
        "type": "object",
        "properties": {
          "tracer": {
            "type": "string",
            "enum": [
              "callTracer",
              "prestateTracer"
            ]
          },
          "tracerConfig": {
            "type": "object",
            "properties": {
              "onlyTopCall": {
                "type": "boolean",
                "description": "onlyTopCall for callTracer, ignored for prestateTracer",
                "default": false
              },
              "diffMode": {
                "type": "boolean",
                "description": "diff mode for prestateTracer, ignored for callTracer",
                "default": false
              },
              "withLog": {
                "type": "boolean",
                "description": "log for callTracer, ignored for prestateTracer",
                "default": false
              }
            }
          }
        },
        "description": "Tracer configuration object."
      }
    }
  ]
},
{
  "name": "admin_ethCallStatistics",
  "params": []
},
{
  "name": "net_version",
  "params": []
},
{
  "name": "txpool_statusByAddress",
  "params": [
    {
      "name": "address",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
        "description": "20-byte account address (hex-encoded)."
      }
    }
  ]
},
{
  "name": "txpool_statusByHash",
  "params": [
    {
      "name": "hash",
      "required": true,
      "schema": {
        "type": "string",
        "default": "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
        "description": "32-byte transaction hash (hex-encoded)."
      }
    }
  ]
},
{
  "name": "web3_clientVersion",
  "params": []
}
]}
/>