> 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

Antarmuka Solidity bertipe untuk memanggil program Solana dari kontrak EVM, plus SDK Rust di balik layanan off-chain Rome.

Rome SDK 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 — pembuat aplikasi (TypeScript), pengembang kontrak (Solidity), dan tim yang menjalankan layanan mereka sendiri di Rome (Rust).

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

**Untuk pengembang dapp dan frontend** — SDK yang paling sering digunakan para pembuat aplikasi untuk memulai. [`@rome-protocol/sdk`](https://github.com/rome-protocol/rome-sdk-ts) membungkus jalur penulisan Rome sehingga 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. Instalasi berbasis repo terlebih dahulu (publikasi npm masih menunggu):

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

```typescript
import { submitRomeTx } from '@rome-protocol/sdk';
// Kirimkan penulisan EVM Rome apa pun melalui jalur penulisan yang benar (menangani pengkodean gas/biaya).
```

Publik [rome-dex](https://github.com/rome-protocol/rome-dex) Aplikasi hanya menggunakan beberapa helper SDK (derivasi PDA dan akun token, `invoke` encoder CPI dan padding gas 1,3x), dan [cardo](https://github.com/rome-protocol/cardo) tidak bergantung padanya. Juga tidak memanggil `submitRomeTx` atau `submitRomeTxV1`, jadi bacalah untuk melihat bagaimana sebuah aplikasi memanggil precompile CPI, bukan untuk jalur penulisan SDK.

**Dua jalur, satu SDK.** `submitRomeTx` adalah jalur EVM (MetaMask). Untuk **jalur Solana** — dompet Solana yang menjalankan aplikasi EVM Anda — `submitRomeTxV1` menirunya: proxy menyusun satu transaksi Solana v1 untuk panggilan tersebut, wallet menandatangani dua kali dengan kunci yang sama (pesan otorisasi yang dapat dibaca, lalu transaksinya), dan Rome menjalankan panggilan itu sebagai transaksi EVM dari identitas turunan pengguna, tanpa kunci EVM. Panggilan yang tidak muat dalam satu transaksi diteruskan oleh proxy dengan tanda tangan otorisasi yang sama, dan `fundSyntheticGas` menambah gas native yang dihabiskan oleh panggilan yang diteruskan. Panggilan yang diteruskan dan dibatalkan akan diselesaikan dengan `receipt.status === "0x0"` alih-alih melempar, jadi periksalah; bagian [panggilan yang diteruskan dan panggilan panjang](https://docs.rome.builders/id/panduan-pengembang/call-evm-from-solana.md#relayed-calls-and-long-calls) ini memiliki aturan gas dan batasnya. Nilai keluar-masuk 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 sekali, secara eksplisit, dengan `buildCreatePdaCall`. Yang sebelumnya `submitRomeTxSolanaLane`, yang membuat transaksi Solana lawas di klien, masih ada di SDK. Lihat [Bangun aplikasi jalur ganda](https://docs.rome.builders/id/panduan-pengembang/dual-lane-app.md) dan [Panggil EVM dari Solana](https://docs.rome.builders/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. Publikasi npm masih menunggu; saat ini Anda mengonsumsinya 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 tim yang menjalankan layanan mereka sendiri di Rome.** Workspace Rust yang menangani penyusunan transaksi, interaksi Solana, penetapan harga gas, dan pengindeksan blok. Proxy dan Hercules dibangun di atasnya. Kode sumbernya ada di [`rome-protocol/rome-sdk`](https://github.com/rome-protocol/rome-sdk). Ini mengirim transaksi Solana v1 (4 KB, hingga 64 akun).

**Membangunnya.** Workspace ini mengharapkan repositori [`rome-sdk`](https://github.com/rome-protocol/rome-sdk), [`rome-evm`](https://github.com/rome-protocol/rome-evm) dan [`mollusk`](https://github.com/rome-protocol/mollusk) dikonter sejajar, karena ia bergantung pada dua repositori lainnya melalui path relatif. Itulah juga sebabnya cara yang didukung untuk menggunakannya dari proyek lain adalah dependensi path, bukan dependensi git biasa. Anda memerlukan Rust 1.85 atau lebih baru dan akses jaringan untuk build pertama. `rome-evm` tidak memiliki fitur jaringan bawaan, jadi build apa pun yang mengompilasinya memerlukan tepat salah satu dari `ci`, `testnet` atau `mainnet`; gunakan `ci` untuk pekerjaan lokal, misalnya `cargo test -p rome-sdk --features ci`. README repositori berisi langkah lengkap dan tabel fitur.

**Lisensi.** SDK Rust tersedia sumbernya, tetapi bukan sumber terbuka: seluruh hak dilindungi dan boleh digunakan untuk keperluan pribadi nonkomersial. Penggunaan komersial memerlukan izin tertulis dari Rome Protocol; `LICENSE` berisi cara untuk meminta izin.

## SDK Solidity: Apa Saja yang Termasuk

### Antarmuka Precompile

Ikat 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 cached: ISplCached 0xff…05, IAssociatedSplCached 0xff…06, ISystemCached 0xff…04, IWithdrawCached 0xff…0b
```

### Operasi Token SPL

Gunakan `IHelperProgram` (`0xff…09`) untuk primitif SPL yang ditandatangani oleh PDA pengguna:

```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 cached, operasi yang setara berada 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);

// Temukan PDA arbitrer
(bytes32 pda, uint8 bump) = SystemProgram.find_program_address(programId, seeds);
```

### Pemanggilan Lintas Program

```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 mint SPL apa pun
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";

// Uraikan 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, konfigurasi, tiga tipe transaksi (`RheaTx`, `RemusTx`, `RomulusTx`)                                                |
| `rome-evm-client`   | klien EVM untuk chain Rome, 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`      | pembaca pool Meteora DAMM v1 dan v2 untuk penetapan harga gas                                                                               |
| `rome-meta-hook`    | Klien untuk program Meta-Hook Router: konfigurasi transfer-hook Token-2022, resolusi akun tambahan, transfer dengan estimasi compute-budget |
| `rome-jito-bundler` | pembuat bundel Jito untuk pengiriman multi-transaksi atomik                                                                                 |

### Tipe Transaksi

```rust
// Satu transaksi EVM pada satu chain Rome
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?;

// Beberapa transaksi EVM pada chain Rome yang berbeda, atomik dalam satu transaksi Solana
let remus = RemusTx::new(vec![tx1, tx2]);
let mut tx = rome.compose_cross_rollup_tx(remus).await?;

// Transaksi EVM plus instruksi Solana native, atomik dalam satu transaksi Solana
let romulus = RomulusTx::new(eth_txs, sol_ixs);
let mut tx = rome.compose_cross_chain_tx(romulus, signers).await?;
```

### Pooling Sumber Daya

SDK mengelompokkan keypair Solana (pembayar) 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 melalui CPI
* Oracle Gateway V1 + V2 (Pyth Pull, Switchboard V3)
* helper System Program, deserialisasi Borsh
* Factory ERC20SPL + kontrak bridge

## Langkah Berikutnya

* [Deploy Solidity](https://docs.rome.builders/id/panduan-pengembang/deploy-solidity.md) — deploy kontrak pertama Anda menggunakan SDK
* [Panggil Solana dari EVM](https://docs.rome.builders/id/panduan-pengembang/call-solana-from-evm.md) — gunakan CPI untuk berinteraksi dengan program Solana
* [Contract Addresses](https://docs.rome.builders/id/referensi/contract-addresses.md) — alamat kontrak SDK yang telah dideploy


---

# 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/id/produk/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.
