> 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/gelistirici-kilavuzlari/call-evm-from-solana.md).

# Solana'dan EVM'yi çağırma

Bir Solana cüzdanının Rome üzerindeki EVM sözleşmelerini kullanmasına izin verin — Ethereum anahtarı gerekmez. Cüzdan imzalar ve işlemi Solana'ya gider.

tersi [EVM'den Solana'yı çağırma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-solana-from-evm.md): bir Solana cüzdanı (örneğin Solflare), herhangi bir EVM sözleşmesini Rome üzerinde doğrudan,  **Ethereum anahtarı olmadan**. Bu,  [Aerarium](https://docs.rome.builders/tr/rome-uzerindeki-uygulamalar/apps.md) Solana yerel kullanıcıların EVM kullanıcılarıyla aynı sözleşmeleri paylaşmasına olanak tanır.

Tek çağrılı yöntem SDK'nın `submitRomeTxV1`, burada proxy çağrı için tek bir Solana v1 işlemi oluşturur; bu sayfa mekanizmayı açıklar.

## Sentetik adresler

Bir Solana cüzdanının EVM kimliği onun **sentetik adresidir** — keccak256'nin son 20 baytı `keccak256` 32 baytlık Solana açık anahtarının:

```
synthetic_evm_address = keccak256(solana_pubkey)[12:]
```

Bu, `msg.sender` cüzdan bir sözleşmeyi çağırdığında kullanılan ve nonce ile depolamasının altında yer alan sabit kimliktir. Türetilme protokolde sabitlenmiştir, bu yüzden bir cüzdan her zaman aynı adrese eşlenir.

```javascript
import { syntheticAddress } from "@rome-protocol/sdk";
const from = syntheticAddress(solanaPubkey); // 0x… 20 bayt
```

## Sentetik bir geçiş aracıdır — hareketsizken hiçbir token tutmaz

Solana yerel bir kullanıcının harcanabilir bakiyesi onların **Solana cüzdanı** (SPL tokenları olarak), EVM tarafında tokenın **ERC20SPL sarmalayıcısı** (örn. `wUSDC`). Sentetik hareketsizken hiçbir şey tutmaz, bu yüzden değer akışı *içinden* onun üzerinden — her adım Solana cüzdanı tarafından imzalanır:

1. **Hazırlama (bir kez).** Yepyeni bir sentetiğin dış kimlik doğrulama PDA'sı `create_pda` çalıştırılır — ve aşağıdaki transferler bu PDA tarafından imzalanır. `submitRomeTxSolanaLane` ilk kullanımda onu otomatik olarak hazırlar (veya çağırın `provisionSynthetic` açık bir "Etkinleştir" adımı için; `isSyntheticProvisioned`). İle `submitRomeTxV1`, kontrol edin `isSyntheticProvisioned` ve gönderin `buildCreatePdaCall` onun üzerinden bir kez.
2. **Fonlama ayağı (cüzdan → sentetik).** Tokenı cüzdanın ATA'sından sentetiğin ATA'sına taşıyın — `ActivateAta` adımı, `buildFundLeg`tarafından oluşturulan `wrapper.balanceOf(synthetic)` bu bakiyeyi okur; böylece sentetik onu sıradan bir ERC-20 olarak (`transfer` / `transferFrom`) — **değil** yerel olarak `msg.value`, çünkü onu tutmaz.
3. **Çağrı(lar) (`DoTxUnsigned`).** Sentetik, EVM işlem(ler)ini yürütür — örn. `approve` ardından bir kasaya `yatırma` şunun aracılığıyla çeken `transferFrom`.
4. **Süpürme ayağı (sentetik → cüzdan).** Bir çekme / borç alma / talep işlemi tokenları sentetiğe düşürdükten sonra, `buildSweepLeg` bunları kullanıcının kendi cüzdan ATA'sına geri iter (`HelperProgram.transfer_spl`), böylece sentetik net olarak sıfıra iner.

Sonraki bölüm, daha eski olanın ne yaptığını açıklar `submitRomeTxSolanaLane` istemci tarafında oluşturur. `submitRomeTxV1` bunun yerine proxy'nin bir v1 işlem oluşturmasını sağlar; kodunuzda hesap keşfi, ComputeBudget veya hazine cüzdanı yoktur; bkz. [external-V1 uç noktaları](#the-external-v1-endpoints) aşağıda.

## Çağrının nasıl oluşturulduğu

`submitRomeTxSolanaLane` tüm bunları yapar. Mekanik:

1. **İmzalanmamış bir EIP-1559 işlemi oluşturun** ile `şuradan` = sentetik adres — secp256k1 imzası yok.
2. **Hesapları keşfet** — çağırın [`rome_emulateCallAccounts`](https://docs.rome.builders/tr/referans/json-rpc.md) çağrının `şuradan`, `şuraya`, `data`, **ve `value`** (çağrı ödeme kabul ediyorsa). `value` önemlidir: proxy *gerçek* çağrıyı simüle eder; bu nedenle değere bağlı herhangi bir depolama yazımı — örn. yeni bir mapping yuvası — ayrılır ve onun Solana hesabı döndürülür. Bunu atlayın ve o hesap eksik olur; bu durumda işlem şu hatayla başarısız olur: *"instruction modified data of a read-only account."*
3. **Solana işlemini birleştirin:** iki **ComputeBudget** komutları (Rome'un EVM'si yükseltilmiş bir CU sınırına ≈1,35M ve büyük bir heap çerçevesine ≈250 KB ihtiyaç duyar — Solana'nın varsayılanları hata verir) + **`DoTxUnsigned`** komutu (imzasız RLP + keşfedilen hesaplar) + zincir başına **hazine cüzdanı** (yürütme ona küçük bir ücret öder; keşif onu atlar, bu yüzden SDK onu ekler).
4. **Cüzdan imzalar ve gönderir.** Şu **Solana cüzdanı Solana işlemini (Ed25519) imzalar ve bunu proxy'ye değil Solana RPC'sine gönderir.** Solana çalışma zamanı imzayı doğrular; zincir üzerinde program `msg.sender` o imzalayıcıdan türetir. Yetki Ethereum imzası değil, Solana imzasıdır. (Proxy yalnızca 2. adımda emülasyon/keşif için kullanılır.)

Kullanıcının PDA'sı (`["EXTERNAL_AUTHORITY", synthetic_address]`) token hesaplarına sahiptir ve onlar adına SPL CPI'larını imzalar — böylece bir Solana kullanıcısı tamamen Solana cüzdanından temin, borç alma, takas ve LP yapabilir.

## external-V1 uç noktaları

`submitRomeTxV1` tek çağrılı yoldur: proxy'den oluşturulmuş bir v1 işlem ister, onu kontrol eder, cüzdana imzalatır ve Solana RPC'sine gönderir; çağrı sığmadığında proxy üzerinden iletir. Proxy, RPC yöntemleriyle aynı hattı sunar, bu yüzden herhangi bir istemci SDK olmadan kullanabilir (tam liste için [JSON-RPC Desteği](https://docs.rome.builders/tr/referans/json-rpc.md)):

* `rome_composeUnsignedAtomicV1(rlp, pubkey, signature)` — bir Solana v1 işlemi; cüzdan onu imzalar ve uygulama bunu Solana RPC'sine yayınlar. Çağrı tek bir atomik işleme sığmadığında reddedilir.
* `rome_composeUnsignedIterativeV1(rlp, pubkey, signature)` — yürütmenin her ayağı (sığıyorsa atomik, aksi halde yinelemeli ayaklar); cüzdan her birini imzalar, `rome_submitSignedV1Plan` bunları yayınlar. Uzun bir planın sınırları şuradadır: [İletilen çağrılar ve uzun çağrılar](#relayed-calls-and-long-calls).
* `rome_relayUnsignedV1(rlp, pubkey, signature)` — tek bir cüzdan imzası, proxy'nin ödeyicisi ayakları yürütür ve EVM işlem karmasını döndürür; sentetik Rome gazını öder, bu yüzden onu bir kez şununla fonlayın: `rome_composeExternalDepositV1`.

**Yetkilendirme imzası.** `rlp` çıplak 9 alanlı imzasız EIP-1559 gövdesidir. Cüzdan, Ed25519 anahtarıyla, ya ham 32 baytlık `keccak256(0x02 ‖ rlp)` ya da okunabilir mesajı

```
Rome authorization\n0x<64 küçük harfli onaltılık karakterden oluşan bu hash>
```

Her ikisi de kabul edilir; okunabilir biçim, bir cüzdanın bunu kendi `signMessage` isteminde okunaklı biçimde göstermesidir. Program, yürüttüğü gövdeden hash'i yeniden hesaplar ve imzalanan mesajın tam olarak bu iki biçimden biri olmasını ister; böylece bir gövde üzerindeki imza asla bir başkasını yetkilendiremez ve gövdenin nonce'u yeniden oynatmayı önler.

## İletilen çağrılar ve uzun çağrılar

Bazı çağrılar tek bir Solana işlemine sığmaz. Bu bölüm, o durumda ne olduğunu ve hangi sınırların geçerli olduğunu açıklar.

### Atomik oluşturucu reddettiğinde

`rome_composeUnsignedAtomicV1` tek bir atomik işleme sığmayan bir çağrıyı reddeder. `submitRomeTxV1` ardından çağrıyı proxy üzerinden **aynı** yetkilendirme imzasıyla iletir, böylece cüzdandan ikinci kez istenmez. Sonuç `route: "relay"` ve Solana `imzası`. Geçirin `relayOnRefusal: false` bunun yerine reddi bir hata olarak almak için, ya da `relayV1` bilerek aktarmak için kendiniz çağırın.

Aktarılan bir çağrı hakkında bilinmesi gereken üç şey:

* **Sentetik gazı öder.** Aktarma yolunda proxy, Solana işlemlerini gönderir ve bunların ücretini öder; çağrı, zincirin yerel gaz tokenı ile sentetiğin bakiyesinden karşılanır. Bakiye en az `gasLimit × maxFeePerGas`. `fundSyntheticGas(deps, amountWei)` onu zincirin gaz tokenındaki cüzdanın kendi token hesabından doldurur (Hadrian ve Rubicon'da USDC); cüzdan tek bir düz v1 işlemini imzalar ve Solana ücreti için biraz SOL'a ihtiyaç duyar. `amountWei` zincirin 18 ondalıklı wei birimindedir ve 10^12'nin katı olmalıdır, yoksa proxy bunu reddeder. SDK olmadan, `rome_composeExternalDepositV1` aynı işlemi oluşturur.
* **Bir geri dönüş hata fırlatmaz.** EVM tarafında geri dönen bir aktarılmış çağrı normal şekilde sonuçlanır, `receipt.status === "0x0"`. Kontrol edin `receipt?.status === "0x1"` çağrıyı tamamlanmış saymadan önce. `makbuz` şu `null` makbuz zamanında görünmediyse.
* **`relayOnRefusal: false` SDK'de yapılan bir seçimdir, bir kilit değil.** Proxy, o yük için yetkilendirme imzasını zaten tutar ve onu iki yoldan biriyle çalıştırabilir, `gasLimit × maxFeePerGas`.

```javascript
const res = await submitRomeTxV1(deps, { to, data, value });
if (res.route === "relay" && res.receipt?.status !== "0x1") {
  // geri dönen bir aktarılmış çağrı hata fırlatmaz
}
```

### Uzun çağrılar

Birden fazla işlem gerektiren bir çağrı yinelemeli bir oturum olarak çalışır: program her Solana işlemine sığan kadar EVM adımı yürütür ve aralarında durumunu kaydeder. Bunu bir Solana cüzdanından sürmenin iki yolu vardır:

* **Onu aktarın.** `rome_relayUnsignedV1` tek bir cüzdan imzası alır ve proxy'nin ödeyicisi her ayağı gönderir. Sentetik, yukarıda anlatıldığı gibi gazı öder.
* **Ayakları kendiniz imzalayın.** `rome_composeUnsignedIterativeV1` boş bir imza yuvasıyla her ayağı döndürür, cüzdan her birini imzalar ve `rome_submitSignedV1Plan` bunları sırayla yayınlar. Bir cüzdanın tek seferde bir işlem imzaladığı durumda, yetkilendirme imzasının üstüne her ayak için bir kez istem gelir. Cüzdan her ayakta Solana ücretini öder.

Sınırlar:

| Limit                                         | Değer          | Kaynağı                                                                                                               |
| --------------------------------------------- | -------------- | --------------------------------------------------------------------------------------------------------------------- |
| Tek bir `rome_submitSignedV1Plan` çağrıda     | 64             | Proxy daha uzun bir planı reddeder                                                                                    |
| Yinelemeli oluşturucunun planlayacağı ayaklar | 128            | Rust Rome SDK'sinin yinelemeli oluşturucusundaki üst sınır, planı da sınırlar `rome_composeUnsignedIterativeV1` döner |
| Bir oturumdaki yinelemeler                    | 160            | Rome EVM programı; bunun ötesinde oturum sürdürmeyi bırakır, hesap kilitlerini serbest bırakır ve sona erer           |
| Solana işlem boyutu ve hesapları              | 4 KB, 64 adres | Her ayak bir Solana v1 işlemidir                                                                                      |

Gerçek çağrıların çoğu bu üst sınırların çok altında ayakta tamamlanır. Cüzdan imzalı bir plandaki 64 işlem sınırıyla ilk karşılaşacağınız budur. Bundan daha fazla ayak gerektiren bir çağrı şunun üzerinden yayınlanamaz `rome_submitSignedV1Plan`.

Uzun bir çağrı legacy-track CPI'ları yapamaz. Legacy precompile'larda (`0xff…08`, `0xff…09` ve `0x42…16`) yinelemeli bir oturumda reddedilir `CpiProhibitedInIterativeTx`. Solana durumunun okumaları ve cached-track precompile'ları (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`) çalışır. Legacy-track CPI yapan bir çağrı, hangi hat gönderirse göndersin, tek bir atomik işleme sığmalıdır. Bkz. [Kısıtlar](https://docs.rome.builders/tr/temel-kavramlar/constraints.md) ve [Hesaplama Bütçesi](https://docs.rome.builders/tr/temel-kavramlar/compute-budget.md).

## Referans uygulamalar

* **Aerarium** — Compound v3'ü (teminat yatırma / borç alma) bir Solana cüzdanından üzerinden yönlendirir `DoTxUnsigned`. Yukarıda açıklanan eski işlem hattı için referanstır, bunun için değil `submitRomeTxV1`.
* **Rome DEX** bu sayfanın bir örneği değildir: onun Solana tarafı, cüzdanın doğrudan imzaladığı yerel bir Solana programıdır ve EVM tarafı aynı havuzu paylaşır.

Aerarium'un ikinci bir cüzdana ihtiyacı yoktur — sentetik adres, tek bir Solana anahtarını birinci sınıf bir EVM hesabı haline getirir. v1 kalıbı için şunu izleyin [Çift hatlı bir uygulama oluşturma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/dual-lane-app.md).

## Sırada Ne Var

* [EVM'den Solana'yı çağırma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-solana-from-evm.md) — diğer yön, CPI aracılığıyla
* [Token Birlikte Çalışabilirliği](https://docs.rome.builders/tr/temel-kavramlar/token-interop.md) — bakiyelerin EVM ve Solana arasında nasıl paylaşıldığı


---

# 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/gelistirici-kilavuzlari/call-evm-from-solana.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.
