> 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/urunler/rome-sdk.md).

# Rome SDK

EVM sözleşmelerinden Solana programlarını çağırmak için tiplenmiş Solidity arayüzleri ve ayrıca Rome'un zincir dışı hizmetlerinin arkasındaki Rust SDK.

Rome SDK, EVM akıllı sözleşmelerinden Solana programlarıyla etkileşim kurmak için tipli Solidity arayüzleri sağlar. Bu, Rome üzerinde runtime'lar arası uygulamalar geliştirmek için geliştirici araç setidir.

## SDK'ler

Rome, üç kitle için SDK'ler sunar — uygulama geliştiricileri (TypeScript), kontrat geliştiricileri (Solidity) ve kendi servislerini Rome üzerinde çalıştıran ekipler (Rust).

### TypeScript SDK (`@rome-protocol/sdk`)

**dapp ve ön yüz geliştiricileri için** — çoğu uygulama geliştiricisinin başladığı SDK. [`@rome-protocol/sdk`](https://github.com/rome-protocol/rome-sdk-ts) Rome yazma yolunu sarar, böylece bir web uygulaması Rome işlemlerini doğru şekilde gönderir: `submitRomeTx` (doğru yazma yolu ve gaz/ücret işleme), PDA / ATA türetimi, CPI `invoke` / `invoke_signed` kodlayıcılar, precompile bağlayıcıları ve bir `/bridge` alt yol. Depo öncelikli kurulum (npm yayını beklemede):

```bash
npm install github:rome-protocol/rome-sdk-ts#v0.4.0
```

```typescript
import { submitRomeTx } from '@rome-protocol/sdk';
// Herhangi bir Rome EVM yazmasını doğru yazma yolu üzerinden gönderin (gaz/ücret kodlamasını işler).
```

Genel [rome-dex](https://github.com/rome-protocol/rome-dex) uygulama SDK'nin yardımcılarının sadece birkaçını kullanır (PDA ve token hesabı türetimi, CPI `invoke` kodlayıcısı ve 1.3x gaz dolgusu) ve [cardo](https://github.com/rome-protocol/cardo) ona bağımlı değildir. Hiçbiri çağırmaz `submitRomeTx` veya `submitRomeTxV1`, bu yüzden onları bir uygulamanın CPI precompile'ını nasıl çağırdığını görmek için okuyun, SDK'nin yazma yolu için değil.

**İki kanal, tek SDK.** `submitRomeTx` EVM kanalıdır (MetaMask). For the **Solana kanalı** — EVM uygulamanızı yöneten bir Solana cüzdanı — `submitRomeTxV1` bunu yansıtır: proxy, çağrı için bir Solana v1 işlemi oluşturur, cüzdan aynı anahtarla iki kez imza atar (önce okunabilir bir yetkilendirme mesajı, sonra işlem) ve Rome, çağrıyı kullanıcının türetilmiş kimliğinden bir EVM işlemi olarak, EVM anahtarı olmadan çalıştırır. Tek bir işleme sığmayan bir çağrı, aynı yetkilendirme imzasıyla proxy tarafından iletilir ve `fundSyntheticGas` iletimle yapılan çağrının harcadığı yerel gazı tamamlar. Geri dönen bir iletilmiş çağrı şu değerle sonuçlanır: `receipt.status === "0x0"` hata fırlatmak yerine, bunu kontrol edin; [iletilmiş çağrılar ve uzun çağrılar](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-evm-from-solana.md#relayed-calls-and-long-calls) bölümünde gaz kuralı ve sınırlar vardır. Değer giriş ve çıkış yapar `buildFundLeg` / `buildSweepLeg` bir ERC-20 sarmalayıcısı olarak (örn. `wUSDC`), yerel değil `msg.value` — sentetik gönderici dinlenimde hiçbir şey tutmaz — ve ilk kez oluşturulan bir sentetik, bir kez ve açıkça şu şekilde sağlanır: `buildCreatePdaCall`. Daha önceki `submitRomeTxSolanaLane`istemcide eski bir Solana işlemi oluşturan yapı, hâlâ SDK'de yer alır. Bkz. [Çift hatlı bir uygulama oluşturma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/dual-lane-app.md) ve [Solana'dan EVM'yi çağırma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-evm-from-solana.md).

### Solidity SDK (`@rome-protocol/rome-solidity`)

**Solidity geliştiricileri için.** Precompile arayüzleri, ERC-20/SPL sarmalayıcıları, PDA türetimi ve CPI yardımcılarını sağlar. npm yayını beklemede; bugün bunları genel [`rome-solidity`](https://github.com/rome-protocol/rome-solidity) deposundan (git bağımlılığı veya kopyalanmış dosyalar) kullanırsınız.

```solidity
import {ISystemProgram, ICrossProgramInvocation, IHelperProgram, IWithdraw}
    from "@rome-protocol/rome-solidity/contracts/interface.sol";
import {SPL_ERC20} from "@rome-protocol/rome-solidity/contracts/erc20spl/erc20spl.sol";
import {RomeEVMAccount} from "@rome-protocol/rome-solidity/contracts/rome_evm_account.sol";
```

### Rust SDK (`rome-sdk`)

**Rome üzerinde kendi servislerini çalıştıran ekipler için.** İşlem oluşturma, Solana etkileşimi, gaz fiyatlandırması ve blok indekslemeyi yöneten bir Rust workspace'i. Proxy ve Hercules bunun üzerine inşa edilmiştir. Kaynak şurada: [`rome-protocol/rome-sdk`](https://github.com/rome-protocol/rome-sdk). Solana v1 işlemleri gönderir (4 KB, en fazla 64 hesap).

**Bunu derlemek.** Workspace, şu depoların [`rome-sdk`](https://github.com/rome-protocol/rome-sdk), [`rome-evm`](https://github.com/rome-protocol/rome-evm) ve [`mollusk`](https://github.com/rome-protocol/mollusk) yan yana klonlanmış olmasını bekler; çünkü diğer ikisine göreli yol üzerinden bağlıdır. Bu nedenle, onu başka bir projeden kullanmanın desteklenen yolu düz git bağımlılığı değil, bir path bağımlılığıdır. İlk derleme için Rust 1.85 veya üzeri ve ağ erişimi gerekir. `rome-evm` varsayılan ağ özelliğine sahip değildir, bu yüzden onu derleyen herhangi bir yapı tam olarak şunlardan birine ihtiyaç duyar: `ci`, `test ağı` veya `ana ağ`; kullanın `ci` yerel çalışma için, örneğin `cargo test -p rome-sdk --features ci`. Depo README'si tam adımları ve özellik tablosunu içerir.

**Lisans.** Rust SDK kaynak erişimli bir üründür, açık kaynak değildir: tüm hakları saklıdır ve kişisel, ticari olmayan amaçlarla kullanılabilir. Ticari kullanım için Rome Protocol'den yazılı izin gerekir; deponun `LICENSE` nasıl başvurulacağını anlatır.

## Solidity SDK: Neler Dahil

### Precompile Arayüzleri

Bir arayüzü precompile adresine bağlayın:

```solidity
ISystemProgram          constant System   = ISystemProgram(0xFF00000000000000000000000000000000000007);
ICrossProgramInvocation constant Cpi      = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);
IHelperProgram          constant Helper   = IHelperProgram(0xFF00000000000000000000000000000000000009);
IWithdraw               constant Withdraw = IWithdraw(0x4200000000000000000000000000000000000016);
// Önbelleğe alınmış yol: ISplCached 0xff…05, IAssociatedSplCached 0xff…06, ISystemCached 0xff…04, IWithdrawCached 0xff…0b
```

### SPL Token İşlemleri

Kullanın `IHelperProgram` (`0xff…09`) kullanıcı-PDA imzalı SPL ilkelleri için:

```solidity
// Bir mint için çağıranın ATA'sını oluşturun
Helper.create_ata(user, mint);

// SPL'yi çağıranın PDA'sından aktarın
Helper.transfer_spl(to, tokens, mint);
```

Önbelleğe alınmış yolda, eşdeğer işlemler şunlar üzerinde bulunur: `ISplCached` (`0xff…05`ve `IAssociatedSplCached` (`0xff…06`). Bkz. `interface.sol` tüm overload'lar için; bir kontrat tek bir yolu tutarlı biçimde kullanır.

### PDA Türetilmesi

```solidity
// Bir kullanıcının Solana PDA'sını türetin
bytes32 userPda = RomeEVMAccount.pda(msg.sender);

// Tuzla PDA türetin (kullanıcı başına birden çok PDA oluşturmak için)
bytes32 pda = RomeEVMAccount.pda_with_salt(msg.sender, salt);

// İstediğiniz PDA'yı bulun
(bytes32 pda, uint8 bump) = SystemProgram.find_program_address(programId, seeds);
```

### Programlar Arası Çağrı

```solidity
// Herhangi bir Solana programını çağırın
ICrossProgramInvocation.AccountMeta[] memory accounts = new ICrossProgramInvocation.AccountMeta[](2);
accounts[0] = ICrossProgramInvocation.AccountMeta(signerPda, true, true);
accounts[1] = ICrossProgramInvocation.AccountMeta(targetAccount, false, true);

CpiProgram.invoke(programId, accounts, instructionData);

// PDA ile imzalayarak çağırın
CpiProgram.invoke_signed(programId, accounts, data, seeds);

// Hesap verilerini okuyun
(uint64 lamports, bytes32 owner, bool isSigner, bool isWritable, bool executable, bytes memory data)
    = CpiProgram.account_info(pubkey);
```

### SPL Token'lar üzerinde ERC-20

```solidity
// Herhangi bir SPL mint'i için sarmalayıcı dağıtın
ERC20SPLFactory factory = ERC20SPLFactory(FACTORY_ADDRESS);
address wrapper = factory.add_spl_token_with_metadata(splMint);

// Sarmalayıcıyı standart ERC-20 olarak kullanın
SPL_ERC20 token = SPL_ERC20(wrapper);
token.transfer(recipient, amount);
uint256 balance = token.balanceOf(user);
```

### Borsh Serileştirmeden Geri Çözme

```solidity
import {Convert} from "@rome-protocol/rome-solidity/contracts/convert.sol";

// Solana hesap verilerini ayrıştırın (küçük endian Borsh biçimi)
(uint64 value, uint256 newOffset) = Convert.read_u64le(data, offset);
(bytes32 pubkey, uint256 newOffset2) = Convert.read_bytes32(data, offset);
```

### Metaplex Meta Verisi

```solidity
import {MplTokenMetadataLib} from "@rome-protocol/rome-solidity/contracts/mpl_token_metadata/lib.sol";

// Token metadata'sını Metaplex'ten yükleyin
MplTokenMetadataLib.Metadata memory meta = MplTokenMetadataLib.load_metadata(
    mintPubkey, mplProgramId, cpiAddress
);
string memory name = meta.name;
string memory symbol = meta.symbol;
```

## Rust SDK: Mimari

Rust SDK bir Cargo workspace'idir. Temel crate'leri:

| Crate               | Amaç                                                                                                                                             |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `rome-sdk`          | Çekirdek API: `Rome` struct, config ve üç işlem türü (`RheaTx`, `RemusTx`, `RomulusTx`)                                                          |
| `rome-evm-client`   | Rome zincirleri için EVM istemcisi, TxBuilder, ResourceFactory, emülatör entegrasyonu                                                            |
| `rome-solana`       | Solana tower, RPC istemcisi, işlem toplu işleme ve izleme                                                                                        |
| `rome-utils`        | RLP, hex, JSON-RPC, kimlik doğrulama yardımcıları                                                                                                |
| `rome-obs`          | OpenTelemetry gözlemlenebilirliği (izler, metrikler, günlükler)                                                                                  |
| `rome-meteora`      | Gaz fiyatlandırması için Meteora DAMM v1 ve v2 havuz okuyucuları                                                                                 |
| `rome-meta-hook`    | Meta-Hook Router programı için istemci: Token-2022 transfer-hook yapılandırması, ek hesap çözümleme, hesaplama bütçesi tahminleriyle transferler |
| `rome-jito-bundler` | Atomik çoklu işlem gönderimi için Jito paket oluşturucu                                                                                          |

### İşlem Türleri

```rust
// Tek bir Rome zincirinde tek bir EVM işlemi
let rhea = RheaTx::new(signed_eth_tx);
let mut tx = rome.compose_rollup_tx(rhea).await?;
let sig = rome.send_and_confirm(&mut *tx).await?;

// Farklı Rome zincirlerinde birkaç EVM işlemi, tek bir Solana işleminde atomik
let remus = RemusTx::new(vec![tx1, tx2]);
let mut tx = rome.compose_cross_rollup_tx(remus).await?;

// EVM işlemleri artı yerel Solana yönergeleri, tek bir Solana işleminde atomik
let romulus = RomulusTx::new(eth_txs, sol_ixs);
let mut tx = rome.compose_cross_chain_tx(romulus, signers).await?;
```

### Kaynak Havuzlama

SDK, paralel işlem gönderimi için Solana keypair'lerini (ödeyiciler) ve holder hesap indekslerini havuzlar:

```rust
let resource = resource_factory.get().await?;
let payer = resource.payer();       // Solana keypair
let holder = resource.holder();     // Holder hesap indeksi
// Kaynak, Drop sırasında otomatik olarak havuza geri döner
```

## SDK Yol Haritası

### Derlenmiş ve Çalışıyor

* SPL Token sarmalayıcıları ve precompile arayüzleri
* CPI üzerinden Meteora DAMM v1 takasları
* Oracle Gateway V1 + V2 (Pyth Pull, Switchboard V3)
* System Program yardımcıları, Borsh serileştirmeden geri çözme
* ERC20SPL Factory + köprü kontratları

## Sırada Ne Var

* [Solidity'yi dağıtın](https://docs.rome.builders/tr/gelistirici-kilavuzlari/deploy-solidity.md) — SDK'yi kullanarak ilk kontratınızı dağıtın
* [EVM'den Solana'yı çağırma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-solana-from-evm.md) — Solana programlarıyla etkileşim için CPI kullanın
* [Sözleşme Adresleri](https://docs.rome.builders/tr/referans/contract-addresses.md) — dağıtılmış SDK kontrat adresleri


---

# 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/urunler/rome-sdk.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.
