> For the complete documentation index, see [llms.txt](https://docs.rome.builders/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rome.builders/de/referenz/json-rpc.md).

# JSON-RPC-Unterstützung

Von Rome-EVM-Endpunkten unterstützte Ethereum-JSON-RPC-Methoden plus Rome-spezifisches Verhalten — für Foundry, Hardhat, ethers, viem und MetaMask.

Die Rome-EVM-Endpunkte sprechen standardmäßiges Ethereum-JSON-RPC. Foundry, Hardhat, ethers, viem und MetaMask funktionieren gegen Rome genauso wie auf jeder anderen EVM-Chain. Diese Seite listet auf, was unterstützt wird, und die wenigen Rome-spezifischen Verhaltensweisen, die man kennen sollte.

## Unterstützte Methoden

**Kern (Zustand & Ausführung):** `eth_chainId`, `eth_blockNumber`, `eth_getBalance`, `eth_getCode`, `eth_getStorageAt`, `eth_getTransactionCount`, `eth_call`, `eth_estimateGas`, `eth_gasPrice`, `eth_maxPriorityFeePerGas`, `eth_feeHistory`.

**Blöcke & Transaktionen:** `eth_getBlockByNumber`, `eth_getBlockByHash`, `eth_getBlockReceipts`, `eth_getTransactionByHash`, `eth_getTransactionReceipt`, `eth_sendRawTransaction`, Varianten nach Blockindex/-Anzahl.

**Logs & Filter:** `eth_getLogs`, `eth_newFilter`, `eth_newBlockFilter`, `eth_getFilterChanges`, `eth_getFilterLogs`, `eth_uninstallFilter`.

**WebSocket-Abonnements:** `eth_subscribe` / `eth_unsubscribe` (`newHeads`, `logs`). Siehe [WebSocket-Abonnements](https://docs.rome.builders/de/entwicklerleitfaden/websocket-subscriptions.md).

**Net / web3:** `net_version`, `net_listening`, `net_peerCount`, `web3_clientVersion`.

**Kleine Introspektionsmethoden:** `rpc_modules` (listet auf `debug`, `eth`, `net`, `rome`, `rpc`, `txpool`, `web3`), `eth_syncing` (immer `false`), `eth_accounts` (immer eine leere Liste), `eth_getUncleCountByBlockNumber`, `eth_getUncleCountByBlockHash`, `eth_getUncleByBlockNumberAndIndex` und `eth_getUncleByBlockHashAndIndex` (keine Uncles, daher sind die Zähler `0x0` und Abfragen geben `null`), `eth_newPendingTransactionFilter` (akzeptiert, gibt aber nie Hashes zurück, da es keinen öffentlichen Mempool gibt), und `txpool_status`, das immer zurückgibt `{"pending":"0x0","queued":"0x0"}` da es keinen öffentlichen Mempool gibt.

**Tracing:** `debug_traceRomeTransaction` nimmt einen Transaktions-Hash und gibt die Aufschlüsselung pro Sub-Call und pro CPI für eine Transaktion zurück, die mehrere Aufrufe in einem Batch bündelt. Gewöhnliche Transaktionen geben `null`, ebenso wie ein Hash, der unbekannt ist oder noch nicht indiziert wurde.

### Nicht unterstützt

`debug_traceTransaction` / `trace_*` (Ethereum-ähnliches Transaktions-Tracing; sie geben `-32601`), `eth_getProof`, `eth_createAccessList`, `eth_blobBaseFee` (keine Blob-Transaktionen), und die `txpool_*` Methoden außer `txpool_status` (kein öffentlicher Mempool). `newPendingTransactions` Abonnements werden akzeptiert, senden aber nie Ereignisse.

## Rome-Erweiterungsmethoden

Zusätzlich zum standardmäßigen Ethereum-RPC stellt der Proxy `rome_*` Methoden bereit:

| Methode                           | Zweck                                                                                                                                                                                                                                                                         |
| --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome_emulateTx`                  | Eine Transaktion off-chain emulieren (gibt das Solana-Ausführungsergebnis zurück)                                                                                                                                                                                             |
| `rome_emulateTxWithPayer`         | Gegen einen bestimmten Payer emulieren                                                                                                                                                                                                                                        |
| `rome_emulateCallAccounts`        | Emulieren und die Solana-Konten zurückgeben, die ein Aufruf berührt                                                                                                                                                                                                           |
| `rome_emulateRegRollup`           | Eine Rollup-Registrierung emulieren                                                                                                                                                                                                                                           |
| `rome_getResources`               | Den Zustand des Proxy-Ressourcenpools melden (Payer, Holder)                                                                                                                                                                                                                  |
| `rome_mintId`                     | Die SPL-Mint hinter einem ERC-20-Wrapper auflösen                                                                                                                                                                                                                             |
| `rome_buildInfo`                  | Proxy-Build + On-Chain-Programminfo                                                                                                                                                                                                                                           |
| `rome_isCompatible`               | Proxy-/Programmkompatibilität prüfen                                                                                                                                                                                                                                          |
| `rome_solanaTxForEvmTx`           | Die Solana-Transaktion(en) für einen EVM-Transaktions-Hash abrufen                                                                                                                                                                                                            |
| `rome_sendUnsignedTransaction`    | Eine nicht signierte Transaktion absenden (Synthetic-Sender-Flows)                                                                                                                                                                                                            |
| `rome_composeUnsignedAtomicV1`    | Eine Solana-v1-Transaktion für einen unsignierten EIP-1559-Body zusammenstellen, autorisiert durch die Ed25519-Signatur einer Solana-Wallet; die Wallet signiert sie und die App broadcastet sie. Verweigert, wenn der Aufruf nicht in eine einzige atomare Transaktion passt |
| `rome_composeUnsignedIterativeV1` | Dasselbe, aber gibt jeden Schritt zurück (atomar, wenn es passt, sonst die iterativen Schritte); die Wallet signiert jeden und übermittelt sie mit `rome_submitSignedV1Plan`                                                                                                  |
| `rome_submitSignedV1Plan`         | Einen signierten Plan broadcasten (bis zu 64 Schritte); der Proxy ist nur das Transportmedium, die Wallet bleibt Fee-Payer                                                                                                                                                    |
| `rome_relayUnsignedV1`            | Eine Wallet-Signatur, der Payer des Proxys steuert die Schritte; das Synthetic bezahlt Rome-Gas (lade es zuerst auf mit `rome_composeExternalDepositV1`). Gibt den EVM-Transaktions-Hash zurück                                                                               |
| `rome_composeExternalDepositV1`   | Eine von der Wallet signierte Transaktion, die das native Gas-Guthaben des Synthetic aus den Tokens der Wallet auflädt                                                                                                                                                        |

## Rome-spezifische Verhaltensweisen

### Gas ist von Solana abgeleitet — schätzen, nicht fest codieren

Rome misst die Ausführung in Solana-Compute-Units, die als EVM-Gas dargestellt werden. Der Großteil dessen, was ein Write kostet, ist das Erstellen von Solana-Konten: ein Empfänger, der noch nie verwendet wurde, ein neues Token-Konto, ein bereitgestellter Contract. Diese Konten sind Teil der Schätzung. Praktische Konsequenzen:

* **Verwenden Sie `eth_estimateGas`, und niemals fest codieren `21000`.** Standard-Tooling (`forge create`, `cast`, Hardhat, ethers, viem, MetaMask) ruft es bereits auf und erhält einen nutzbaren Wert. Für Aufrufe, die Solana-Programme berühren, füge einen Aufschlag hinzu (das SDKs `submitRomeTx` erhöht um das 1,3-Fache) und setze ein Gas-Limit, wenn schon die Schätzung selbst reverts. Ein fest codiertes `21000` Limit schlägt fehl, sobald der Write Konten erstellt, zum Beispiel bei einer Überweisung an eine Adresse, die noch nie verwendet wurde.
* **Rome berechnet das tatsächlich verwendete Gas.** In den Messungen unten war das verwendete Gas nie höher als die Schätzung, daher kostet dich eine Schätzung, die höher ist als die tatsächlich ausgeführte Arbeit, nicht die Differenz.
* **Lass den Aufschlag deines Toolings stehen.** Der Zustand kann sich zwischen der Schätzung und dem Zeitpunkt ändern, zu dem die Transaktion landet, und die Schätzung für einen Aufruf, der Solana-CPIs ausführt, kann zu niedrig ausfallen. Das SDKs `submitRomeTx` erhöht die Schätzung als Puffer um das 1,3-Fache.

Gemessen auf Hadrian, bei einem Gaspreis von damals etwa 10,4 gwei:

| Write                                                         | `eth_estimateGas` | Verwendetes Gas |
| ------------------------------------------------------------- | ----------------- | --------------- |
| Native Transfer an eine nie verwendete Adresse                | 1,086,961         | 1,086,961       |
| Native Transfer an eine bestehende Adresse                    | 21,000            | 10,001          |
| wUSDC-Transfer an eine nie verwendete Adresse                 | 2,544,921         | 2,544,921       |
| Gas in wUSDC wrappen (`withdraw_to_ata`)                      | 21,000            | 10,001          |
| Wrapper-Genehmigung (`approve_spl` auf dem Helper-Precompile) | 21,000            | 10,001          |
| Einen 10-Byte-Contract bereitstellen                          | 1,147,921         | 1,147,921       |

Das sind Einzelmessungen auf einer Chain, keine Grenzwerte. Die Zahlen hängen davon ab, welche Konten ein Aufruf erstellen muss, also schätze jeden Write einzeln, statt sie zu übernehmen.

### `forge script --broadcast` benötigt `--skip-simulation`

`forge script` setzt sein Broadcast-Gas-Limit aus einer **lokalen** Simulation, die im Vergleich zu Romes Gasmodell zu niedrig ansetzt. Füge `--skip-simulation` hinzu, damit Foundry stattdessen den Chain-Wert `eth_estimateGas` verwendet:

```bash
forge script script/Deploy.s.sol:Deploy \
  --rpc-url <RPC> --private-key $PRIVATE_KEY --broadcast --skip-simulation
```

`forge create`, `cast send`, und Hardhat sind nicht betroffen — sie schätzen bereits on-chain.

### `eth_getLogs` hat eine Bereichsbegrenzung (\~12.000 Blöcke)

Wie Infura, Alchemy und andere produktive RPCs, `eth_getLogs` lehnt zu breite Blockbereiche ab (Fehler `-32005`). Begrenze deine Abfragen:

```javascript
const latest = await provider.getBlockNumber();
const logs = await contract.queryFilter(filter, latest - 5000, latest);
```

Eine `queryFilter` ohne Bereich durchsucht die gesamte Historie und überschreitet das Limit — übergebe ein explizites `fromBlock`/`toBlock`. Receipt-basierte Event-Assertions (z. B. auf eine Tx warten und ihre Logs lesen) sind nicht betroffen.

### Gebühren

`eth_gasPrice` gibt den echten, vom Oracle abgeleiteten Preis zurück; Wallets (einschließlich MetaMask) verwenden ihn und zeigen korrekte Gebühren an. Übermittelte Fee-Felder werden großzügig akzeptiert — sowohl Legacy- als auch EIP-1559-Transaktionen landen mit den Standard-Tooling-Defaults.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.rome.builders/de/referenz/json-rpc.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
