> 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/tr/referans/json-rpc.md).

# JSON-RPC Desteği

Rome EVM uç noktaları tarafından desteklenen Ethereum JSON-RPC yöntemleri ve Rome'a özgü davranışlar — Foundry, Hardhat, ethers, viem ve MetaMask için.

Rome EVM uç noktaları standart Ethereum JSON-RPC konuşur. Foundry, Hardhat, ethers, viem ve MetaMask, Rome ile herhangi bir EVM zincirinde çalıştıkları gibi çalışır. Bu sayfa, desteklenenleri ve bilinmeye değer birkaç Rome'a özgü davranışı listeler.

## Desteklenen yöntemler

**Çekirdek (durum ve yürütme):** `eth_chainId`, `eth_blockNumber`, `eth_getBalance`, `eth_getCode`, `eth_getStorageAt`, `eth_getTransactionCount`, `eth_call`, `eth_estimateGas`, `eth_gasPrice`, `eth_maxPriorityFeePerGas`, `eth_feeHistory`.

**Bloklar ve işlemler:** `eth_getBlockByNumber`, `eth_getBlockByHash`, `eth_getBlockReceipts`, `eth_getTransactionByHash`, `eth_getTransactionReceipt`, `eth_sendRawTransaction`, block-by-index/count varyantları.

**Günlükler ve filtreler:** `eth_getLogs`, `eth_newFilter`, `eth_newBlockFilter`, `eth_getFilterChanges`, `eth_getFilterLogs`, `eth_uninstallFilter`.

**WebSocket abonelikleri:** `eth_subscribe` / `eth_unsubscribe` (`newHeads`, `logs`). Bkz. [WebSocket Abonelikleri](https://docs.rome.builders/tr/gelistirici-kilavuzlari/websocket-subscriptions.md).

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

**Küçük introspection yöntemleri:** `rpc_modules` (listeler `debug`, `eth`, `net`, `rome`, `rpc`, `txpool`, `web3`), `eth_syncing` (her zaman `false`), `eth_accounts` (her zaman boş bir liste), `eth_getUncleCountByBlockNumber`, `eth_getUncleCountByBlockHash`, `eth_getUncleByBlockNumberAndIndex` ve `eth_getUncleByBlockHashAndIndex` (uncle yok, bu yüzden sayılar `0x0` ve aramalar şunu döndürür: `null`), `eth_newPendingTransactionFilter` (kabul edilir, ancak herkese açık bir mempool olmadığı için asla hash döndürmez), ve `txpool_status`, her zaman şunu döndürür: `{"pending":"0x0","queued":"0x0"}` çünkü herkese açık bir mempool yok.

**İzleme:** `debug_traceRomeTransaction` bir işlem karma değeri alır ve birkaç çağrıyı tek bir toplu işte birleştiren bir işlem için her alt çağrı ve her CPI bazında dökümü döndürür. Sıradan işlemler `null`döndürür; bilinmeyen ya da henüz indekslenmemiş bir karma da aynı şekilde.

### Desteklenmiyor

`debug_traceTransaction` / `trace_*` (Ethereum tarzı işlem izleme; bunlar şunu döndürür: `-32601`), `eth_getProof`, `eth_createAccessList`, `eth_blobBaseFee` (blob işlemi yok), ve `txpool_*` dışındaki yöntemler `txpool_status` (herkese açık mempool yok). `newPendingTransactions` abonelikler kabul edilir ama hiçbir zaman yayın yapmaz.

## Rome uzantı yöntemleri

Standart Ethereum RPC'nin ötesinde, proxy şunları sunar: `rome_*` yöntemler:

| Yöntem                            | Amaç                                                                                                                                                                                                                             |
| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome_emulateTx`                  | Bir işlemi zincir dışında emüle et (Solana yürütme sonucunu döndürür)                                                                                                                                                            |
| `rome_emulateTxWithPayer`         | Belirli bir ödeyiciyle emüle et                                                                                                                                                                                                  |
| `rome_emulateCallAccounts`        | Bir çağrının dokunduğu Solana hesaplarını emüle et ve döndür                                                                                                                                                                     |
| `rome_emulateRegRollup`           | Bir rollup kaydını emüle et                                                                                                                                                                                                      |
| `rome_getResources`               | Proxy kaynak havuzu durumunu raporla (ödeyenler, tutucular)                                                                                                                                                                      |
| `rome_mintId`                     | Bir ERC-20 sarmalayıcısının arkasındaki SPL mint'ini çöz                                                                                                                                                                         |
| `rome_buildInfo`                  | Proxy derleme + zincir üstü program bilgisi                                                                                                                                                                                      |
| `rome_isCompatible`               | Proxy/program uyumluluğunu denetle                                                                                                                                                                                               |
| `rome_solanaTxForEvmTx`           | Bir EVM işlem hash'i için Solana işlemlerini al                                                                                                                                                                                  |
| `rome_sendUnsignedTransaction`    | İmzasız bir işlem gönder (sentetik gönderen akışları)                                                                                                                                                                            |
| `rome_composeUnsignedAtomicV1`    | Bir Solana cüzdanının Ed25519 imzası tarafından yetkilendirilmiş imzasız bir EIP-1559 gövdesi için tek bir Solana v1 işlemi oluştur; cüzdan bunu imzalar ve uygulama yayınlar. Çağrı tek bir atomik işleme sığmadığında reddeder |
| `rome_composeUnsignedIterativeV1` | Aynı şey, ancak her bacağı döndürür (sığıyorsa atomik, yoksa yinelemeli bacaklar); cüzdan her birini imzalar ve bunları `rome_submitSignedV1Plan`                                                                                |
| `rome_submitSignedV1Plan`         | Bir imzalı planı yayınla (64 bacağa kadar); proxy yalnızca aktarım katmanıdır, cüzdan ücret ödeyicisi olarak kalır                                                                                                               |
| `rome_relayUnsignedV1`            | Tek bir cüzdan imzası, proxy'nin ödeyicisi bacakları yönlendirir; sentetik, Rome gazını öder (önce şununla fonlayın `rome_composeExternalDepositV1`). EVM işlem hash'ini döndürür                                                |
| `rome_composeExternalDepositV1`   | Cüzdandan gelen token'larla sentetik'in yerel gaz bakiyesini kredilendiren tek bir cüzdan imzalı işlem                                                                                                                           |

## Rome'a özgü davranışlar

### Gaz Solana'dan türetilir — tahmin et, sabit kodlama yapma

Rome, yürütmeyi Solana compute unit'leri ile ölçer; bu, EVM gazı olarak görünür. Bir yazma işleminin maliyetinin çoğu, Solana hesapları oluşturmaktır: hiç kullanılmamış bir alıcı, yeni bir token hesabı, dağıtılmış bir sözleşme. Bu hesaplar tahminin bir parçasıdır. Pratik sonuçlar:

* **Kullanın `eth_estimateGas`, ve asla sabit kodlama yapma `21000`.** Standart araçlar (`forge create`, `cast`, Hardhat, ethers, viem, MetaMask) zaten bunu çağırır ve kullanılabilir bir değer alır. Solana programlarına dokunan çağrılar için bir marj ekleyin (SDK'nin `submitRomeTx` 1,3x ile doldurur) ve tahminin kendisi geri dönerse bir gas üst sınırı belirleyin. Sabit kodlanmış bir `21000` limit, yazma hesaplar oluşturduğunda başarısız olur; örneğin daha önce hiç kullanılmamış bir adrese yapılan transferde.
* **Rome, gerçekte kullanılan gazı ücretlendirir.** Aşağıdaki ölçümlerde kullanılan gaz hiçbir zaman tahmini aşmadı, bu yüzden yapılan işten daha yüksek bir tahmin size farkı maliyet olarak yansıtmaz.
* **Araçlarınızın eklediği marjı bırakın.** Tahmin ile işlemin zincire düştüğü an arasında durum değişebilir ve Solana CPI'ları yapan bir çağrının tahmini düşük çıkabilir. SDK'nin `submitRomeTx` 1,3x ile tahmini bir marj olarak doldurur.

Hadrian üzerinde ölçüldü, o sırada gaz fiyatı yaklaşık 10,4 gwei idi:

| Yazma                                                 | `eth_estimateGas` | Kullanılan gaz |
| ----------------------------------------------------- | ----------------- | -------------- |
| Hiç kullanılmamış bir adrese yerel transfer           | 1,086,961         | 1,086,961      |
| Var olan bir adrese yerel transfer                    | 21,000            | 10,001         |
| Hiç kullanılmamış bir adrese wUSDC transferi          | 2,544,921         | 2,544,921      |
| Gazı wUSDC'ye sar (`withdraw_to_ata`)                 | 21,000            | 10,001         |
| Sarma izni (`approve_spl` Helper precompile üzerinde) | 21,000            | 10,001         |
| 10 baytlık bir sözleşme dağıt                         | 1,147,921         | 1,147,921      |

Bunlar tek bir zincirde tek ölçümlerdir, sınır değil. Sayılar, bir çağrının hangi hesapları oluşturmak zorunda olduğuna bağlıdır; bu yüzden onları kopyalamak yerine her yazma işlemini tahmin edin.

### `forge script --broadcast` gerektirir `--skip-simulation`

`forge script` yayınlama gaz limitini bir **yerel** simülasyondan belirler; bu, Rome'un gaz modeline karşı yetersiz kalır. Şunu ekleyin `--skip-simulation` böylece Foundry zincirin `eth_estimateGas` kullanır:

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

`forge create`, `cast send`, ve Hardhat etkilenmez — onlar zaten zincir üstünde tahmin ediyor.

### `eth_getLogs` aralık sınırı var (\~12.000 blok)

Infura, Alchemy ve diğer üretim RPC'leri gibi, `eth_getLogs` aşırı geniş blok aralıklarını reddeder (hata `-32005`). Sorgularınızı sınırlandırın:

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

Bir `queryFilter` bir aralık olmadan tüm geçmişi tarar ve sınırı aşar — açık bir `fromBlock`/`toBlock`. Kayıt tabanlı olay doğrulamaları (ör. bir tx'i bekleyip günlüklerini okumak) etkilenmez.

### Ücretler

`eth_gasPrice` gerçek, oracle'dan türetilmiş fiyatı döndürür; cüzdanlar (MetaMask dahil) bunu kullanır ve doğru ücretleri gösterir. Gönderilen ücret alanları esnek biçimde kabul edilir — hem legacy hem de EIP-1559 işlemleri standart araç varsayılanlarıyla zincire düşer.


---

# 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/tr/referans/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.
