> 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/rome-academy/04-how-rome-runs-your-code.md).

# 4. Bagaimana Rome menjalankan kode Anda

Bagaimana sebuah transaksi Rome menjadi transaksi Solana, mengapa sebagian besar panggilan berjalan secara atomik, dan apa yang berubah ketika sebuah panggilan terlalu besar.

Solidity Anda berjalan tanpa perubahan. Yang berubah adalah di mana ia berjalan: di dalam program Solana, di bawah batasan Solana. Pelajaran ini memberi Anda gambaran yang Anda perlukan untuk memprediksi berapa biaya sebuah panggilan dan kapan ia akan gagal.

## Yang akan Anda pelajari

* Jalur yang ditempuh sebuah transaksi dari dompet Anda ke validator Solana dan kembali menjadi tanda terima EVM.
* Perbedaan antara eksekusi atomik dan iteratif, dan mengapa Anda menginginkan yang atomik.
* Batasan Solana mana yang berlaku pada Solidity Anda: komputasi, ukuran, jumlah akun, kunci.
* Cara mengukur biaya sebenarnya dari sebuah panggilan.

## Sebelum Anda mulai

* Selesai [3. Kontrak pertama Anda di Hadrian](https://docs.rome.builders/id/rome-academy/03-first-contract-on-hadrian.md). Anda memerlukan sebuah kontrak yang sudah di-deploy dan satu transaksi yang Anda kirim kepadanya.
* Simpan hash transaksi itu. Anda akan membukanya di explorer pada akhir pelajaran ini.

## Jalur satu transaksi

Anda menandatangani transaksi EVM biasa dan mengirimkannya ke proxy Rome dengan `eth_sendRawTransaction`. Proxy belum meneruskannya. Pertama, ia menjalankan panggilan itu secara off-chain dalam emulator yang mengeksekusi logika EVM yang sama seperti program on-chain. Emulasi memberi tahu tiga hal: berapa banyak gas yang dibutuhkan panggilan, akun Solana mana yang disentuh panggilan, dan apakah panggilan muat dalam satu transaksi Solana.

Proxy kemudian membungkus panggilan Anda sebagai instruksi Solana dan mengirimkannya. Program Rome EVM, yang merupakan program Solana biasa, menafsirkan bytecode Anda. Perubahan state masuk ke akun-akun Solana. Sebuah indexer membaca hasilnya dan menghasilkan blok serta tanda terima EVM yang diharapkan oleh alat Anda.

Setiap alamat EVM dipetakan ke akun Solana yang dimiliki oleh program Rome. Saldo, nonce, kode, dan storage kontrak Anda semuanya adalah akun Solana. Itulah sebabnya proxy harus mengetahui daftar akun sebelum mengirimkannya: Solana mensyaratkan setiap akun disebutkan di awal.

Baca siklus hidup lengkap di [Model eksekusi](https://docs.rome.builders/id/konsep-inti/execution-model.md).

## Utamakan atomik

Sebagian besar panggilan berjalan dalam satu transaksi Solana. Rome menyebut ini eksekusi atomik (VmAt). Sifatnya all-or-nothing: jika satu langkah gagal, seluruh panggilan dibatalkan. Transfer, swap, dan sebagian besar panggilan DeFi cocok. Sebagian tidak: borrow Aave di Hadrian membutuhkan lebih dari satu transaksi Solana.

Satu panggilan atomik memiliki anggaran sekitar 1,4 juta unit komputasi. Batasan ini membentuk setiap panggilan:

| Batas          | Artinya bagi Anda                                                                                                                                    |
| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| Komputasi      | Sekitar 1,4 juta CU dibagi antara pekerjaan EVM dan setiap program yang Anda panggil                                                                 |
| Akun           | 64 alamat, termasuk akun milik Rome dan semua yang disentuh oleh CPI Anda                                                                            |
| Ukuran         | 4 KB per transaksi Solana; payload EVM yang lebih besar, seperti deployment besar, di-staging melalui akun penampung dan SDK menanganinya untuk Anda |
| Ukuran kontrak | 24 KB, seperti di Ethereum                                                                                                                           |

Daftar lengkap, beserta nilainya, ada di [Batasan](https://docs.rome.builders/id/konsep-inti/constraints.md).

## Iteratif ketika panggilan terlalu besar

Jika emulator menemukan bahwa suatu panggilan tidak muat, Rome menjalankannya secara iteratif (VmIt). Panggilan dipotong menjadi beberapa tahap. Setiap tahap adalah transaksi Solana tersendiri dan menjalankan sebanyak yang diizinkan oleh anggaran komputasinya. Di antara tahap, state VM disimpan dalam akun penampung dan tahap berikutnya mengambilnya.

Eksekusi iteratif berfungsi, tetapi ada biayanya:

* Sebuah sesi berakhir setelah 160 tahap. Setelah itu, sesi melepaskan kuncinya dan tidak meng-commit apa pun.
* Sesi mengunci akun saldo dan storage selama beberapa detik, diperbarui pada setiap tahap. Penulisan atomik ke akun yang terkunci ditolak dengan `AccountLocked`, dan klien mengirim ulang.
* Panggilan yang membuat CPI Solana pada jalur legacy (panggilan `CpiProgram` dan `HelperProgram` di pelajaran 5) sama sekali tidak dapat berjalan secara iteratif. Panggilan itu harus muat secara atomik.
* Pada jalur Solana, dompet yang menandatangani tahapnya sendiri meminta pengguna sekali per tahap.

Aturan desainnya menjadi: bentuk setiap aksi pengguna agar muat dalam satu transaksi atomik. Jika alurnya lebih besar, pecah menjadi dua aksi pengguna daripada mengandalkan mode iteratif. Pelajaran 5 akan kembali ke ini saat Anda memanggil program Solana.

## Yang Anda bayar

Rome menghitung biaya sebuah panggilan dalam lamport Solana: biaya tanda tangan, tol tetap, dan sewa untuk akun apa pun yang dibuat oleh panggilan itu. Satu unit gas mewakili satu lamport biaya. Harga gas mengonversinya ke token gas jaringan, yaitu USDC di Hadrian dan Rubicon.

Sewa adalah bagian yang mengejutkan banyak orang. Transfer pertama ke alamat yang belum pernah digunakan membuat akun, jadi biayanya jauh lebih besar daripada transfer ulang. Harapkan gas tinggi pada sentuhan pertama dan gas biasa setelahnya. Contoh angkanya ada di [Cara Solana dan EVM bertemu di Rome](https://docs.rome.builders/id/konsep-inti/how-solana-and-evm-meet.md#gas-and-rent).

## Ukur, jangan menebak

EVM `gasUsed` bukan pengganti yang akurat untuk komputasi Solana. Di Rome satu unit gas adalah satu lamport biaya, jadi `eth_estimateGas` menentukan batas gas Anda tetapi tidak memberi tahu Anda apa pun tentang unit komputasi. Baca komputasi dari sisi Solana. Via menautkan transaksi Solana dari baris "Settled in"-nya, dan explorer Solana menunjukkan unit komputasinya. Dalam kode, ambil tanda tangan Solana di balik hash EVM dengan `rome_solanaTxForEvmTx`, ambil masing-masing dengan `getTransaction` dan `maxSupportedTransactionVersion: 1`, dan baca `computeUnitsConsumed`. Panggilan iteratif memiliki satu transaksi per tahap. [Anggaran komputasi](https://docs.rome.builders/id/konsep-inti/compute-budget.md) memiliki biaya tipikal per operasi dan kebiasaan hemat yang menguranginya: konstanta untuk ID program, derivasi PDA yang di-cache, lebih sedikit akun.

Dua perilaku berbeda dari Ethereum dan layak diketahui sekarang:

* Rome tidak memiliki meter gas per opcode. Gas yang Anda berikan ke sebuah `CALL` tidak ditegakkan dan tidak ada stipend 2300 gas. Lindungi dari reentrancy secara eksplisit.
* `block.number` adalah slot Solana dan `block.timestamp` adalah clock Solana.

## Periksa pemahaman Anda

Buka transaksi Anda dari pelajaran 3 di explorer Hadrian. Temukan tautan jaringan di [Hadrian](https://docs.rome.builders/id/jaringan/hadrian.md) dan catatan explorer di [Via explorer](https://docs.rome.builders/id/aplikasi-di-rome/via.md).

Perhatikan dua hal:

1. Transaksi Solana yang menyelesaikan panggilan Anda, dari baris "Settled in".
2. Unit komputasi yang dikonsumsinya, di explorer Solana.

Bandingkan angka itu dengan anggaran 1,4 juta. Panggilan sederhana hanya menggunakan sebagian kecil darinya.

Lalu jawab:

<details>

<summary>1. Mengapa proxy meniru sebuah panggilan sebelum mengirimkannya?</summary>

Solana memerlukan setiap akun disebutkan di awal, dan proxy harus tahu apakah panggilan itu muat dalam satu transaksi. Emulasi menemukan akun yang disentuh, memperkirakan gas, dan menentukan atomik atau iteratif.

</details>

<details>

<summary>2. Sebuah panggilan membuat CPI jalur legacy (panggilan `CpiProgram` dan `HelperProgram` di pelajaran 5) dan membutuhkan lebih dari 1,4 juta CU. Apa yang terjadi?</summary>

Panggilan itu tidak dapat dijalankan. CPI jalur legacy ditolak dalam transaksi iteratif, jadi panggilan harus muat dalam satu transaksi atomik. Pecah pekerjaannya menjadi aksi pengguna yang lebih kecil.

</details>

<details>

<summary>3. Mengapa transfer pertama ke alamat baru mahal?</summary>

Rome membuat akun Solana untuk itu, dan sewa untuk akun-akun tersebut dibebankan kepada pengirim sebagai gas.

</details>

## Berikutnya

[5. Memanggil Solana dari Solidity](https://docs.rome.builders/id/rome-academy/05-call-solana-from-solidity.md)


---

# 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/rome-academy/04-how-rome-runs-your-code.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.
