> 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/token-interop.md).
# Interoperabilitas Token
Bagaimana token ERC-20 dan SPL adalah akun dasar yang sama di Rome.
Rome merepresentasikan token ERC-20 dan token SPL dasarnya sebagai satu akun bersama. Halaman ini menjelaskan cara kerja token di seluruh EVM dan Solana.
## Model state bersama
Rome tidak mengunci token di satu sisi dan mencetak salinan terbungkus di sisi lain. Token ERC-20 di Rome adalah sebuah **pembungkus transparan** di atas akun token SPL di Solana — saldo ERC-20 *adalah* saldo SPL.
* Tidak ada jeda bridging — saldo ERC-20 adalah saldo SPL
* Tidak ada fragmentasi likuiditas — DeFi di kedua sisi melihat token yang sama
* Tidak ada risiko bridge — tidak ada escrow terpisah yang bisa dieksploitasi
> Jalur impor di bawah menggunakan `@rome-protocol/rome-solidity`. Paket ini tidak ada di npm; instal dari [`rome-solidity`](https://github.com/rome-protocol/rome-solidity) repo publik dengan `npm install github:rome-protocol/rome-solidity`, atau `forge install rome-protocol/rome-solidity` dengan remapping; kontrak wrapper dan factory juga memerlukan OpenZeppelin di bawah Foundry (lihat [Mendeploy Kontrak Solidity](/id/panduan-pengembang/deploy-solidity.md#using-the-rome-solidity-sdk)). Antarmuka precompile berada di [`contracts/interface.sol`](https://github.com/rome-protocol/rome-solidity/blob/master/contracts/interface.sol).
## Kontrak wrapper
`SPL_ERC20` (dan varian cached-track-nya `SPL_ERC20_cached`, yang saat ini diterapkan oleh factory) menyediakan antarmuka ERC-20 penuh di atas sebuah mint SPL:
* `balanceOf()` — membaca saldo ATA pengguna dari Solana
* `transfer()` — memindahkan token di Solana
* `approve()` / `allowance()` — menggunakan penyimpanan EVM (SPL tidak memiliki allowance bergaya EVM)
* `totalSupply()` — membaca suplai mint SPL
## Factory
`ERC20SPLFactory` menerapkan wrapper untuk mint SPL apa pun:
```solidity
import {ERC20SPLFactory} from "@rome-protocol/rome-solidity/contracts/erc20spl/erc20spl_factory.sol";
// Terapkan wrapper, memuat nama/simbol dari metadata Metaplex
address wrapper = factory.add_spl_token_with_metadata(splMint);
// Atau tentukan nama/simbol secara manual
address wrapper = factory.add_spl_token_no_metadata(splMint, "USD Coin", "USDC");
```
Alamat factory aktif, dari `aktif` entri registry (v0.2.0): Hadrian `0x37c13e4ff21fb914eb24014dcbd0f8dbeaa31078`, Martius `0x405ded76ebae104ebe8345a649c6cbbf37efff00`. Factory sebelumnya masih berada di on-chain tetapi ditandai sebagai `usang` atau `pensiun` di [registry](https://github.com/rome-protocol/rome-registry/tree/main/chains); jangan gunakan. Registry adalah sumber kebenaran, jadi baca alamat aktif darinya (lihat [Membaca daftar kontrak](/id/referensi/contract-addresses.md#reading-the-contracts-list)) alih-alih menyalinnya ke kode Anda.
## Mint kanonik
Tidak ada kontrak registry token on-chain. Wrapper kanonik dan token gas/bridge dikurasi di off-chain [`rome-protocol/registry`](https://github.com/rome-protocol/rome-registry); wrapper permissionless yang dibuat melalui `add_spl_token_no_metadata` ditemukan dari on-chain `TokenCreated` event. Ini menjaga setiap aset dipetakan ke satu mint SPL kanonik tanpa memfragmentasi likuiditas.
## Operasi SPL dari Solidity
Untuk primitive SPL yang ditandatangani user-PDA, gunakan **HelperProgram** precompile (`0xFF…09`) — pembuatan ATA, transfer SPL, dan konversi gas↔lamports:
```solidity
import {IHelperProgram} from "@rome-protocol/rome-solidity/contracts/interface.sol";
IHelperProgram helper = IHelperProgram(0xFF00000000000000000000000000000000000009);
helper.create_ata(user, mint); // buat ATA pengguna untuk sebuah mint
helper.transfer_spl(to, tokens, mint); // transfer SPL dari PDA milik pemanggil
```
`transfer_spl` memiliki beberapa overload (termasuk varian delegate untuk `transferFrom` aliran); lihat `interface.sol` untuk tanda tangan yang tepat. Pada cached track, operasi yang setara berada di `ISplCached` (`0xFF…05`) dan `IAssociatedSplCached` (`0xFF…06`). Sebuah kontrak menggunakan satu track secara konsisten.
## Deposit dan withdraw
* **Ke EVM** — sisi SPL mengkredit ATA milik PDA pengguna; wrapper ERC-20 langsung mencerminkan saldo. Transfer masuk lintas-chain diselesaikan tanpa perlu kepercayaan melalui otorisasi yang ditandatangani pengguna pada bridge.
* **Keluar ke Solana** — panggil `Penarikan` precompile (`0x42…16`): `withdraw_to_pda` / `withdraw_to_ata` memindahkan token dari PDA pengguna kembali ke Solana. Jalur wrap-gas-ke-SPL adalah `withdraw_to_ata`.
## Token gas
Setiap chain memiliki token gasnya sendiri — token SPL apa pun, diberi harga melalui pool Meteora DAMM (v1 atau v2, dapat dikonfigurasi). Chain publik (Martius, Hadrian) menggunakan USDC. Tidak ada token gas default universal.
## Batasan
* Jumlah token SPL adalah `uint64` (maks. 18.446.744.073.709.551.615)
* Allowance menggunakan penyimpanan EVM, bukan delegate Solana
* Simbol wrapper ERC-20 harus unik per factory
## Langkah Berikutnya
* [Alamat Kontrak](/id/referensi/contract-addresses.md) — precompile dan alamat per-chain
* [Memanggil Solana dari EVM](/id/panduan-pengembang/call-solana-from-evm.md) — operasi CPI dan SPL dari Solidity
---
# 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/token-interop.md?ask=&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.
