Interoperabilitas Token

Rome EVM menjembatani token ERC-20 dan token SPL melalui model satu status. Halaman ini menjelaskan cara kerja token di EVM dan Solana.

Model Satu Status

Tidak seperti bridge tradisional, Rome tidak mengunci token di satu chain dan mencetak salinan wrapped di chain lain. Sebaliknya, token ERC-20 di Rome EVM adalah pembungkus transparan di atas akun token SPL yang mendasarinya di Solana.

┌──────────────────────────────────┐
│ Rome EVM                         │
│                                  │
│   ERC-20 "rUSDC"                 │
│   ┌────────────────────────┐     │
│   │ balanceOf(user)        │─────┼──► membaca langsung dari SPL ATA
│   │ transfer(to, amount)   │─────┼──► mengeksekusi transfer SPL via precompile
│   │ totalSupply()          │─────┼──► membaca suplai mint SPL
│   └────────────────────────┘     │
│                                  │
└──────────────────────────────────┘
                 │
                 │ data dasar yang sama
                 ↓
┌──────────────────────────────────┐
│ Solana                           │
│                                  │
│   Akun Token SPL (ATA)           │
│   Pemilik: PDA milik pengguna    │
│   Mint: USDC (native Circle)     │
│   Jumlah: 1000000 (= 1 USDC)    │
│                                  │
└──────────────────────────────────┘

Artinya ini berarti:

• Tidak ada penundaan 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

ERC20SPL: Kontrak Pembungkus

SPL_ERC20 adalah kontrak pembungkus standar yang menyediakan antarmuka ERC-20 penuh di atas mint token SPL:

import {SPL_ERC20} from "@rome-protocol/solidity-sdk/contracts/token/ERC20SPL.sol";

// Pembungkus membaca saldo dari ATA SPL milik pengguna
uint256 balance = wrapper.balanceOf(userAddress);

// Transfer dieksekusi melalui precompile SPL Token
wrapper.transfer(recipient, amount);

Cara kerjanya di balik layar:

• balanceOf() → menurunkan ATA pengguna (Associated Token Account) → membaca saldo dari Solana

• transfer() → memanggil precompile SPL Token (0xff...05) → memindahkan token di Solana

• approve() / allowance() → menggunakan penyimpanan EVM (pola ERC-20 standar) karena SPL tidak secara native mendukung allowance bergaya EVM

• totalSupply() → membaca dari akun mint SPL

ERC20SPLFactory

Kontrak factory menerapkan pembungkus untuk token SPL apa pun:

import {ERC20SPLFactory} from "@rome-protocol/solidity-sdk/contracts/token/ERC20SPLFactory.sol";

ERC20SPLFactory factory = ERC20SPLFactory(0xfd21da046c282e1d36cc45e46d9599cff5742f2b);

// Menerapkan pembungkus untuk mint SPL (memuat nama/simbol dari metadata Metaplex)
address wrapper = factory.add_spl_token_with_metadata(splMintPubkey);

// Atau tentukan nama/simbol secara manual
address wrapper = factory.add_spl_token_no_metadata(splMintPubkey, "USD Coin", "USDC");

Alamat factory (devnet): 0xfd21da046c282e1d36cc45e46d9599cff5742f2b

Register Token

The TokenRegistry menyediakan pendaftaran token SPL yang disetujui dengan metadata lintas-chain yang dikontrol admin:

import {TokenRegistry, TokenOrigin} from "@rome-protocol/solidity-sdk/contracts/token/TokenRegistry.sol";

// Mendaftarkan token SPL native
registry.registerToken(
    splMint,
    TokenOrigin.NativeSPL,
    bytes32(0),   // tidak ada alamat eksternal
    0             // tidak ada chain eksternal
);

// Mendaftarkan token wrapped Wormhole dengan metadata lintas-chain
registry.registerToken(
    wormholeMint,
    TokenOrigin.WormholeWrapped,
    externalTokenAddress,  // token asli di chain sumber
    2                       // ID chain Wormhole untuk Ethereum
);

Registry memastikan setiap aset dipetakan ke satu mint SPL kanonik — mencegah beberapa representasi USDC memecah likuiditas.

Alur Deposit / Withdraw

Mendepositkan SPL → EVM

1. Pengguna mentransfer token SPL ke vault bridge

2. Bridge membuat ATA pengguna di Rome EVM (jika belum ada)

3. Pembungkus ERC-20 menjadi aktif — pengguna melihat saldo di MetaMask

Menarik EVM → SPL

1. Pengguna memanggil precompile Withdraw (0x42...16) di Rome EVM

2. Precompile mengeksekusi transfer SPL dari PDA pengguna kembali ke dompet Solana mereka

3. Token SPL muncul di dompet Solana milik pengguna

Derivasi PDA

Setiap alamat EVM dipetakan ke PDA Solana yang memiliki akun token mereka:

import {RomeEVMAccount} from "@rome-protocol/solidity-sdk/contracts/core/RomeEVMAccount.sol";

// Dapatkan PDA Solana untuk alamat EVM
bytes32 userPda = RomeEVMAccount.pda(msg.sender);

// Dapatkan ATA pengguna untuk mint tertentu
bytes32 ata = AssociatedSplToken.create_associated_token_account(userPda, mintPubkey);

Pola Utama

Membaca Saldo SPL dari Solidity

// Baca state akun token SPL mentah
ISplToken.Account memory account = SplToken.account_state(tokenAccountPubkey);
uint64 balance = account.amount;
uint8 decimals = SplToken.decimals_eq(mintPubkey, 9); // verifikasi desimal

Mentransfer Token via Precompile SPL

// Transfer SPL langsung (level lebih rendah daripada pembungkus ERC-20)
SplToken.transfer(recipientAta, mintPubkey, amount);

Token Gas

Setiap chain Rome EVM memiliki token gas sendiri — token SPL apa pun yang dipilih saat pendaftaran chain:

• RSOL — token gas default (SOL wrapped)

• Token kustom — token SPL apa pun, diberi harga melalui pool Meteora DAMM V1

Token gas adalah representasi ERC-20 dari token SPL. Transfer Hook TIDAK dijalankan pada pembayaran gas internal EVM.

Batasan

• Jumlah token SPL adalah uint64 — nilai maksimum 18,446,744,073,709,551,615

• Desimal default untuk mint SPL baru: 9

• Simbol pembungkus ERC-20 harus unik secara global per factory

• Allowance menggunakan penyimpanan EVM (bukan delegate Solana)

Berikutnya

• Transfer Hooks — logika EVM di transfer hook Token-2022

• Panduan Pembungkus Token — terapkan pembungkus ERC-20 milik Anda sendiri

• Alamat Contract — alamat factory yang telah diterapkan