# Rome SDK

Rome SDK menyediakan antarmuka Solidity bertipe untuk berinteraksi dengan program Solana dari smart contract EVM. Ini adalah toolkit developer untuk membangun aplikasi lintas runtime di Rome.

## Dua SDK

Rome memiliki dua SDK yang melayani tujuan berbeda:

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

**Untuk developer Solidity.** Menyediakan antarmuka precompile, wrapper ERC-20/SPL, derivasi PDA, dan utilitas CPI. Instal melalui npm dan impor ke dalam contract Solidity Anda.

```bash
npm install @rome-protocol/solidity-sdk
```

```solidity
import {SplToken, CpiProgram, SystemProgram} from "@rome-protocol/solidity-sdk/contracts/core/Precompiles.sol";
import {SPL_ERC20} from "@rome-protocol/solidity-sdk/contracts/token/ERC20SPL.sol";
import {RomeEVMAccount} from "@rome-protocol/solidity-sdk/contracts/core/RomeEVMAccount.sol";
```

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

**Untuk operator infrastruktur.** Workspace Rust dengan 9 crate yang menangani komposisi transaksi, interaksi Solana, penetapan harga gas, pengindeksan blok, dan orkestrasi layanan. Digunakan oleh Proxy, Hercules, dan Rhea.

## SDK Solidity: Apa yang Disertakan

### Antarmuka Precompile

Konstanta singleton yang sudah terikat untuk semua precompile Rome:

```solidity
// Tersedia secara global setelah impor
ISplToken constant SplToken;                    // 0xff...05
IAssociatedSplToken constant AssociatedSplToken; // 0xff...06
ISystemProgram constant SystemProgram;           // 0xff...07
ICrossProgramInvocation constant CpiProgram;     // 0xff...08
IWithdraw constant Withdraw;                     // 0x42...16
```

### Operasi Token SPL

```solidity
// Baca status akun token
ISplToken.Account memory acc = SplToken.account_state(tokenAccountPubkey);
uint64 balance = acc.amount;
bytes32 owner = acc.owner;

// Transfer token
SplToken.transfer(recipientAta, mintPubkey, amount);

// Inisialisasi akun token baru
SplToken.initialize_account3(newAccount, mintPubkey, ownerPubkey);
```

### Derivasi PDA

```solidity
// Derive PDA Solana milik pengguna
bytes32 userPda = RomeEVMAccount.pda(msg.sender);

// Derive 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);
```

### Pemanggilan Lintas-Program

```solidity
// Panggil program Solana mana 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);
```

### Register Token

```solidity
TokenRegistry registry = TokenRegistry(REGISTRY_ADDRESS);

// Daftarkan dengan metadata lintas-chain
registry.registerToken(splMint, TokenOrigin.WormholeWrapped, externalAddr, chainId);

// Cari berdasarkan token eksternal
TokenEntry memory entry = registry.getTokenByExternal(2, ethUsdcAddress);
```

### Deserialisasi Borsh

```solidity
import {Convert} from "@rome-protocol/solidity-sdk/contracts/core/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/solidity-sdk/contracts/programs/metadata/MplTokenMetadataLib.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 dengan 9 crate:

| 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-geth`       | integrasi OP-Geth Engine API untuk pembuatan blok                            |
| `rome-utils`      | utilitas RLP, hex, JSON-RPC, autentikasi                                     |
| `rome-obs`        | observabilitas OpenTelemetry (trace, metrik, log)                            |
| `rome-da`         | lapisan ketersediaan data Celestia                                           |
| `rome-meteora`    | adapter pool AMM Meteora DEX untuk penetapan harga gas                       |
| `rome-meta-hook`  | klien router Token-2022 Transfer Hook                                        |

### Tipe Transaksi

```rust
// Transaksi rollup tunggal
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
// Resource otomatis dikembalikan ke pool saat Drop
```

## Roadmap SDK

### Sudah Dibuat 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 + contract bridge
* Register Token dengan metadata lintas-chain

### Sedang Berlangsung

* JupiterRouter (antarmuka Solidity untuk swap Jupiter)
* klien SDK Meta-Hook Router

### Direncanakan (Tahap 2)

| Antarmuka | Protokol               |
| --------- | ---------------------- |
| IJupiter  | aggregator DEX Jupiter |
| IDrift    | perpetual Drift        |
| IKamino   | lending Kamino         |
| IMeteora  | likuiditas Meteora     |
| IOndoGM   | RWA Ondo               |

### Direncanakan (Tahap 3)

| Antarmuka     | Program           |
| ------------- | ----------------- |
| IStakeProgram | Stake Solana      |
| IVoteProgram  | Vote Solana       |
| ISlotHashes   | Sysvar SlotHashes |

## Selanjutnya

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


---

# Agent Instructions: 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:

```
GET https://docs.rome.builders/id/produk/rome-sdk.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.