> 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 çalışma zamanı arası uygulamalar geliştirmek için geliştirici araç setidir. ## SDK'lar Rome'un üç kitle için SDK'ları vardır — uygulama geliştiricileri (TypeScript), sözleşme geliştiricileri (Solidity) ve kendi hizmetlerini Rome üzerinde çalıştıran ekipler (Rust). ### TypeScript SDK (`@rome-protocol/sdk`) **dapp ve ön yüz geliştiricileri için** — uygulama geliştiricilerinin çoğunun başladığı SDK. [`@rome-protocol/sdk`](https://github.com/rome-protocol/rome-sdk-ts) bir web uygulamasının Rome işlemlerini doğru şekilde göndermesi için Rome yazma yolunu sarmalar: `submitRomeTx` (doğru yazma yolu ve gas/ücret yönetimi), PDA / ATA türetimi, CPI `invoke` / `invoke_signed` kodlayıcılar, precompile bağlamaları 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 yazımını doğru yazma yolu üzerinden gönderin (gas/ücret kodlamasını işler). ``` Genel [rome-dex](https://github.com/rome-protocol/rome-dex) uygulama yalnızca SDK'nin birkaç yardımcı işlevini kullanır (PDA ve token-hesabı türetimi, CPI `invoke` kodlayıcısı ve 1,3x gas tamponu) ve [cardo](https://github.com/rome-protocol/cardo) ona bağlı değildir. Ne de çağrı yapar `submitRomeTx` veya `submitRomeTxV1`, bu yüzden bir uygulamanın CPI precompile'ını nasıl çağırdığı için okuyun, SDK'nin yazma yolu için değil. **İki hat, tek SDK.** `submitRomeTx` EVM hattıdır (MetaMask). İçin **Solana hattı** — EVM uygulamanızı yöneten bir Solana cüzdanı — `submitRomeTxV1` bunu yansıtır: proxy, çağrı için tek bir Solana v1 işlemi oluşturur, cüzdan aynı anahtarla iki kez imzalar (önce okunabilir bir yetkilendirme mesajı, ardından 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` iletilen bir çağrının harcadığı yerel gas'i tamamlar. Geri dönen bir iletilmiş çağrı şu sonuçla çözülür: `receipt.status === "0x0"` hata fırlatmak yerine, bu yüzden bunu kontrol edin; [iletilmiş çağrılar ve uzun çağrılar](/tr/gelistirici-kilavuzlari/call-evm-from-solana.md#relayed-calls-and-long-calls) bölümü gas kuralını ve limitleri içerir. Değer şu yolla içeri ve dışarı hareket eder: `buildFundLeg` / `buildSweepLeg` bir ERC-20 sarmalayıcısı olarak (ör. `wUSDC`), yerel değil `msg.value` — sentetik gönderici dinlenme halinde hiçbir şey tutmaz — ve ilk kez oluşturulan bir sentetik, açıkça, bir kez şu şekilde sağlanır: `buildCreatePdaCall`. Daha önceki `submitRomeTxSolanaLane`, istemci içinde eski bir Solana işlemi oluşturan, hâlâ SDK içindedir. Bakın [Çift hatlı bir uygulama oluşturma](/tr/gelistirici-kilavuzlari/dual-lane-app.md) ve [Solana'dan EVM'yi çağırma](/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) depodan (git bağımlılığı veya kopyalanmış dosyalar). ```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`) **Kendi hizmetlerini Rome üzerinde çalıştıran ekipler için.** İşlem oluşturma, Solana etkileşimi, gas fiyatlandırması ve blok indekslemeyi yöneten bir Rust çalışma alanı. Proxy ve Hercules bunun üzerine inşa edilmiştir. Kaynak şuradadır: [`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.** Çalışma alanı, ş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 ile bağımlıdır. Bu nedenle başka bir projeden kullanmanın desteklenen yolu düz bir git bağımlılığı değil, bir yol bağımlılığıdır. İlk derleme için Rust 1.85 veya sonrası ve ağ erişimi gerekir. `rome-evm` varsayılan bir ağ özelliğine sahip değildir, bu nedenle onu derleyen herhangi bir derleme tam olarak şunlardan birine ihtiyaç duyar: `ci`, `testnet` veya `mainnet`; kullanın `ci` yerel çalışma için, örneğin `cargo test -p rome-sdk --features ci`. Depodaki README tam adımları ve özellik tablosunu içerir. **Lisans.** Rust SDK kaynak erişimlidir, açık kaynak değildir: tüm hakları saklıdır ve kişisel, ticari olmayan amaçlar için kullanılabilir. Ticari kullanım için Rome Protocol'den yazılı izin gerekir; deponun `LICENSE` dosyası nasıl başvurulacağını söyler. ## 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 `IHelperProgram` (`0xff…09`) kullanıcı-PDA imzalı SPL temel işlemleri için: ```solidity // Bir mint için çağıranın ATA'sını oluşturun Helper.create_ata(user, mint); // Çağıranın PDA'sından SPL aktarın Helper.transfer_spl(to, tokens, mint); ``` Önbelleğe alınmış yolda, eşdeğer işlemler şurada bulunur: `ISplCached` (`0xff…05`) ve `IAssociatedSplCached` (`0xff…06`). Bakın `interface.sol` tüm overload'lar için; bir sözleşme bir yolu tutarlı şekilde 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 fazla PDA oluşturmak için) bytes32 pda = RomeEVMAccount.pda_with_salt(msg.sender, salt); // Keyfi PDA 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 imzasıyla çağırın CpiProgram.invoke_signed(programId, accounts, data, seeds); // Hesap verisini okuyun (uint64 lamports, bytes32 owner, bool isSigner, bool isWritable, bool executable, bytes memory data) = CpiProgram.account_info(pubkey); ``` ### SPL Tokenları Üzerinde ERC-20 ```solidity // Herhangi bir SPL mint 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 Seri Dışına Çıkarma ```solidity import {Convert} from "@rome-protocol/rome-solidity/contracts/convert.sol"; // Solana hesap verisini ayrıştırın (little-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 meta verisini 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 çalışma alanıdır. Temel crate'leri: | Crate | Amaç | | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | | `rome-sdk` | Çekirdek API: `Rome` yapısı, yapılandırma, işlem türleri (RheaTx, RemusTx, RomulusTx) | | `rome-evm-client` | EVM rollup istemcisi, TxBuilder, ResourceFactory, emülatör entegrasyonu | | `rome-solana` | Solana kulesi, 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` | gas 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, compute-budget tahminleriyle transferler | | `rome-jito-bundler` | atomik çoklu işlem gönderimi için Jito paket oluşturucu | ### İşlem Türleri ```rust // Tek rollup 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?; // Rollup'lar arası atomik işlem let remus = RemusTx::new(vec![tx1, tx2]); let mut tx = rome.compose_cross_rollup_tx(remus).await?; // Zincirler arası atomik işlem (EVM + Solana) 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 anahtar çiftlerini (ödeyiciler) ve holder hesap dizinlerini havuzlar: ```rust let resource = resource_factory.get().await?; let payer = resource.payer(); // Solana anahtar çifti let holder = resource.holder(); // Holder hesap dizini // 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 seri dışına çıkarma * ERC20SPL Factory + köprü sözleşmeleri ## Sırada Ne Var * [Solidity dağıt](/tr/gelistirici-kilavuzlari/deploy-solidity.md) — SDK'yi kullanarak ilk sözleşmenizi dağıtın * [EVM'den Solana'yı çağırma](/tr/gelistirici-kilavuzlari/call-solana-from-evm.md) — Solana programlarıyla etkileşim kurmak için CPI kullanın * [Sözleşme Adresleri](/tr/referans/contract-addresses.md) — dağıtılmış SDK sözleşme 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=&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.