> 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/temel-kavramlar/how-solana-and-evm-meet.md).

# Solana ile EVM'nin Rome'da nasıl buluştuğu

Solana cüzdanlarının Solidity sözleşmelerini nasıl çağırdığı, EVM adreslerinin Solana programlarını nasıl çağırdığı ve Rome’un kimlik, tokenlar, ücretler ve yürütme sınırlarını nasıl yönettiği.

Bu sayfa, çağrıların Rome üzerinde Solana ile EVM arasında nasıl geçtiğini açıklar. Kimin imzaladığını, tokenların nerede bulunduğunu, kimin ödediğini ve hangi Solana kurallarının Solidity sözleşmelerini etkilediğini kapsar.

Aksi belirtilmedikçe, bu sayfadaki sayılar ve işlemler 19 Ekim 2026 itibarıyla Hadrian'dan (testnet) alınmıştır.

## Sentetik adres nedir?

Sentetik adres, bir Solana genel anahtarının EVM kimliğidir. Rome bunu `keccak256` genel anahtarının `keccak256(pubkey)[12..32]` son 20 baytı olarak hesaplar. Eşleme sabittir. Bunun sentetik olarak adlandırılmasının nedeni, buna ait bir secp256k1 anahtarını kimsenin tutmamasıdır: MetaMask bunun için imza atamaz ve yalnızca Solana anahtarı buradan gelen çağrıları yetkilendirebilir.

Üst düzey sözleşme çağrısında, her ikisi de `msg.sender` ve `tx.origin` sentetik adrestir. Rome EVM nonce'unu o adres altında saklar. Sözleşme bu alanlar üzerinden bu kimliği bir MetaMask kullanıcısından ayırt edemez.

## Bir Solana kullanıcısı Solidity sözleşmesini nasıl çağırır?

Cüzdan, imzasız bir EIP-1559 çağrısını iki yoldan biriyle yetkilendirir. v1 hattı mevcut yoldur. Eski hat daha eski yoldur: cüzdan, `DoTxUnsigned` taşıyan Solana işlemini imzalar ve onun ücretini öder; Rome EVM programı da bu Solana imzalayıcısından sentetik adresi türetir.

v1 hattında cüzdan, `Rome yetkilendirmesi`, bir satır sonu ve çağrı karmasını içeren okunabilir bir iletiyi `0x`  ardından 64 küçük harfli onaltılık karakter gelecek şekilde imzalar. İşlem bu imzayı 0. indekste bir Ed25519 doğrulama instruction'ında taşır. Rome EVM programı, çağrıyı yetkilendiren anahtardan sentetik adresi türetir.

Rome Proxy, v1 işlemini oluşturur. Ardından cüzdan bunu imzalar ve Solana'ya gönderir. Relay rotasında Rome Proxy işlemi gönderir ve SOL öder; sentetik adres ise zincirin gaz tokenındaki yerel bakiyesinden gazı öder (Hadrian ve Rubicon'da USDC).

Cüzdan doğrudan ödediğinde, v1 hattı 15.000 lamport tutar: 5.000 lamportluk imza ücreti, Ed25519 doğrulama imzası için 5.000 lamport ve 5.000 lamportluk hazine geçiş ücreti. Daha eski `DoTxUnsigned` hattın Ed25519 instruction'ı yoktur ve 10.000 lamport tutar. Her iki rota da oluşturulan hesaplar için kira öder. Doğrudan rotaların hiçbiri EVM gazı tahsil etmez. Hadrian'da eski hatla yapılan bir işlem cüzdana 10.000 lamport tuttu ve `gasUsed = 0` ve `effectiveGasPrice = 0`.

SDK’nın `submitRomeTxV1` şu adımları izler:

1. Sentetik adresin nonce'unu `eth_getTransactionCount`gazı tahmin etmek ve imzasız çağrıyı oluşturmak için okuyun.
2. Cüzdandan okunabilir `Rome yetkilendirmesi` iletiyi imzalamasını isteyin.
3. Şuradan bir işlem talep edin: `rome_composeUnsignedAtomicV1`.
4. dönen ödeyiciyi, çağrı baytlarını, Ed25519 yetkilendirmesini, izin verilen programları ve öncelik ücreti olmadığını doğrulayın.
5. Cüzdandan v1 işlemini imzalamasını isteyin, bunu Solana'ya gönderin ve EVM makbuzu için Rome Proxy'yi sorgulayın.
6. Çağrı yinelemeli yürütme gerektiriyorsa, onu `rome_relayUnsignedV1` üzerinden aynı yetkilendirme imzasıyla iletin.

Kullanın `fundSyntheticGas` bir relay veya `msg.value` için gereken yerel bakiyeyi fonlamak. Gaz tokenını cüzdanın token hesabından yatırır ve sentetik adresin yerel bakiyesini kredi eder. Yerel bakiyeler 18 ondalık kullanır.

Bir sözleşmede token kullanmak için SDK sentetik adresi fonlar, sözleşmeyi çağırır ve kalan tokenları geri döndürür. `buildFundLeg` kullanır `ActivateAta` tokenları cüzdandan sentetik adresin token hesabına taşımak için `buildSweepLeg` kullanır `transfer_spl` kalan tokenları cüzdana geri göndermek için.

Cüzdanın Solana v1 işlemlerini imzalayabilmesi gerekir. Solflare bunu Solana devnet'te destekler; Phantom henüz desteklemiyor. Her çağrı, yeniden oynatmayı önlemek için sentetik adres altındaki EVM nonce'unu denetler ve artırır.

Bakın [Solana'dan EVM'yi çağırma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-evm-from-solana.md), [Çift hatlı bir uygulama oluşturma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/dual-lane-app.md), ve [Rome SDK](https://docs.rome.builders/tr/urunler/rome-sdk.md).

## Bir EVM kullanıcısı ya da sözleşme, bir Solana programını nasıl çağırır?

Her EVM adresinin, token hesaplarına sahip olan ve Solana programlarına çağrıları imzalayabilen bir Solana program-türetilmiş adresi vardır. Bu onun harici-otorite PDA'sıdır. Rome EVM programı bunu şu tohumdan türetir `EXTERNAL_AUTHORITY` ardından EVM adresi gelir. Tohumlar zincir kimliği içermez, bu yüzden aynı Rome EVM programı tarafından barındırılan zincirler bu otoriteyi paylaşır.

Bir kullanıcı ya da sözleşme, CPI precompile'ını `0xFF…08` hedef program kimliği, hesap listesi ve instruction baytlarıyla çağırır. CPI, zincirler arası program çağrısı anlamına gelir. Precompile, Solana programını aynı Solana işlemi içinde çağırır.

`invoke` hesap listesi onu imzalayan olarak işaretlediğinde çağıranın harici-otorite PDA'sı için imzalar. `invoke_signed` ayrıca tuzlarla türetilmiş PDA'ları da destekler. Tuz eklenmiş her PDA, hesap listesinde imzalayan olarak görünmelidir.

Yöntemler `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, ve `pdas_batch_derive` salt-okunur yardımcılarıdır. Bir Solana programını çağırmazlar.

Precompile, Rome EVM programının kendisini hedefleyen çağrıları reddeder. Ayrıca Rome EVM program kimliğini içeren bir hesap listesini de reddeder. Bir CPI, düz bir Sistem `Transfer` instruction'ı dışında, Solana ücret ödeyicisini adlandıramaz.

Hadrian'daki bir RomeDexRouter 2.0.0 takası şu adımları izledi:

1. Yönlendirici `HelperProgram.create_ata` kullanıcının çıktı token hesabının mevcut olduğundan emin olmak için çağırdı.
2. Kullanıcının giriş ve çıkış token hesaplarını türetti ve kendi harici-otorite PDA'sını imzalayan olarak işaretledi.
3. Şunu çağırdı `CPI.invoke` ile Solana takas programını, hesap listesini ve takas instruction baytlarını.
4. SPL Token, tokenları kullanıcının hesabından havuza taşıdı ve çıktı tokenlarını kullanıcının diğer hesabına geri verdi. Yönlendiricinin PDA'sı, kullanıcının SPL delegesi olarak imzaladı. Yönlendirici hiçbir token tutmadı.
5. Yönlendirici alınan miktarı şu şekilde kontrol etti `CPI.account_u64_at(dstAta, 64)`.
6. Makbuz 10.001 gaz bildirdi: `5,000 + 5,000 + 1 = 10,001` lamport Solana maliyeti. Bu maliyetler imza ücreti, hazine geçiş ücreti ve öncelik ücretinden oluşuyordu. Rome Proxy SOL ödedi ve kullanıcı gazı USDC ile ödedi.

Bakın [EVM'den Solana'yı çağırma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-solana-from-evm.md), [Bir Solana programını entegre edin](https://docs.rome.builders/tr/gelistirici-kilavuzlari/integrate-solana-program.md), ve [Precompile referansı](https://docs.rome.builders/tr/referans/precompiles.md).

## Bir sözleşme bir Solana programını çağırdığında kim imzalar?

Rome, precompile'ı doğrudan çağıranın harici-otorite PDA'sı ile imzalar. Dolayısıyla bir sözleşme kendi kimliğiyle imzalar. Yalnızca kullanıcının kendi EVM ya da sentetik adresinden precompile'a doğrudan gönderilen bir çağrı, kullanıcının PDA'sı ile imzalanır.

Bir yönlendiricinin veya adaptörün kullanıcının tokenlarını taşımasına izin vermek için kullanıcı `approve_spl(spender, amount, mint)`. Bu, sözleşmenin harici-otorite PDA'sını kullanıcının token hesabının SPL delegesi olarak ayarlar. Bu, Rome'un ERC-20 `approve`.

Altında `DELEGATECALL`, precompile çıplak harici-otorite PDA'sını imzalayan olarak reddeder. Tuz eklenmiş otoriteler, `DELEGATECALL`.

## Her adresin bir PDA'sı varsa neden wrapper'lar likiditeyi bölmüyor?

Bir cüzdan için wrapper, onun SPL tokenlarının bir görünümüdür. `balanceOf` cüzdanın Solana'daki gerçek token hesabını okur. `totalSupply` mintin arzını okur.

Hadrian (testnet), 9.0.0 (`0xbce339ba…`), 8.0.0 (`0xae287c43…`), ve Mayıs 2026 (`0x9fd4d58d…`), her cüzdan için aynı bakiyeyi gösterir. Üçü de mintin arzını `totalSupply`.

Bir Solana-yerli sahibi ve bir EVM sahibi aynı mintin hesaplarını kullanır. Solana cüzdanı token hesabına doğrudan sahiptir. EVM adresinin harici-otorite PDA'sı token hesabına sahiptir. `ActivateAta` ve `transfer_spl` bu hesaplar arasında token taşır. Her iki sahip de aynı Solana havuz hesapları ve rezervlerine karşı işlem yapar.

Sözleşme tarafından tutulan bakiyeler farklı işlem görmelidir. Sözleşmeye gönderilen tokenlar wrapper'ın emanet hesabında durur. Wrapper sözleşmenin bakiyesini izler. Hadrian'da bir UniswapV2 tarzı çift, wrapper 9.0.0 ile 9.600.566 ve wrapper 8.0.0 ile 0 bakiyeye sahipti. Havuzlar, kasalar ve borç verme piyasaları için kayıt defterindeki kanonik wrapper'ı kullanın.

Her token hesabında bir SPL delegate yuvası vardır. Bir router'a veya köprüye izin vermek, wrapper'ın izninin yerini alır. Bir wrapper rotasyonundan sonra, kullanıcı yeni wrapper'a `approve_spl`ile yeniden izin vermelidir. Başka bir delegate onun yerini aldıysa wrapper'a yeniden izin verin.

Her factory mint başına bir wrapper'a izin verir. Farklı factory'lerden gelen wrapper'lar yine de aynı cüzdan token hesaplarını okuyabilir. Bkz. [Token Birlikte Çalışabilirliği](https://docs.rome.builders/tr/temel-kavramlar/token-interop.md).

## Rome, Solana ve EVM'nin farklı semantiklerini nasıl aşıyor?

| Fark                                           | Rome'un yaptığı                                                                                                                                                                                                              |
| ---------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Önceden bildirilen hesaplar ile dinamik erişim | Önce çağrıyı taklit eder ve dokunulan hesapları Solana instruction'ının hesap listesi olarak kullanır.                                                                                                                       |
| Tek bir işlemin hesaplama ve boyut sınırları   | Çağrı sığıyorsa atomik (VmAt) yürütme kullanır. Holder hesapları daha büyük yük taşır ve yinelemeli (VmIt) yürütme işi işlemler arasında böler.                                                                              |
| Bacaklar arasında hesap kilitleri              | Bakiye ve saklama hesaplarındaki kilitleri her bacakta yeniler. Kilitler 3 saniye sürer, işlem 28'den fazla hesap adlandırdığında 4 saniye sürer. Kilitli bir hesaba atomik yazma şu hatayla başarısız olur `AccountLocked`. |
| Gaz tokenı ve ücretler                         | Solana maliyetlerini lamport cinsinden sayar ve bunları işlemin gaz fiyatıyla gaz tokenı ücretlerine dönüştürür. Kullanıcı tarafından ödenen çağrılar SOL'u doğrudan öder.                                                   |
| Bloklar ve slotlar                             | Solana slotunu kullanır `block.number` ve Solana saatini `block.timestamp`.                                                                                                                                                  |
| Kesinlik                                       | Solana'da onaylar `onaylanmış`. Hercules indekslenmiş blokları `nihai`.                                                                                                                                                      |
| İmzalar                                        | EVM imzalarını `secp256k1_recover`ile doğrular. Solana yetkilendirmesi Ed25519 kullanır. İkisi de 20 baytlık bir EVM göndereni üretir.                                                                                       |
| Kira                                           | Solana hesap oluşturma ve büyümesini ücret ödeyici üzerinden finanse eder. Bir ücret alıcısı olduğunda EVM gönderenden gaz ile ücret alır.                                                                                   |
| Ondalıklar ve tam sayı genişliği               | Yerel gaz bakiyeleri için 18 ondalık kullanır. SPL birimlerine dönüşüm tam olmalı ve `u64` içine sığmalıdır. Wrapper'lar mintin ondalıklarını kullanır ve şu değerin üzerindeki miktarları reddeder `uint64` azami.          |
| Yeniden giriş ve gaz ölçümü                    | EVM opcode gaz ölçeri yoktur. 2.300 gazlık stipend çağrıları kısıtlamaz, bu yüzden sözleşmelerin açık yeniden giriş korumalarına ihtiyacı vardır.                                                                            |
| CPI derinliği                                  | Rome EVM programını 1. derinlikte ve bir CPI hedefini 2. derinlikte çalıştırır. Solana 5. derinliğe kadar iç içe geçmeye izin verir.                                                                                         |
| Solana yan etkilerinin atomikliği              | Eski CPI'leri hemen yürütür ve çerçeve daha sonra geri alınırsa tüm işlemi iptal eder. Önbelleğe alınan çağrılar yürütme sırasında kaydedilir ve commit sırasında gönderilir. Çerçeve geri alınırsa onlar atılır.            |
| `SELFDESTRUCT` ve bilinmeyen opcode'lar        | devre dışı bırakır `SELFDESTRUCT`. Bu ve diğer uygulanmamış opcode'lar tüm işlemi şu hatayla iptal eder `IncompatibleVersionEVM`.                                                                                            |
| Nonce'lar                                      | Her gönderici için bir EVM nonce'unu kendi bakiye PDA'sında saklar ve denetler. Gaz tahmini nonce kontrolünü atlar.                                                                                                          |

### Hesaplar

Emülatör, gönderimden önce çağrıyı Solana hesaplarına karşı çalıştırır. Dokunulan her hesabı ve yazılabilir olması gerekip gerekmediğini kaydeder. Bu küme, Solana instruction'ının hesap listesi olur. Listede olmayan gerekli bir hesap, zincir üstü çağrının başarısız olmasına neden olur.

Zamana bağlı bir dal emülasyon ile yürütme arasında değişebilir. Eğer bu değişiklik çağrının hesaplama bütçesini aşmasına neden olursa, Rome Proxy bir sonraki blokta bir kez yeniden oluşturur.

### İşlem boyutu ve hesaplama

Atomik (VmAt) yürütme tek bir Solana işlemi içine sığar; yaklaşık 1,4 milyon compute unit ve en fazla 64 hesapla. Çağrı ayrıca heap ve instruction izleme sınırlarına da sığmalıdır.

Bir Solana v1 işlemi en fazla 4.096 bayt tutar. Daha büyük EVM işlem yükleri için Rome Proxy, 3.600 baytlık parçaları en fazla 80.000 baytlık bir `TxHolder` holder hesabına yazar. Her parçanın imza ücreti gaz olarak ücretlendirilir.

Yinelemeli (VmIt) yürütme, VM durumunu bacaklar arasında bir `StateHolder` holder hesabında saklar. Bir oturum en fazla 160 yinelemeye izin verir. Planlayıcı en fazla 128 bacak üretir; her bacak için opcode sınırı en az 500'dür. Eski CPI'ler atomik yürütme gerektirir. Önbelleğe alınmış çağrılar yinelemeli yürütmeyi destekler.

### Gaz ve kira

Bir Rome gaz birimi, bir lamport Solana maliyetini temsil eder. Maliyetler imza ücretlerini, 5.000 lamportluk hazine geçiş ücretini, öncelik ücretlerini ve iadeler net kira maliyetini içerir. `eth_gasPrice` lamport başına gaz tokenı wei'si bildirir. Bir ücret alıcısı olduğunda Rome gönderenden `lamport × tx.gasPrice` kadarını yerel bakiyeden alır.

Rome bakiye ve saklama hesapları oluşturduğunda veya büyüttüğünde Solana ücret ödeyicisi kirayı finanse eder. Bir ücret alıcısı olduğunda bu maliyet EVM gönderenden gaz olarak tahsil edilir. Bu nedenle hiç kullanılmamış bir adrese yapılan ilk transfer yaklaşık 1 milyon gaz tutar. `eth_estimateGas` 21.000'den azını asla döndürmez.

### Bloklar, zaman ve kesinleşme

`block.number` Solana slotudur. `block.timestamp` Solana saatinin Unix zaman damgasıdır. Rome VM durumunu oluştururken ikisini de yakalar ve yinelemeli bacaklar boyunca korur.

`blockhash(n)` şu `keccak256(bytes32(n))` son 256 slot içinde geçerlidir ve onların dışında sıfırdır. Entropisi yoktur. `block.coinbase` ücret alıcısıdır; yoksa sıfırdır.

SDK bekler `onaylanmış`. Hercules, indekslenen her bloğu finalleştiğinde yeniden kontrol eder `nihai` ve blok karması değişmişse onu yeniden yükler.

### Geri almalar, yeniden giriş ve CPI

Eski CPI'ler hemen yürütülür. Bir CPI yapan çerçeve daha sonra geri alınırsa Rome tüm işlemi iptal eder. Solidity `try/catch` bu geri almayı yutamaz. Önbelleğe alınmış çağrılar yürütme sırasında kaydedilir ve commit sırasında gönderilir. Geri alınan bir çerçeve kendi kaydedilmiş çağrılarını atar. Bir işlem bir yoldan yazdıktan sonra diğer yoldan yazmalar reddedilir. Önbelleğe alınmış bir yazmadan sonra eski okuma yardımcıları da reddedilir: CpiProgram'ın hesap okumaları ve `pdas_batch_derive`, ve HelperProgram'ın `user_balance`, `allowance_of` ve `mint_info`.

Rome'un EVM opcode gaz ölçeri yoktur. `gasleft()` gaz limitini döndürür ya da `U256::MAX` ücret alıcısı yoksa. Şu değere aktarılan gaz `CALL` veya `CREATE` zorunlu değildir. 2.300 gazlık stipend'e güvenmek yerine açık yeniden giriş korumaları kullanın.

Solana'nın instruction yığın derinliği 5'tir. Rome EVM programı 1. derinlikte çalışır, bu yüzden hedefi 2. derinlikte çalışır ve 5. derinliğe kadar iç içe geçebilir. Hadrian swap, takas programını 2. derinlikte ve SPL Token'ı 3. derinlikte çalıştırdı. Beklemedeki bir Solana değişikliği (SIMD-0268) derinliği 5'ten 9'a çıkaracaktır. Bu değişiklik 19 Ekim 2026 itibarıyla devnet'te veya mainnet'te aktif değildi. Rome EVM programına geri bir CPI reddedilir.

Bakın [Yürütme Modeli](https://docs.rome.builders/tr/temel-kavramlar/execution-model.md), [Kısıtlar](https://docs.rome.builders/tr/temel-kavramlar/constraints.md), [Hesaplama Bütçesi](https://docs.rome.builders/tr/temel-kavramlar/compute-budget.md), ve [Bilinen Sınırlamalar](https://docs.rome.builders/tr/guvenlik/known-limitations.md).

## Yaygın sorular

### MetaMask ve Phantom Rome'da aynı hesap mı?

Hayır. Bir MetaMask anahtarı ve bir Solana anahtarı iki farklı EVM adresi verir ve Rome bunları asla bağlamaz. MetaMask anahtarı kendi normal Ethereum adresini verir. Solana anahtarı ise kendi [sentetik adresidir](#what-is-a-synthetic-address), `keccak256(pubkey)[12..32]`: `2PMoUv…` olur `0x45b64dae…`. Üst düzey çağrıda, `msg.sender` ve `tx.origin` imzalama adresidir; relay rotasındaki sentetik adres de buna dahildir.

Farklı anahtarlar ayrımı oluşturur: iki MetaMask anahtarı da iki hesaptır. Eğriler yalnızca hiçbir anahtarın diğerinin adresi için imza atamaması anlamına gelir. Bir bağlama özelliği yoktur. `ActivateAta` yalnızca imzalayanın kendi sentetik adresini fonlar. Bir `Yatırma` instruction, imzalayanın gaz-token hesabından ödenerek herhangi bir EVM adresini yerel gazla kredilendirebilir. Proxy yalnızca imzalayanın kendi sentetik adresine yapılan yatırımları oluşturur. Bunların hiçbiri iki anahtarı tek hesap yapmaz. Bir havuz iki sahibini görür, ancak ikisi de aynı rezervlere karşı işlem yapar; bkz. [Likidite paylaşılıyor mu](#is-liquidity-shared-between-solana-and-evm-users-or-split).

### Solana ve EVM hesapları nasıl eşlenir?

Rome her Solana anahtarını sabit bir [sentetik EVM adresine](#what-is-a-synthetic-address)eşler. Her EVM adresinin nonce'u, yerel gaz bakiyesi ve kodu için zincir başına bir bakiye PDA'sı vardır. Harici-otorite PDA'sı token hesaplarına sahiptir ve CPI'leri imzalar. Tek bir Rome programındaki zincirler bu otoriteyi paylaşır.

Bu hesaplar Hadrian'da (testnet) okundu:

| Hesap                           | MetaMask adresi `0x35153297…a266`                                          | Solana cüzdanı `2PMoUv…`, sentetik adres `0x45b64dae…127d`                                   |
| ------------------------------- | -------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| Cüzdanın kendi Solana hesapları | MetaMask anahtarından hiçbiri                                              | SOL sistem hesabı `2PMoUv…`; kendi wSOL hesabı `T8gKAAg9pz5eLcerH1Nh52Hn97m1nnGyhY9z4bwtyir` |
| Bakiye PDA'sı                   | `8zuWEakFcuRRJ5Gju44u6Ptyk22gbNUMbsD8VLEQVS4c`                             | `EeRr14Feh3Ft7YuyacAVJQd3YSYsKAPTqdMEN43gtBSd`                                               |
| Harici-otorite PDA'sı           | `EZSTURZAg3GMqiWN3NBCvMLjEeLSxGH9PGooW6dAG8Kb`                             | `FMSHMpgdA9rEhzGLSvFniAHT7BmGjJweQqxPiGJJntC1`                                               |
| Rome'un kullandığı token hesabı | USDC `8wAzpmag4oL4c6ku6wqQBjxWXYLPoVsek6SyAvrYaxim`, sahipliği `EZSTURZA…` | wSOL `3pPjxR4ho3mVb5AMauVCjqTBUVS2Rif5JAnk9DFukPg2`, sahipliği `FMSHMpgd…`                   |

Bir Solana kullanıcısının tokenları iki yerde durur: cüzdanın kendi hesapları ve wrapper'ların okuduğu sentetik adresin PDA'ya ait hesapları. SDK tokenları `ActivateAta` ile içeri ve `transfer_spl`ile geri taşır, açıklandığı gibi [Bir Solana kullanıcısı Solidity sözleşmesini nasıl çağırır?](#how-does-a-solana-user-call-a-solidity-contract). Süpürme `0x95b2502d…` cüzdana 0,016587 wSOL geri verdi. Aynı MetaMask adresi, Hadrian (testnet) ve Rubicon (mainnet) üzerinde farklı token hesaplarına sahiptir; çünkü bunlar farklı Rome programları, mintler ve Solana kümeleri üzerinde çalışır.

### Bir EVM kullanıcısı ve bir Solana kullanıcısı aynı sözleşmeyi çağırdığında hangi ücret kimin tarafından ödenir? Tek bir ücret yolu mu var yoksa iki tane mi?

Rome, bunu ödemek için iki yolu olan tek bir maliyet modeli kullanır. Bir Rome gaz birimi bir lamport Solana maliyetidir: imza ücretleri, 5.000 lamportluk hazine geçiş ücreti, herhangi bir öncelik ücreti ve iadeler net kira.

Cüzdan tarafından imzalanan Solana hatlarında, Solana ücret ödeyicisi bu maliyeti EVM gaz ücreti olmadan SOL olarak öder. MetaMask ve relay çağrılarında ise Rome Proxy SOL'u peşin öder. Program EVM gönderenden `lamport × işlemin gaz fiyatı` kadarını kendi yerel bakiyesinden bir proxy ücret alıcısına tahsil eder. Gaz tokenı Hadrian'da (testnet) USDC, Rubicon'da (mainnet) ise USDC'dir.

Bu iki `arz` çağrısı (MetaMask'tan USDC, Solana anahtarından wSOL) Hadrian'da (testnet) AavePool 2.0.0 (`0x81e7e7e4…`) kullandı. Her biri iki hesap oluşturdu.

| Maliyet veya alıcı          | EVM anahtarı (MetaMask)                                                              | Solana anahtarı (v1 cüzdan-imzalı)                                                                                   |
| --------------------------- | ------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------- |
| EVM tx                      | `0xc7e6ee8d…`, from `0x35153297…`                                                    | `0xb0712551…`, from `0x45b64dae…`                                                                                    |
| Kim imzaladı ve SOL ödedi   | Rome'un proxy ödeyicisi `GNX1fLhb…`                                                  | Kullanıcının cüzdanı `2PMoUv…`                                                                                       |
| Harcanan SOL                | 2.102.962 lamport = 5.000 imza + 2 öncelik + 5.000 geçiş ücreti + 2 × 1.046.480 kira | 2.107.960 lamport = imza ücretlerinde 10.000 (işlem + Ed25519 doğrulaması) + 5.000 geçiş ücreti + 2 × 1.046.480 kira |
| EVM gazı tahsil edildi      | Gönderici 2.102.962 gaz × 13.004.742.450 wei = 0,0273485 USDC ödedi                  | `gasUsed` 0, `gasPrice` 0                                                                                            |
| Gazın ödendiği yer          | Proxy ücret alıcısı `0x179d6112…`                                                    | Kimse; yok `gasRecipient`                                                                                            |
| Hazine geçiş ücreti alıcısı | `7WDWCxvk…`, hazine hesabı #31                                                       | `3F9eKFpr…`, hazine hesabı #6                                                                                        |

* **Eski hat (daha eski yol):** `0x350b8e36…` cüzdana oluşturulan tek bir hesap için 1.056.480 lamporta mal oldu: 5.000 imza ücreti + 5.000 geçiş ücreti + 1.046.480 kira. EVM gazı 0'dı.
* **Relay:** Aave `borç alma` işlemi `0x18d65e8c…` 16 Solana bacağı kullandı. Sentetik adres, MetaMask kullanıcısıyla aynı ücret yolunu kullanarak 2.177.992 gaz = 0,0226594 USDC ödedi. Gaz ücreti şunları kapsar `16 × 5.002 + 5.000 geçiş ücreti + 2 × 1.046.480 kira = 2.177.992`. Her relay bacağı ayrıca Ed25519 doğrulama imzasını taşır. Proxy bu bacak başına 5.000 lamportu öder ve bunu faturalamaz; dolayısıyla bu çağrı proxy'e ücretlerde 16 × 10.002 lamporta mal oldu.
* **Ortak hazine:** Her rota, 5.000 lamportluk geçiş ücretini zincirin 64 hazine hesabından birine öder. Yukarıdaki iki arz çağrısı geçiş ücretlerini aynı kümenin #31 ve #6 numaralı hesaplarına ödedi.
* **Beyan edilen fiyat:** Rome, işlemin beyan edilen fiyatını tahsil eder, `maxFeePerGas` EIP-1559 için. Temel ücret veya farkın iadesi yoktur. Canlı EVM anahtarlı işlemler `eth_gasPrice` lamport başına 10.403.793.960 wei alıntısının 1× ila 2× arasını beyan etti ve her biri tam olarak beyan ettiğini ödedi. Gaz, EVM opcode'u başına değil, Solana maliyetinin her lamportu başına fiyatlanır.
* **Cüzdan-imzalı maliyetler:** SDK hatları herhangi bir öncelik ücreti ayarlamaz, bu yüzden kullanıcılar hesaplama ücreti ödemez. İmza ücretlerini, geçiş ücretini ve kirayı SOL olarak öderler. v1 hattı iki imzanın bedelini öder: işlem imzası ve Ed25519 doğrulaması.

Şuna bakın: [Solana çağrı akışı](#how-does-a-solana-user-call-a-solidity-contract) ve [çift hatlı kılavuz](https://docs.rome.builders/tr/gelistirici-kilavuzlari/dual-lane-app.md) cüzdan ve relay rotaları için.

### Likidite Solana ve EVM kullanıcıları arasında paylaşılıyor mu, yoksa bölünüyor mu?

Paylaşılıyor. Her iki hat da aynı mintin hesaplarına karşı işlem yapar. Hadrian'daki (testnet) Aave üzerinde, bir Solana anahtarı ve bir MetaMask-hattı EVM anahtarı, wSOL emanet hesabı üzerinden hem arz hem de borç aldı `3yY2FHSG…` (MetaMask: arz `0xaf460f52…`, borç al `0x89dbf0b6…`; Solana anahtarı: arz `0xb0712551…`, borç al `0x18d65e8c…`). Bu, awSOL rezervini tutan wSOL wrapper'ının emanetteki hesabıdır.

rome-dex'te, bir Solana cüzdanı likiditeyi, EVM yönlendirici takas `0xa7f77530…`için kullanılan aynı kasalara doğrudan yatırdı. `2xFSzza7…` Rome programı içermez. Sadece sözleşmelerde tutulan bakiyeler wrapper'a bağlıdır, bu yüzden havuzlar ve kasalar için kayıt defterinin kanonik wrapper'ını kullanın (bkz. [PDA ve wrapper bölümü](#every-address-has-a-pda-so-why-dont-the-wrappers-split-liquidity)). wSOL likiditesini `totalSupply`ile ölçmeyin: 0 okur çünkü yerel SOL minti 0 arz bildirir.

### Bir MetaMask adresi ile bir Solana cüzdanı arasında tokenları ve gaz bakiyesini nasıl taşırım?

* **Solana cüzdanından MetaMask adresine, tokenlar:** Eksikse token hesabını oluşturun (Associated Token programının idempotent oluşturması, hesabın harici-otorite PDA'sı sahip olarak), ardından ona düz bir SPL transferi gönderin. `HelperProgram.ata(address, mint)` adresini döndürür. İşlem `2tBhefMJ…` ikisini de yaptı ve 20 USDC taşıdı.
* **Solana cüzdanından MetaMask adresine, gaz:** Kendi sentetik adresinizi `fundSyntheticGas`ile fonlayın. Ardından sentetik adresten MetaMask adresine yerel değer transferi gönderin.
* **MetaMask adresinden Solana cüzdanına, tokenlar:** Çağırın `transfer_spl(bytes32,uint64,bytes32)` doğrudan EVM adresinden Helper precompile'ı üzerinde, alıcının mevcut token hesabıyla. Alternatif olarak, `RomeBridgeWithdraw.bridgeOutToSolana`çağırın; bu da bir izin ve mevcut bir alıcı token hesabı gerektirir.
* **MetaMask adresinden Solana cüzdanına, gaz:** Withdraw precompile'ının ödemeli `withdrawal(bytes32 to)` çağrısını miktarı `msg.value`olarak yapın. Cüzdan bunu USDC token hesabında USDC olarak alır; Rome gerekiyorsa bunu oluşturur. `msg.value` 10^12 wei'nin katı olmalıdır. Alıcı mevcut bir cüzdan hesabı olmalıdır.

`transfer_spl_to_signer` yalnızca cüzdan imzalı Solana hattında kendi cüzdanınıza ulaşır. MetaMask'ten veya relay üzerinden, imzalayan Rome'un vekil ödeyicisidir; bu yüzden çağrı başarısız olur ya da tokenlar Rome'a gider. Bkz. [Precompile referansı](https://docs.rome.builders/tr/referans/precompiles.md).

Bir kimlik, diğerinin tokenlarını yalnızca açık bir yetki verme yoluyla harcayabilir, `approve_spl` ya da bir ERC-20 `approve`, diğer herhangi bir adres gibi. Her token hesabının bir delegate yuvası vardır. Bkz. [Token Birlikte Çalışabilirliği](https://docs.rome.builders/tr/temel-kavramlar/token-interop.md#one-time-grant-per-wallet).

### Adresim her Rome zincirinde aynı mı?

EVM adresi, anahtardan geldiği için her zincirde aynıdır. Nonce'u ve gas bakiyesi zincir bazında tutulur. Token hesapları, aynı Rome programındaki zincirler arasında ortaktır ve programlar ile kümeler arasında farklılık gösterir. Bkz. [hesap eşlemesi](#how-do-solana-and-evm-accounts-map).

### Solana hattında hangi cüzdan çalışır? Phantom çalışıyor mu?

Henüz Solana hattında değil. Solana hattı Solana v1 işlemlerini kullanır ve cüzdanın bunları imzalaması gerekir. Devnet'te Solflare yapar; Phantom henüz yapmıyor.

### Gezgin, bir işlemin hangi hattı kullandığını gösteriyor mu?

Kısmen. The [Via gezgini](https://docs.rome.builders/tr/rome-uzerindeki-uygulamalar/via.md) bir EVM anahtarının mı yoksa bir Solana anahtarının mı bir çağrı gönderdiğini gösterir: `kaynak` şu `ecdsa` veya `solana_unsigned`, ve Solana anahtarlı çağrılar şunu taşır: `solanaSigner`. Eski, v1 ve relay yollarını birbirinden ayırt etmez; üçünü de şu şekilde gösterir `solana_unsigned`. Bir relay çağrısı, sıfır olmayan şuna sahip olandır: `gasUsed` ve bir `gasRecipient`. ile yapılan bir gas takviyesi `fundSyntheticGas` şu şekilde görünür: `ecdsa` olmadan `solanaSigner`.

## Sırada nereye gidilir

* [Mimari](https://docs.rome.builders/tr/baslarken-1/architecture.md)
* [Yürütme Modeli](https://docs.rome.builders/tr/temel-kavramlar/execution-model.md)
* [Token Birlikte Çalışabilirliği](https://docs.rome.builders/tr/temel-kavramlar/token-interop.md)
* [EVM'den Solana'yı çağırma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-solana-from-evm.md)
* [Solana'dan EVM'yi çağırma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-evm-from-solana.md)
* [Çift hatlı bir uygulama oluşturma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/dual-lane-app.md)
* [Bir Solana programını entegre edin](https://docs.rome.builders/tr/gelistirici-kilavuzlari/integrate-solana-program.md)
* [Precompile referansı](https://docs.rome.builders/tr/referans/precompiles.md)
* [JSON-RPC referansı](https://docs.rome.builders/tr/referans/json-rpc.md)


---

# 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/temel-kavramlar/how-solana-and-evm-meet.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.
