> 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/id/produk/rome-sdk.md). # Rome SDK SDK Rome menyediakan antarmuka Solidity bertipe untuk berinteraksi dengan program Solana dari smart contract EVM. Ini adalah toolkit pengembang untuk membangun aplikasi lintas runtime di Rome. ## SDK Rome memiliki SDK untuk tiga audiens — pembangun aplikasi (TypeScript), pengembang kontrak (Solidity), dan operator infrastruktur (Rust). ### SDK TypeScript (`@rome-protocol/sdk`) **Untuk pengembang dapp dan frontend** — SDK yang paling sering dipakai oleh pembuat aplikasi sebagai titik awal. [`@rome-protocol/sdk`](https://github.com/rome-protocol/rome-sdk-ts) membungkus jalur penulisan Rome agar aplikasi web mengirim transaksi Rome dengan benar: `submitRomeTx` (jalur penulisan yang benar plus penanganan gas/biaya), derivasi PDA / ATA, CPI `invoke` / `invoke_signed` encoder, binding precompile, dan sebuah `/bridge` subpath. Instal dari repo terlebih dahulu (npm publish menunggu): ```bash npm install github:rome-protocol/rome-sdk-ts#v0.2.1 ``` ```typescript import { submitRomeTx } from '@rome-protocol/sdk'; // Kirim penulisan EVM Rome apa pun melalui jalur penulisan yang benar (menangani encoding gas/biaya). ``` Aplikasi referensi publik — [rome-dex](https://github.com/rome-protocol/rome-dex) dan [cardo](https://github.com/rome-protocol/cardo) — menggunakan SDK ini. **Dua jalur, satu SDK.** `submitRomeTx` adalah jalur EVM (MetaMask). Untuk **jalur Solana** — dompet Phantom/Solana yang menjalankan aplikasi EVM Anda — `submitRomeTxSolanaLane` menirunya: pengguna menandatangani transaksi Solana dan Rome menjalankannya sebagai transaksi EVM dari identitas turunan mereka, tanpa kunci EVM. Nilai berpindah masuk dan keluar melalui `buildFundLeg` / `buildSweepLeg` sebagai wrapper ERC-20 (mis. `wUSDC`), bukan native `msg.value` — pengirim sintetis tidak menyimpan apa pun saat diam — dan sintetis pertama kali disediakan otomatis pada penggunaan pertama. Lihat [Bangun aplikasi dua jalur](/id/panduan-pengembang/dual-lane-app.md) dan [Panggil EVM dari Solana](/id/panduan-pengembang/call-evm-from-solana.md). ### SDK Solidity (`@rome-protocol/rome-solidity`) **Untuk pengembang Solidity.** Menyediakan antarmuka precompile, wrapper ERC-20/SPL, derivasi PDA, dan utilitas CPI. Publish npm masih menunggu; saat ini Anda menggunakan ini dari [`rome-solidity`](https://github.com/rome-protocol/rome-solidity) repo publik (dependensi git atau file yang disalin). ```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"; ``` ### SDK Rust (`rome-sdk`) **Untuk operator infrastruktur.** Workspace Rust yang menangani penyusunan transaksi, interaksi Solana, penentuan harga gas, dan pengindeksan blok. Digunakan oleh Proxy dan Hercules. ## SDK Solidity: Apa Saja yang Termasuk ### Antarmuka Precompile Hubungkan sebuah antarmuka ke alamat precompile-nya: ```solidity ISystemProgram constant System = ISystemProgram(0xFF00000000000000000000000000000000000007); ICrossProgramInvocation constant Cpi = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008); IHelperProgram constant Helper = IHelperProgram(0xFF00000000000000000000000000000000000009); IWithdraw constant Withdraw = IWithdraw(0x4200000000000000000000000000000000000016); // Jalur cache: ISplCached 0xff…05, IAssociatedSplCached 0xff…06, ISystemCached 0xff…04, IWithdrawCached 0xff…0b ``` ### Operasi Token SPL Gunakan `IHelperProgram` (`0xff…09`) untuk primitif SPL yang ditandatangani user-PDA: ```solidity // Buat ATA pemanggil untuk sebuah mint Helper.create_ata(user, mint); // Transfer SPL dari PDA pemanggil Helper.transfer_spl(to, tokens, mint); ``` Pada jalur cache, operasi yang setara ada di `ISplCached` (`0xff…05`) dan `IAssociatedSplCached` (`0xff…06`). Lihat `interface.sol` untuk semua overload; sebuah kontrak menggunakan satu jalur secara konsisten. ### Derivasi PDA ```solidity // Derivasikan PDA Solana milik pengguna bytes32 userPda = RomeEVMAccount.pda(msg.sender); // Derivasikan PDA dengan salt (untuk membuat beberapa PDA per pengguna) bytes32 pda = RomeEVMAccount.pda_with_salt(msg.sender, salt); // Cari PDA arbitrer (bytes32 pda, uint8 bump) = SystemProgram.find_program_address(programId, seeds); ``` ### Cross-Program Invocation ```solidity // Panggil program Solana apa pun 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); // Panggil dengan penandatanganan PDA CpiProgram.invoke_signed(programId, accounts, data, seeds); // Baca data akun (uint64 lamports, bytes32 owner, bool isSigner, bool isWritable, bool executable, bytes memory data) = CpiProgram.account_info(pubkey); ``` ### ERC-20 di atas Token SPL ```solidity // Deploy wrapper untuk setiap mint SPL ERC20SPLFactory factory = ERC20SPLFactory(FACTORY_ADDRESS); address wrapper = factory.add_spl_token_with_metadata(splMint); // Gunakan wrapper sebagai ERC-20 standar SPL_ERC20 token = SPL_ERC20(wrapper); token.transfer(recipient, amount); uint256 balance = token.balanceOf(user); ``` ### Deserialisasi Borsh ```solidity import {Convert} from "@rome-protocol/rome-solidity/contracts/convert.sol"; // Parse data akun Solana (format Borsh little-endian) (uint64 value, uint256 newOffset) = Convert.read_u64le(data, offset); (bytes32 pubkey, uint256 newOffset2) = Convert.read_bytes32(data, offset); ``` ### Metadata Metaplex ```solidity import {MplTokenMetadataLib} from "@rome-protocol/rome-solidity/contracts/mpl_token_metadata/lib.sol"; // Muat metadata token dari Metaplex MplTokenMetadataLib.Metadata memory meta = MplTokenMetadataLib.load_metadata( mintPubkey, mplProgramId, cpiAddress ); string memory name = meta.name; string memory symbol = meta.symbol; ``` ## Arsitektur SDK Rust SDK Rust adalah workspace Cargo. Crate intinya: | Crate | Tujuan | | ------------------- | ---------------------------------------------------------------------------- | | `rome-sdk` | API Inti: `Rome` struct, config, tipe transaksi (RheaTx, RemusTx, RomulusTx) | | `rome-evm-client` | klien rollup EVM, TxBuilder, ResourceFactory, integrasi emulator | | `rome-solana` | tower Solana, klien RPC, batching dan pelacakan transaksi | | `rome-utils` | utilitas RLP, hex, JSON-RPC, autentikasi | | `rome-obs` | observabilitas OpenTelemetry (trace, metrik, log) | | `rome-meteora` | adapter pool Meteora DEX AMM untuk penetapan harga gas | | `rome-jito-bundler` | pembuat bundle Jito untuk pengiriman atomik multi-transaksi | ### Tipe Transaksi ```rust // Satu transaksi rollup 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?; // Transaksi atomik lintas-rollup let remus = RemusTx::new(vec![tx1, tx2]); let mut tx = rome.compose_cross_rollup_tx(remus).await?; // Transaksi atomik lintas-chain (EVM + Solana) let romulus = RomulusTx::new(eth_txs, sol_ixs); let mut tx = rome.compose_cross_chain_tx(romulus, signers).await?; ``` ### Pooling Sumber Daya SDK meng-pool keypair Solana (payer) dan indeks akun holder untuk pengiriman transaksi paralel: ```rust let resource = resource_factory.get().await?; let payer = resource.payer(); // Keypair Solana let holder = resource.holder(); // Indeks akun holder // Sumber daya otomatis dikembalikan ke pool saat Drop ``` ## Roadmap SDK ### Sudah Dibangun dan Berfungsi * Wrapper token SPL dan antarmuka precompile * Swap Meteora DAMM v1 via CPI * Oracle Gateway V1 + V2 (Pyth Pull, Switchboard V3) * Helper System Program, deserialisasi Borsh * ERC20SPL Factory + kontrak bridge ## Berikutnya * [Deploy Solidity](/id/panduan-pengembang/deploy-solidity.md) — deploy kontrak pertama Anda menggunakan SDK * [Panggil Solana dari EVM](/id/panduan-pengembang/call-solana-from-evm.md) — gunakan CPI untuk berinteraksi dengan program Solana * [Alamat Kontrak](/id/referensi/contract-addresses.md) — alamat kontrak SDK yang telah di-deploy --- # 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 dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://docs.rome.builders/id/produk/rome-sdk.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.