> 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/integrate-solana-program.md).

# Bir Solana programını entegre edin

Bir Solana programını Rome EVM ile entegre edin — Solana imzacısının kim olduğu, değerin programınıza nasıl ulaşıp geri döndüğü, tek hat kuralı, atomik ile yinelemeli modlar ve hesap sağlama.

Bu kılavuz, Rome EVM kullanıcılarının kendi programlarını kullanmasını isteyen bir Solana program ekibi içindir — EVM hesapları için değer tutması gereken bir gizlilik, borç verme veya kasa programı. Şunun üzerine kuruludur [EVM'den Solana'yı çağırma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-solana-from-evm.md) (ön derleme mekanikleri) ve gerçek bir program diğer tarafta olduğunda ortaya çıkan soruları yanıtlar: *kim* imzalar, *nasıl* tokenların nasıl girip çıktığı ve *hangi* sınırlamaların tasarımı nasıl şekillendirdiği.

Burada kullanılan akış şudur: bir EVM hesabı USDC’yi programınıza aktarır ("shield" ya da "deposit"), programınız bunu o kullanıcı için tutar ve daha sonra geri serbest bırakır ("unshield" ya da "withdraw"). Fiilleri kendi terimlerinizle değiştirin.

## 1. Her EVM adresinin bir Solana kimliği vardır

Rome, her EVM adresi için — kullanıcılar ve sözleşmeler dahil — bir Solana hesabı türetir; buna **harici yetki**:

```
external_auth(addr) = find_program_address(["EXTERNAL_AUTHORITY", addr_h160], rome_evm_program_id)
```

Bu yetki, adresin ilişkili token hesaplarına sahiptir (yani `wUSDC.balanceOf(addr)` okur) ve o adres adına yapılan CPI'leri imzalayan anahtardır. Programınız 32 baytlık bir Solana açık anahtarı görür; hiçbir zaman bir H160 görmez.

**Kimin imzalayacağına, ön derlemeyi kimin çağırdığı karar verir:**

| Ön derleme şu şekilde çağrılır:                                        | Solana imzalayıcısı                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ---------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Bir **sözleşme**, normal bir `CALL`                                    | Şu **sözleşmenin kendi** harici yetkisi (`external_auth(contract)`), ayrıca istediği sözleşmenin tuzlanmış alt-PDA'ları da dahil                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Bir **kullanıcı**, doğrudan ön derleme adresine gönderilen bir işlemde | Şu **kullanıcının kendi** harici yetki                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Bir sözleşme aracılığıyla `DELEGATECALL`                               | Yalın yetki reddedilir (`DelegatecallOwnerAuthority`). `invoke` imzalayıcı olmadan ve `invoke_signed` tuzlanmış alt-PDA'larla yine de çalışır — ancak bu alt-PDA'lar çalıştıran sözleşmenin adresiyle ad alanına ayrılır (`["EXTERNAL_AUTHORITY", caller, running_contract, salt]`), bu yüzden `pda_with_salt` bunları türetmez. HelperProgram'da yalnızca oluşturma ve fonlama seçicileri geçer (`create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint`, `create_and_init_mint`); bunlar muaf tutulur çünkü hedefleri çağırana bağlıdır ya da operatör tarafından finanse edilir, imzalamadıkları için değil |

Sonuç, zaten bildiğiniz ERC-20 kuralıdır: **bir sözleşme kullanıcının varlıklarını kendi başına hareket ettiremez.** Kendi kimliğiyle hareket eder ve kullanıcı önce ona yetki verir. Solana tarafında hareket etmesi gereken tokenlar için bu yetki, kullanıcının token hesabı üzerindeki bir SPL delegasyonudur; sarmalayıcının ERC-20 `approve` yalnızca sarmalayıcının kendi transferlerinin dikkate aldığı EVM tarafı bir izin kaydıdır. Rome'un kendi token sarmalayıcıları böyle çalışır ve adaptörünüz de böyle çalışacaktır (bölüm 3).

Tuzlanmış alt-PDA'lar: `invoke_signed` bir liste alır `bytes32` tuzlar, ve Rome şu ile imzalar `["EXTERNAL_AUTHORITY", caller_h160, salt]` her biri için (sona bump eklenir; doğrudan çağrıda çağıran sözleşmedir). `HelperProgram.pda_with_salt(addr, salt)` Solidity'den adresi döndürür. Programınız her pozisyon için ayrı bir sahip hesabı istediğinde kullanıcı başına bir tuz kullanın (örneğin kullanıcının adresi).

Fonlama: bir ATA'ya sahip olmak için bir harici yetki PDA'sının var olması gerekmez (`create_ata` idempotenttir ve işlemin Solana ücret ödeyicisi kirayı karşılar). Yalnızca, talimatınızın oluşturduğu hesapları finanse ettiğinde var olmalı ve lamport tutmalıdır. `HelperProgram.create_pda(addr)` onu düz bir System olarak oluşturur `CreateAccount`, bu yüzden bir kez çağırın; idempotent değildir. `swap_gas_to_lamports(n)` adresin PDA'sına şu kadar lamport yükler `n` işlemin Solana ücret ödeyicisinden alınan lamportlarla, ve çağıran taraf bunların bedelini Rome gas olarak öder: legacy track'teki her CPI'nin ücret ödeyicisinin bakiyesi üzerindeki etkisi işlem ücretine eklenir ve kullanıcıya gas fiyatından yansıtılır; tıpkı CPI'nin oluşturduğu hesaplar için kiranın yansıtılması gibi. Solana hattının hazırlama adımı şu bölümde açıklanır: [Solana'dan EVM'yi çağırma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-evm-from-solana.md); bir sözleşme kendi PDA'sını kurucusunda veya ilk çağrısında hazırlar.

## 2. Bir kullanıcının pozisyonunu tutmanın üç yolu

**A. Bir adaptör sözleşmesi (yeniden kullanılabilir bir adaptör için önerilir).** Tek bir Solidity sözleşmesi programınızın önünde yer alır. Kullanıcı, adaptörün yetkilisine kendi token hesabı üzerinde bir SPL delegasyonu verir; adaptör tokenları sahip olduğu bir token hesabına çeker, programınızı kendi kimliğiyle çağırır ve programınızdaki kullanıcının pozisyonunu kullanıcı başına bir alt-PDA ile ya da talimat verisinde ilettiği bir tanımlayıcıyla anahtarlar. Çıkışta programınıza, kullanıcının kendi token hesabına serbest bırakmasını söyler. Adaptör, programınızın bilmesi gereken tek Solana kimliğidir. Yetki bir SPL delegasyonudur, ERC-20 `approve`; bunun nedenini ve kullanıcıya maliyetini 3. bölüm açıklar.

**B. Solana imzalayıcısı olarak kullanıcı.** Ön yüz, kullanıcının EVM hesabından bir işlem gönderir **doğrudan CpiProgram ön derlemesine** (`to = 0xff…08`, calldata = ABI ile kodlanmış `invoke` veya `invoke_signed`), bu yüzden kullanıcının kendi harici yetkisi imzalar ve programınız pozisyonu onunla anahtarlar. Adaptör sözleşmesi ve delegasyon yoktur, ancak her işlem cüzdanda opak bir calldata işlemi olarak görünür ve akışın CPI dışında ihtiyaç duyduğu her şey (ATA, önceden yapılmış bir transfer) ayrı bir işlemdir. Tek seferlik yetkiler için uygundur (bir kullanıcının `approve_spl` bir sarmalayıcıya) ve basit programlar için uygundur, çok adımlı akışlar için değil. [Cardo](https://github.com/rome-protocol/cardo) bu yapıyı kullanır: ön yüzü `invoke` doğrudan kullanıcının cüzdanından ön derlemeye gönderir.

**C. Vekâletsiz bir yönlendirici.** Kullanıcının tokenlarını hiçbir zaman elinde tutmayan bir sözleşme. Kullanıcı, yönlendiricinin yetkilisine kendi token hesabı üzerinde bir SPL delegasyonu verir; yönlendirici, o yetkiyi transfer yetkilisi olarak kullanarak programınıza CPI yapar, böylece tokenlar kullanıcının token hesabından programınızın hesabına (veya geri kullanıcının hesabına) taşınır ve yönlendirici çağrılar arasında hiçbir şey tutmaz. Yönlendirici, kullanıcı tarafındaki her hesabı şundan türetir `msg.sender`, böylece bir kullanıcının yetkisi başka bir kullanıcının hesabına yönlendirilemez ve genel bir `invoke` aktarma katmanı. The `RomeDexRouter` için [rome-dex](https://github.com/rome-protocol/rome-dex) bu şekilde yazılmıştır; rome-dex'in EVM hattı ayrıca ham doğrudan `invoke` B şeklini de sunar. A ile aynı yetkiye, aynı tek-delege maliyetine (bölüm 3) ve çekme adımı olmamasına ihtiyaç duyar.

Bu kılavuzun geri kalanı A'yı izler; C de aynı yetkiyi ve aynı imzalama kuralını kullanır.

## 3. Tokenlar içeri, tokenlar dışarı

Rome'daki USDC, iki açıdan görülen tek bir SPL mintidir: `wUSDC` EVM tarafındaki ERC-20 sarmalayıcısı ve Solana tarafındaki harici yetkinin ATA'sı. Kullanıcının kendi adresi için ikisi aynı bakiyedir: `wUSDC.balanceOf(user)` kullanıcının ATA'sını okur. İki görünüm arasında hiçbir şey hareket etmez veya senkronize olmaz.

**Bir sözleşmenin sarmalayıcı bakiyesi, sözleşmenin kontrol ettiği bir token hesabı değildir.** Fabrika şunu dağıtır: `SPL_ERC20_cached` sıradan bir mint için, ve Hadrian'ın `wUSDC` bunlardan biridir. O sarmalayıcı bir sözleşme için imza atamaz, bu yüzden `wUSDC.transferFrom(user, adapter, amount)` veya `transfer` bir sözleşmeye token gönderdiğinde, SPL tokenlar şu hesaba taşınır: **sarmalayıcının kendi emanet token hesabı** (`escrow_ata()`), ve sarmalayıcı miktarı kendi depolamasında sözleşme bazında kaydeder. `wUSDC.balanceOf(adapter)` bu kaydı, bir emanet defterini döndürür; şu yetkiye ait bir token hesabının bakiyesini değil: `external_auth(adapter)`. Adaptörünüz bu tokenları programınıza bir CPI ile veremez; onlar yalnızca sarmalayıcı üzerinden yeniden çıkabilir. Bu yüzden kendini `transferFrom` ile finanse eden bir adaptörün Solana tarafında harcayabileceği hiçbir şey yoktur.

İşe yarayan yol bir SPL delegasyonudur:

* **Yetki verin.** Kullanıcı şunu gönderir: `approve_spl(adapter, amount, mint)` bir işlem olarak **doğrudan HelperProgram'a** (`to = 0xff…09`), burada `mint` sarmalayıcının `mint_id()`.
* **Giriş.** Adaptörün `deposit(amount)` delege aşırı yüklemesiyle çeker `HelperProgram.transfer_spl(srcAta, dstAta, amount, mint)`, kullanıcının ATA'sı kaynak ve adaptörün kendi ATA'sı (`HelperProgram.ata(address(this), mint)`, bir kez şu şekilde oluşturulan `create_ata`) olarak hedefe. `external_auth(adapter)`Adaptörün yetkisi delege olarak imzalar. Tokenlar artık şu yetkiye ait bir token hesabındadır: `wUSDC.balanceOf(adapter)`.
* **Çıkış.** Programınızın withdraw talimatı şuraya transfer eder: **kullanıcının** ATA'sına, `HelperProgram.ata(user, mint)`. Alma işlemi için kullanıcının imzası gerekmez ve bakiye hemen şu şekilde görünür: `wUSDC.balanceOf(user)`. ATA henüz mevcut olmayabilir; önce şununla oluşturun: `HelperProgram.create_ata(user, mint)` (idempotent).

**Bir token hesabının bir delege vardır.** Yukarıdaki yetki, o hesap üzerindeki sarmalayıcının kendi yetkisini değiştirir. Kullanıcı sarmalayıcıya yeniden yetki verene kadar, o hesaptan yapılan her `wUSDC` `transfer` veya `transferFrom` çıkış SPL hatasıyla geri döner `0x4`. `wUSDC.isEnabled(user)`; döndürdüğünde `false`, kullanıcıdan şunu göndermesini isteyin: `approve_spl(wrapper, 2^64-1, mint)` yeniden HelperProgram'a gönderin; bu, sarmalayıcının etrafında tasarlandığı aynı maksimum yetkidir (bkz. [Tek seferlik: sarmalayıcıya yetki verin](https://docs.rome.builders/tr/gelistirici-kilavuzlari/dual-lane-app.md#one-time-grant-the-wrapper)). Sınırlandırılmış bir yetki, kullanıcının normal `wUSDC` transferlerini, yetki azaldığında yeniden bozar; ve `isEnabled` kalır `true` ondan bir miktar kaldığı sürece true olur, bu yüzden uygulama yeniden istemesi gerektiğini bilemez.

Bir mintin hangi sarmalayıcıya sahip olduğunu kontrol etmek için fabrikanın `wrapper_kind_by_mint(mint)` (fabrika adresi zincirin `contracts.json` şu kısmında: [kaydında](https://github.com/rome-protocol/rome-registry)). `1` bu bölümün açıkladığı önbelleğe alınmış sarmalayıcıdır. `2` ise, fabrikanın etkinleştirilmiş bir transfer kancası olan bir Token-2022 minti için dağıttığı doğrudan-CPI sarmalayıcısıdır; bu kılavuz bunu kapsamaz. Kaydın `tokens.json` sarmalayıcı adresini ve minti listeler, ancak bunun hangi tür olduğunu belirtmez.

## 4. Sözleşme ve işlem başına tek bir hat

Rome'un Solana durumunu değiştiren iki ön derleme ailesi vardır ve **bir işlem bunlardan yalnızca birini kullanır** — çalışma zamanı, sözleşmeler arasında bile olsa her ikisinden de değiştiren çağrıları karıştıran bir işlemi reddeder.

| Hat        | Precompile'lar                                                                                      | Etkiler uygulanır                                                                                                   | Yinelemeli yürütmede çalışır                                                                          |
| ---------- | --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| **Legacy** | `CpiProgram` `0xff…08` (`invoke`, `invoke_signed`), `HelperProgram` `0xff…09`, `Çekme` `0x42…16`    | Hemen, EVM adımı içinde gerçek bir CPI olarak                                                                       | **Hayır** — yinelemeli bir işlemde legacy CPI şu hatayla başarısız olur: `CpiProhibitedInIterativeTx` |
| **Cached** | `SplCached` `0xff…05`, `ASplCached` `0xff…06`, `SystemCached` `0xff…04`, `WithdrawCached` `0xff…0b` | Bir bindirme katmanında aşamalı hale getirilir ve işlemin sonunda CPI olarak yazılır; bir EVM revert’i bunları atar | Evet                                                                                                  |

Bu, bir program entegrasyonu için ne anlama gelir:

* **Kendi programınızın talimatlarını çağırmak yalnızca legacy hattında mümkündür.** Cached track'in genel bir `invoke`; SPL transferlerini, ATA oluşturmayı, system-programı işlemlerini ve gas çekmeyi kapsar.
* Bu nedenle adaptörü fonlayan adım, CPI ile aynı işlemde çalışıyorsa o da legacy-track olmalıdır. Cached sarmalayıcının `transferFrom` bir cached-track çağrısıdır; bu yüzden CPI'nızla aynı işlemi paylaşamaz (ve bölüm 3'ün gösterdiği gibi yalnızca bir emanet defterini krediler). Şununla çekin: `HelperProgram.transfer_spl(userAta, adapterAta, amount, mint)` bunun yerine, kullanıcı adaptörü SPL delegesi yaptıktan sonra (`approve_spl`kullanıcı tarafından doğrudan HelperProgram'a gönderilen).
* **Sarmalayıcıyı o işlemin dışında tutun.** Sarmalayıcının değiştiren işlevlerini çağırmayın (`wUSDC.transfer`, `transferFrom`) adaptörden, legacy CPI ile aynı işlem içinde çağırmayın. Şunu kontrol edin: `isEnabled(user)` ve ön yüzdeki bakiyeleri şu şekilde kontrol edin: `eth_call`.
* **Ve CPI işlemi atomik olmalıdır.** Tasarımın altında durduğu sınır budur.

Okumalar bu kuralın dışındadır: `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` ve `HelperProgram.user_balance` / `allowance_of` önceden yüklenmiş hesapların okumalarıdır (CPI yok), her iki track'te ve her iki yürütme modunda da izinlidir. Ön kontrollerinizi bunlar üzerinde yapın. Bir sıralama kuralı: bir işlemde cached bir değişiklik tetiklendikten sonra, kalan kısım için legacy-track okumaları engellenir — önce oku, sonra değiştir.

## 5. Atomiklik bütçedir

Atomik bir Rome işlemi, tek bir Solana işlemidir: yaklaşık **1,4 milyon compute unit**, bir **64 adresli** hesap listesi ve **4 KB** iletim boyutu (Solana v1 işlemleri). Rome programı ve CPI'nız bu bütçeyi paylaşır. Bir sarmalayıcı transferi Hadrian üzerinde yaklaşık 170K CU kullanır ve talimatınız kendi maliyetini ekler; bunu Solana makbuzunun `computeUnitsConsumed`, EVM değil `gasUsed`.

Emülasyon bir işlemin sığmadığına karar verdiğinde, Rome onu **yinelemeli olarak** birkaç Solana işlemi boyunca çalıştırır ve içindeki legacy CPI sonra başarısız olur. Hem deposit hem withdraw için yalnızca bir token hareketi artı programınıza bir CPI olacak şekilde sınırlı tutun ve etraflarındaki Solidity kodunu küçük tutun. Daha büyük her şeyi iki kullanıcı işlemine bölün.

CPI derinliği: Solana 4 seviyeye izin verir ve Rome bir seviye kullanır; bu yüzden talimatınız 2. seviyede, altında iki seviye varken çalışır (programınız → SPL Token bir seviye bırakır).

## 6. Hesap hazırlama

Programınız hesaplarını çalışma zamanında Solidity'den almaz. Proxy **emüle eder** göndermeden önce her işlemi, CPI'ların dokunduğu her Solana hesabını kaydeder ve bunları Solana işlemine yerleştirir. Adaptörünüz hesapları şu listede adlandırır: `invoke_signed` hesap listesi; emülasyon bunların çözüldüğünü kanıtlar. Buradan üç sonuç çıkar:

* Talimatınızın dokunduğu her hesap, adaptörün sahip olduğu girdilerden türetilebilir olmalıdır (kendi PDA'sı ve alt-PDA'ları, program ID'niz, mintler, kullanıcının adresi). `SystemProgram.find_program_address` ve `CpiProgram.pdas_batch_derive` türetmeleri Solidity içinde yapar.
* Henüz var olmayan bir hesap (yeni bir pozisyon, yeni bir ATA) yine de hesap listesinde adı geçmek zorundadır; Solana işlemine ulaşan şey onun adresidir.
* İşlemin dokunduğu her şey — kullanıcı, adaptör ve sarmalayıcı için Rome'un kendi hesapları dahil — 64 adresin altında kalmalıdır. Tek bir çağrıda on piyasaya dokunan bir tasarım sığmaz.

Solana cüzdan hattı için, `rome_emulateCallAccounts` aynı keşfi istemciye sunar; SDK bunu kullanır.

Bir CPI'nin asla adlandıramayacağı iki hesap vardır: işlemi gönderen Solana ücret ödeyicisi (düz bir System transfer talimatı içinde olmadıkça) ve Rome programının kendisi. Rome programına geri dönen bir CPI reddedilir.

## 7. Solidity'de bir deposit ve bir withdraw

Legacy track üzerinde bir adaptörün minimal bir taslağı. Kullanıcı zaten şunu gönderdi: `approve_spl(adapter, amount, mint)` HelperProgram'a (bölüm 3). `PRIVACY_PROGRAM` program ID'nizdir; `encodeDeposit` / `encodeWithdraw` talimat verinizi oluşturun (Borsh, little-endian); hesap metaları talimatınızın düzenini izler.

```solidity
import {ICrossProgramInvocation, IHelperProgram}
    from "@rome-protocol/rome-solidity/contracts/interface.sol";

contract PrivacyAdapter {
    ICrossProgramInvocation constant Cpi    = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);
    IHelperProgram          constant Helper = IHelperProgram(0xFF00000000000000000000000000000000000009);
    bytes32 constant SPL_TOKEN = 0x06ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9; // TokenkegQ...

    bytes32 immutable PRIVACY_PROGRAM;
    bytes32 immutable USDC_MINT;

    constructor(bytes32 program, bytes32 mint) {
        PRIVACY_PROGRAM = program; USDC_MINT = mint;
        Helper.create_pda(address(this));                 // adaptörün kendi Solana kimliği
        Helper.create_ata(address(this), USDC_MINT);      // ve sahip olduğu bir USDC hesabı
    }

    function _salt(address user) internal pure returns (bytes32) { return bytes32(uint256(uint160(user))); }

    function deposit(uint64 amount) external {
        bytes32 self       = Helper.pda(address(this));                   // imzalayıcı: adaptörün yetkisi
        bytes32 adapterAta = Helper.ata(address(this), USDC_MINT);
        bytes32 position   = Helper.pda_with_salt(address(this), _salt(msg.sender)); // kullanıcı başına alt-PDA, ayrıca imzalar

        // Kullanıcının token hesabından çekin. Adaptörün yetkisi SPL olarak imzalar
        // kullanıcının verdiği delege; bu, aşağıdaki CPI gibi bir legacy-track çağrısıdır.
        Helper.transfer_spl(Helper.ata(msg.sender, USDC_MINT), adapterAta, amount, USDC_MINT);

        ICrossProgramInvocation.AccountMeta[] memory accs = new ICrossProgramInvocation.AccountMeta[](5);
        accs[0] = ICrossProgramInvocation.AccountMeta(self,       true,  true);
        accs[1] = ICrossProgramInvocation.AccountMeta(position,   true,  true);
        accs[2] = ICrossProgramInvocation.AccountMeta(adapterAta, false, true);                          // kaynak: adaptörün yetkisine ait
        accs[3] = ICrossProgramInvocation.AccountMeta(_vaultFor(position), false, true);                 // programınızın kasası
        accs[4] = ICrossProgramInvocation.AccountMeta(SPL_TOKEN, false, false);

        bytes32[] memory salts = new bytes32[](1);
        salts[0] = _salt(msg.sender);
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeDeposit(amount), salts);
    }

    function withdraw(uint64 amount) external {
        bytes32 position = Helper.pda_with_salt(address(this), _salt(msg.sender));
        bytes32 userAta  = Helper.ata(msg.sender, USDC_MINT);            // hedef: kullanıcının kendi hesabı
        // ... aynı yapı: programınız `amount` tutarını kasadan userAta'ya taşır, `position` tarafından imzalanır
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeWithdraw(amount), salts);
    }
}
```

Adaptör hiçbir zaman `wUSDC` sözleşmeyi çağırmaz. Çekme işlemi, kullanıcının delegasyonunu harcayan bir HelperProgram çağrısıdır ve tokenlar şu token hesabında durur: `external_auth(adapter)` ona ait; bu yüzden CPI onları harcayabilir.

İmzalayıcı hakkında notlar. Rome tam olarak iki tür hesap için imzalar: çağıran sözleşmenin yalın yetkisi (`Helper.pda(address(this))`), bu `tuzlar`, ve `tuzlar`. Listelediğiniz her tuz, hesap listesinde imzalayıcı olarak görünmelidir; aksi halde çağrı şu hatayla başarısız olur: `sağlanan tohumdan hesaplanan imzalayıcı hesabı bulunamadı`. Kullanıcının kendi yetkisi dahil imzalayıcı olarak işaretlenen diğer hiçbir hesap Rome'dan tohum almaz ve Solana çalışma zamanı CPI'yi reddeder. Kullanıcının tokenlar üzerindeki hakları delegasyondan gelir, asla adaptörün kullanıcı olarak imzalamasından değil.

Çekme olmadan delegasyon: programınız doğrudan kullanıcının token hesabından harcayacaksa, kullanıcı şunu gönderir: `HelperProgram.approve_spl_raw_delegate(userAta, yourProgramPda, amount, mint, decimals)` doğrudan HelperProgram'a; programınızın PDA'sını SPL delege olarak adlandırır. Rome köprüsü bunu Wormhole için kullanır. Bölüm 3'teki tek-delege kuralı burada da geçerlidir: verilen yetki sarmalayıcının yetkisinin yerini alır.

## 8. Test etme

* Şunun üzerinde dağıtın: **Hadrian** önce (testnet, zincir 200010); adresler ve RPC şu adrestedir: [Sözleşme Adresleri](https://docs.rome.builders/tr/referans/contract-addresses.md) ve [kaydında](https://github.com/rome-protocol/rome-registry).
* `eth_call` ve `eth_estimateGas` proxy'nin gönderirken kullandığı aynı emülasyonu çalıştırır; bu nedenle orada başarısız olan bir CPI zincirde de aynı nedenle başarısız olur ve revert verisi alttaki Solana hatasını taşır (`evm-dışı çağrı hatası: …` Solana program günlüklerinde).
* Gerçekleşmiş bir EVM işleminin Solana tarafını şununla okuyun: `rome_solanaTxForEvmTx(hash)`; CU ve programınızın günlükleri Solana makbuzunda yer alır.
* Şu ortamda çalışan bir CPI: `eth_call` ancak gönderildiğinde reddediliyorsa, genellikle emülasyonun bildirdiği bir sınıra takılmıştır: 64 adres sınırı, atomik CU bütçesi (işlem yinelemeli hale gelmiştir) veya hat kuralı.

## 9. Referans

* [Precompile referansı](https://docs.rome.builders/tr/referans/precompiles.md) — her ön derlemedeki her seçici, gönderim sınıfı ve delegatecall kuralı ile.
* [Kısıtlar](https://docs.rome.builders/tr/temel-kavramlar/constraints.md) — yukarıdaki sınırların tek tabloda özeti.
* [Token Birlikte Çalışabilirliği](https://docs.rome.builders/tr/temel-kavramlar/token-interop.md) — sarmalayıcılar, kanonik mintler, deposit ve withdraw.
* Açık depolardaki referans uygulamalar: [cardo](https://github.com/rome-protocol/cardo) (kullanıcı CPI ön derlemesini doğrudan çağırır, B şekli), [rome-dex](https://github.com/rome-protocol/rome-dex) (doğrudan `invoke` artı vekâletsiz bir yönlendirici, C şekli), ve [aerarium](https://github.com/rome-protocol/aerarium) (paylaşılan tek bir piyasa üzerinde bir Compound III borç verme uygulaması; Solidity'den Solana programlarını çağırmaz (CPI yok), bu yüzden bir adaptör örneği değildir).


---

# 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/integrate-solana-program.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.
