# Arsitektur

Rome Protocol menyematkan interpreter bytecode EVM di dalam program on-chain Solana. Halaman ini menjelaskan bagaimana komponen-komponennya saling terhubung.

## Ikhtisar Sistem

```
┌─────────────────────────────────────────────────────────────────┐
│                        Lapisan Pengguna                         │
│   MetaMask / ethers.js / Hardhat / Foundry                      │
│   (JSON-RPC Ethereum Standar)                                   │
└──────────────────────┬──────────────────────────────────────────┘
                       │
            ┌──────────┴──────────┐
            ▼                     ▼
   ┌────────────────┐    ┌────────────────┐
   │  Rome Proxy    │    │   OP-Geth      │
   │  (:9090)       │    │   (:8545)      │
   │  JSON-RPC      │    │   RPC EVM      │
   └───────┬────────┘    └───────┬────────┘
           │                     │
           │              ┌──────┴──────┐
           │              │    Rhea     │  (meneruskan tx geth ke Solana)
           │              └──────┬──────┘
           │                     │
           └──────────┬──────────┘
                      ▼
   ┌──────────────────────────────────────────────────────────────┐
   │                    Runtime Solana                             │
   │                                                              │
   │   ┌──────────────────────────────────────────────────┐       │
   │   │              Program Rome EVM                     │       │
   │   │                                                   │       │
   │   │   Interpreter Bytecode EVM (fork SputnikVM)       │       │
   │   │   Pemetaan Akun: H160 → Solana PDA               │       │
   │   │   Precompile: ecrecover, BN254, SPL, CPI, dll.   │       │
   │   └───────────────────────┬───────────────────────────┘       │
   │                           │ CPI                               │
   │   ┌───────────┬───────────┼───────────┬───────────┐          │
   │   │Token SPL  │ Jupiter   │ Kamino    │ Meteora   │  ...     │
   │   └───────────┴───────────┴───────────┴───────────┘          │
   └──────────────────────────────────────────────────────────────┘
                      ▲
                      │ Mengindeks event
               ┌──────┴──────┐
               │  Hercules   │  (pengindeks blok → Engine API → OP-Geth)
               └─────────────┘
```

## Komponen

### Program Rome EVM (On-Chain)

Inti dari Rome — sebuah program Solana BPF yang berisi interpreter bytecode EVM lengkap (fork dari SputnikVM). Program ini:

* Menerima transaksi EVM yang diserialisasi dari instruksi Solana
* Menjalankan bytecode Solidity di dalam runtime Solana
* Memetakan alamat Ethereum (H160) ke Solana PDA
* Menyediakan antarmuka precompile untuk CPI, Token SPL, Program Sistem
* Mengelola state EVM (penyimpanan kontrak, saldo, nonce) sebagai data akun Solana

### Rome Proxy (Server JSON-RPC)

Server JSON-RPC Ethereum standar pada port 9090 yang menerjemahkan panggilan API Ethereum menjadi transaksi Solana:

* `eth_sendRawTransaction` → serialisasi tx EVM → kirim instruksi Solana
* `eth_call` → emulasikan eksekusi EVM di luar chain (melalui emulator SVM Mollusk)
* `eth_estimateGas` → simulasi eksekusi untuk estimasi gas
* `eth_getBalance`, `eth_getCode`, dll. → baca dari data akun Solana

Ekstensi Rome: `rome_emulateTx`, `rome_emulateRegRollup`, `rome_mintId`, `rome_buildInfo`, `rome_getResources`.

### OP-Geth (Lapisan RPC EVM Opsional)

Klien Go-Ethereum yang dimodifikasi yang menyediakan kompatibilitas penuh RPC Ethereum. Dalam mode op-geth:

1. Pengguna mengirim transaksi ke OP-Geth (:8545)
2. Rhea meneruskan transaksi ke Rome Proxy → Solana
3. Hercules mengindeks event Solana dan memasok blok EVM ke OP-Geth melalui Engine API (:8551)

Dalam mode single-state, pengguna terhubung langsung ke Rome Proxy (:9090), sepenuhnya melewati OP-Geth.

### Hercules (Pengindeks)

Memantau program Rome EVM di Solana dan menghasilkan data blok yang kompatibel dengan EVM:

* Memantau event program Rome di Solana
* Merekonstruksi blok EVM dengan receipt transaksi, log, dan perubahan state
* Memasok blok ke OP-Geth melalui Engine API untuk kompatibilitas standar block explorer
* Didukung oleh PostgreSQL

### Rhea (Jembatan Mempool)

Menjembatani mempool OP-Geth ke Solana:

* Membaca transaksi tertunda dari mempool OP-Geth
* Membungkusnya sebagai instruksi Solana yang menargetkan program Rome EVM
* Mengirim ke Solana untuk dieksekusi

## Mode Eksekusi

Rome mendukung dua mode eksekusi untuk transaksi EVM:

### Eksekusi Atomik (VmAt)

Satu transaksi Solana. Seluruh transaksi EVM dieksekusi dalam anggaran komputasi satu transaksi Solana (\~1,4 juta unit komputasi). Digunakan untuk sebagian besar operasi — transfer, panggilan kontrak sederhana, swap.

### Eksekusi Iteratif (VmIt)

Untuk operasi intensif komputasi yang melebihi anggaran satu transaksi. Eksekusi EVM dipecah ke beberapa transaksi Solana:

1. Setiap langkah mengeksekusi \~500 opcode EVM
2. State VM diserialisasi dengan Borsh ke sebuah `StateHolder` akun di antara langkah-langkah
3. Akun dikunci TTL selama 3-4 detik saat eksekusi
4. Digunakan untuk operasi berat seperti pairing BN254 (verifikasi bukti ZK)

## Pemetaan Akun

Setiap alamat Ethereum (20 byte) dipetakan ke Solana PDA (32 byte) yang diturunkan dari program Rome EVM:

```
Alamat Ethereum (H160) → PDA = findProgramAddress([address], ROME_EVM_PROGRAM)
```

PDA ini memiliki:

* Saldo ETH/token (sebagai akun token SPL)
* Bytecode kontrak (disimpan dalam data akun Solana)
* Slot penyimpanan kontrak (disimpan dalam data akun Solana)
* Nonce

## Akun Holder

Transaksi Solana dibatasi hingga 1.232 byte. Transaksi EVM (terutama deployment kontrak) bisa jauh lebih besar. Rome menanganinya dengan **akun holder**:

1. Transaksi EVM berukuran besar dipecah menjadi potongan-potongan
2. Potongan-potongan disusun secara berurutan ke dalam akun holder (maks. 80 KB)
3. Setelah semua potongan ditulis, transaksi penuh dirangkai dan dieksekusi
4. Ini dikelola secara transparan oleh Rome SDK

## Gas dan Harga

Setiap aplikasi (chain ID) di Rome memiliki token gas sendiri — token SPL apa pun. Penentuan harga gas menggunakan pool Meteora DAMM V1 untuk mengonversi antara token gas dan SOL untuk biaya transaksi Solana yang mendasarinya.

## Mode Deployment

| Mode                  | Aliran Data                                                           | Kasus Penggunaan                                |
| --------------------- | --------------------------------------------------------------------- | ----------------------------------------------- |
| **Mode OP-Geth**      | Pengguna → OP-Geth → Rhea → Proxy → Solana; Hercules mengindeks balik | Kompatibilitas penuh dengan RPC Ethereum        |
| **Mode single-state** | Pengguna → Proxy → Solana secara langsung                             | Penerapan lebih sederhana, latensi lebih rendah |

## Berikutnya

* [Panduan Cepat](/id/memulai/quickstart.md) — deploy kontrak pertama Anda
* [Model Eksekusi](/id/konsep-inti/execution-model.md) — pendalaman tentang eksekusi atomik vs iteratif
* [Anggaran Komputasi](/id/konsep-inti/compute-budget.md) — memahami biaya CU dan optimisasi


---

# 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/memulai/architecture.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.