> 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/konsep-inti/execution-model.md).

# Model Eksekusi

Cara Rome EVM memproses transaksi Ethereum di Solana — emulasi proxy, mode atomik (VmAt) vs. iteratif (VmIt), dan siklus hidup transaksi lengkap.

Rome EVM mengeksekusi bytecode Solidity di dalam program on-chain Solana. Halaman ini menjelaskan bagaimana transaksi EVM diproses.

## Siklus Hidup Transaksi

```
1. Pengguna menandatangani transaksi EVM (MetaMask / ethers.js)
                    ↓
2. Rome Proxy menerima melalui eth_sendRawTransaction
                    ↓
3. Proxy meniru transaksi di luar rantai (emulator SVM Mollusk)
   → Memperkirakan gas, memeriksa atomisitas, mengidentifikasi akun yang diperlukan
                    ↓
4. Proxy membungkus tx EVM sebagai instruksi Solana
   → Jika tx muat dalam satu tx Solana → Atomik (VmAt)
   → Jika tx melebihi anggaran CU → Iteratif (VmIt)
                    ↓
5. Validator Solana mengeksekusi instruksi
   → Program Rome EVM menafsirkan bytecode EVM
   → Panggilan CPI ke program Solana lain (jika ada)
                    ↓
6. Perubahan status dikomit ke akun Solana
                    ↓
7. Hercules mengindeks event → menghasilkan blok EVM
```

## Eksekusi Atomik (VmAt)

Mode default. Seluruh transaksi EVM dieksekusi dalam satu transaksi Solana.

**Mesin status:** `Lock → Init → Execute → Commit → GasTransfer → Exit`

**Properti:**

* Eksekusi semua-atau-tidak sama sekali — jika ada satu langkah gagal, seluruh transaksi di-rollback
* \~1,4 juta compute unit tersedia per transaksi Solana
* Cocok untuk transfer, panggilan kontrak sederhana, swap, sebagian besar operasi DeFi
* Finalitas di bawah satu detik (waktu blok Solana)

**Kapan digunakan:** Dipilih secara otomatis ketika emulator menentukan transaksi muat dalam anggaran compute satu transaksi Solana.

## Eksekusi Iteratif (VmIt)

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

**Cara kerjanya:**

1. Setiap langkah (satu transaksi Solana) mengeksekusi **sebanyak opcode EVM yang muat dalam anggaran compute-nya** — ukuran langkah adaptif, bukan jumlah tetap
2. Setelah setiap langkah, status VM diserialkan (format Borsh) ke dalam sebuah `StateHolder` akun
3. Langkah berikutnya men-deserialisasi status dan melanjutkan eksekusi
4. Akun yang terlibat di-lock dengan TTL selama **3-4 detik** selama eksekusi multi-langkah; sebuah sesi dibatasi hingga **160 langkah**; setelah itu, langkah berikutnya melepaskan kunci sesi dan mengakhirinya tanpa mengomit apa pun

**Mesin status:** `FromStateHolder → Lock → Init → Execute → Serialize → NextIteration → ... → Completed`

**Penguncian akun:**

* Satu **kunci eksklusif** per akun terkelola (akun saldo dan penyimpanan) — hanya satu sesi iteratif yang dapat memegang akun pada satu waktu; transaksi atomik yang menulis ke akun yang terkunci ditolak dengan `AccountLocked` hingga kunci berakhir, dan klien mengirim ulang
* **TTL:** 3 detik, diperbarui setiap langkah (4 detik ketika sesi menyentuh lebih dari 28 akun)
* **CPI jalur legacy ditolak** di dalam transaksi iteratif (`CpiProhibitedInIterativeTx`); efek jalur cache dipentaskan dan dikomit di akhir

**Kapan digunakan:** deployment kontrak besar, call stack yang dalam, operasi apa pun yang melebihi \~1,4 juta CU. Pemeriksaan pairing BN254 sendiri tidak memerlukannya; lihat [Budget Komputasi](https://docs.rome.builders/id/konsep-inti/compute-budget.md).

## Emulasi

Sebelum mengirim transaksi ke Solana, Proxy menirunya di luar rantai menggunakan **emulator SVM Mollusk**. Ini:

1. Memperkirakan konsumsi gas
2. Menentukan apakah mode atomik atau iteratif diperlukan
3. Mengidentifikasi semua akun Solana yang akan disentuh transaksi
4. Memvalidasi bahwa transaksi tidak akan gagal di on-chain

Emulator mengeksekusi logika EVM yang sama seperti program on-chain — `entrypoint!` makro memastikan tabel dispatch yang identik di basis kode program dan emulator.

**Mollusk SVM** juga dapat mengeksekusi program BPF Solana arbitrer selama emulasi, yang berarti `eth_call` dan `eth_estimateGas` dapat menangani panggilan CPI ke SPL Token, Jupiter, Kamino, dll. dengan benar

## Pemetaan Akun

Setiap alamat Ethereum dipetakan ke PDA Solana:

```
Alamat Ethereum (H160, 20 byte)
    ↓
PDA = findProgramAddress(
    [chain_id, "ACCOUN_SEED", H160, bump],
    ROME_EVM_PROGRAM_ID
)
    ↓
Akun Solana (Pubkey, 32 byte)
```

**Jenis akun yang disimpan on-chain:**

| Jenis       | Seed                                         | Tujuan                                           |
| ----------- | -------------------------------------------- | ------------------------------------------------ |
| Saldo       | `[chain, "ACCOUN_SEED", H160, bump]`         | Nonce, saldo, kode kontrak                       |
| Penyimpanan | `[chain, "STORAGE", H160, slot_index, bump]` | Penyimpanan kontrak (256 slot per akun)          |
| TxHolder    | `[signer, "TX_HOLDER_SEED", index, bump]`    | Data transaksi yang dipentaskan (maksimal 80 KB) |
| StateHolder | `[signer, "STATE_HOLDER_SEED", index, bump]` | Status VM yang diserialkan antar iterasi         |

## Akun Holder

Rome mengirim transaksi Solana **v1**, yang dibatasi hingga 4 KB (4.096 byte) dan 64 alamat. Transaksi EVM — terutama deployment kontrak — bisa jauh lebih besar.

**Mekanisme pemisahan:**

1. SDK memecah transaksi yang dienkode RLP menjadi potongan-potongan
2. Setiap potongan ditulis ke `TxHolder` akun melalui `TransmitTx` instruksi
3. Setelah semua potongan dipentaskan, sebuah `DoTxHolder` instruksi merangkai dan mengeksekusi transaksi penuh
4. Ukuran maksimum holder: **80 KB** per TxHolder

Ini sepenuhnya transparan bagi developer — SDK Rome menangani pemisahan dan penyusunan ulang secara otomatis.

## Jenis Transaksi yang Didukung

| Jenis                       | EIP       | Deskripsi                                                                                                                                                                                                                                                      |
| --------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Legacy                      | —         | Transaksi Ethereum tradisional                                                                                                                                                                                                                                 |
| Daftar Akses                | EIP-2930  | Pola akses state yang dioptimalkan                                                                                                                                                                                                                             |
| Biaya Dinamis               | EIP-1559  | Biaya dasar + biaya prioritas                                                                                                                                                                                                                                  |
| EIP-1559 tak ditandatangani | —         | Sebuah `0x02`payload bertipe tanpa tanda tangan secp256k1, diotorisasi sebagai gantinya oleh tanda tangan Ed25519 dari wallet Solana (jalur Solana; lihat [Panggil EVM dari Solana](https://docs.rome.builders/id/panduan-pengembang/call-evm-from-solana.md)) |
| Setoran                     | Tipe 0x7E | Transaksi deposit, misalnya penyelesaian inbound bridge                                                                                                                                                                                                        |

## Status Terjurnal

Rome EVM menggunakan model status terjurnal untuk mengelola perubahan status selama eksekusi:

* Semua perubahan (nonce, saldo, penyimpanan, kode) dilacak dalam sebuah `Jurnal`
* Operasi CALL/CREATE bersarang menambahkan frame snapshot
* Saat revert: entri jurnal di-rollback ke snapshot
* Saat berhasil: perubahan dikomit ke akun Solana
* Instruksi CPI non-EVM dieksekusi segera (jaminan atomisitas Solana memastikan kebenaran)

## Langkah Berikutnya

* [Budget Komputasi](https://docs.rome.builders/id/konsep-inti/compute-budget.md) — biaya CU dan strategi optimisasi
* [Batasan](https://docs.rome.builders/id/konsep-inti/constraints.md) — batas dan pembatasan penting


---

# 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/konsep-inti/execution-model.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.
