Rome SDK

Antarmuka Solidity bertipe untuk memanggil program Solana dari kontrak EVM, plus SDK Rust di balik layanan off-chain Rome.

SDK Rome menyediakan antarmuka Solidity bertipe untuk berinteraksi dengan program Solana dari smart contract EVM. Ini adalah toolkit pengembang untuk membangun aplikasi lintas runtime di Rome.

SDK

Rome memiliki SDK untuk tiga audiens — pembangun aplikasi (TypeScript), pengembang kontrak (Solidity), dan operator infrastruktur (Rust).

SDK TypeScript (@rome-protocol/sdk)

Untuk pengembang dapp dan frontend — SDK yang paling sering dipakai oleh pembuat aplikasi sebagai titik awal. @rome-protocol/sdk membungkus jalur penulisan Rome agar aplikasi web mengirim transaksi Rome dengan benar: submitRomeTx (jalur penulisan yang benar plus penanganan gas/biaya), derivasi PDA / ATA, CPI invoke / invoke_signed encoder, binding precompile, dan sebuah /bridge subpath. Instal dari repo terlebih dahulu (npm publish menunggu):

npm install github:rome-protocol/rome-sdk-ts#v0.2.1

import { submitRomeTx } from '@rome-protocol/sdk';
// Kirim penulisan EVM Rome apa pun melalui jalur penulisan yang benar (menangani encoding gas/biaya).

Aplikasi referensi publik — rome-dex dan cardo — menggunakan SDK ini.

Dua jalur, satu SDK. submitRomeTx adalah jalur EVM (MetaMask). Untuk jalur Solana — dompet Phantom/Solana yang menjalankan aplikasi EVM Anda — submitRomeTxSolanaLane menirunya: pengguna menandatangani transaksi Solana dan Rome menjalankannya sebagai transaksi EVM dari identitas turunan mereka, tanpa kunci EVM. Nilai berpindah masuk dan keluar melalui buildFundLeg / buildSweepLeg sebagai wrapper ERC-20 (mis. wUSDC), bukan native msg.value — pengirim sintetis tidak menyimpan apa pun saat diam — dan sintetis pertama kali disediakan otomatis pada penggunaan pertama. Lihat Bangun aplikasi dua jalur dan Panggil EVM dari Solana.

SDK Solidity (@rome-protocol/rome-solidity)

Untuk pengembang Solidity. Menyediakan antarmuka precompile, wrapper ERC-20/SPL, derivasi PDA, dan utilitas CPI. Publish npm masih menunggu; saat ini Anda menggunakan ini dari rome-solidity repo publik (dependensi git atau file yang disalin).

import {ISystemProgram, ICrossProgramInvocation, IHelperProgram, IWithdraw}
    from "@rome-protocol/rome-solidity/contracts/interface.sol";
import {SPL_ERC20} from "@rome-protocol/rome-solidity/contracts/erc20spl/erc20spl.sol";
import {RomeEVMAccount} from "@rome-protocol/rome-solidity/contracts/rome_evm_account.sol";

SDK Rust (rome-sdk)

Untuk operator infrastruktur. Workspace Rust yang menangani penyusunan transaksi, interaksi Solana, penentuan harga gas, dan pengindeksan blok. Digunakan oleh Proxy dan Hercules.

SDK Solidity: Apa Saja yang Termasuk

Antarmuka Precompile

Hubungkan sebuah antarmuka ke alamat precompile-nya:

ISystemProgram          constant System   = ISystemProgram(0xFF00000000000000000000000000000000000007);
ICrossProgramInvocation constant Cpi      = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);
IHelperProgram          constant Helper   = IHelperProgram(0xFF00000000000000000000000000000000000009);
IWithdraw               constant Withdraw = IWithdraw(0x4200000000000000000000000000000000000016);
// Jalur cache: ISplCached 0xff…05, IAssociatedSplCached 0xff…06, ISystemCached 0xff…04, IWithdrawCached 0xff…0b

Operasi Token SPL

Gunakan IHelperProgram (0xff…09) untuk primitif SPL yang ditandatangani user-PDA:

// Buat ATA pemanggil untuk sebuah mint
Helper.create_ata(user, mint);

// Transfer SPL dari PDA pemanggil
Helper.transfer_spl(to, tokens, mint);

Pada jalur cache, operasi yang setara ada di ISplCached (0xff…05) dan IAssociatedSplCached (0xff…06). Lihat interface.sol untuk semua overload; sebuah kontrak menggunakan satu jalur secara konsisten.

Derivasi PDA

// Derivasikan PDA Solana milik pengguna
bytes32 userPda = RomeEVMAccount.pda(msg.sender);

// Derivasikan PDA dengan salt (untuk membuat beberapa PDA per pengguna)
bytes32 pda = RomeEVMAccount.pda_with_salt(msg.sender, salt);

// Cari PDA arbitrer
(bytes32 pda, uint8 bump) = SystemProgram.find_program_address(programId, seeds);

Cross-Program Invocation

// Panggil program Solana apa pun
ICrossProgramInvocation.AccountMeta[] memory accounts = new ICrossProgramInvocation.AccountMeta[](2);
accounts[0] = ICrossProgramInvocation.AccountMeta(signerPda, true, true);
accounts[1] = ICrossProgramInvocation.AccountMeta(targetAccount, false, true);

CpiProgram.invoke(programId, accounts, instructionData);

// Panggil dengan penandatanganan PDA
CpiProgram.invoke_signed(programId, accounts, data, seeds);

// Baca data akun
(uint64 lamports, bytes32 owner, bool isSigner, bool isWritable, bool executable, bytes memory data)
    = CpiProgram.account_info(pubkey);

ERC-20 di atas Token SPL

// Deploy wrapper untuk setiap mint SPL
ERC20SPLFactory factory = ERC20SPLFactory(FACTORY_ADDRESS);
address wrapper = factory.add_spl_token_with_metadata(splMint);

// Gunakan wrapper sebagai ERC-20 standar
SPL_ERC20 token = SPL_ERC20(wrapper);
token.transfer(recipient, amount);
uint256 balance = token.balanceOf(user);

Deserialisasi Borsh

import {Convert} from "@rome-protocol/rome-solidity/contracts/convert.sol";

// Parse data akun Solana (format Borsh little-endian)
(uint64 value, uint256 newOffset) = Convert.read_u64le(data, offset);
(bytes32 pubkey, uint256 newOffset2) = Convert.read_bytes32(data, offset);

Metadata Metaplex

import {MplTokenMetadataLib} from "@rome-protocol/rome-solidity/contracts/mpl_token_metadata/lib.sol";

// Muat metadata token dari Metaplex
MplTokenMetadataLib.Metadata memory meta = MplTokenMetadataLib.load_metadata(
    mintPubkey, mplProgramId, cpiAddress
);
string memory name = meta.name;
string memory symbol = meta.symbol;

Arsitektur SDK Rust

SDK Rust adalah workspace Cargo. Crate intinya:

Crate	Tujuan
rome-sdk	API Inti: Rome struct, config, tipe transaksi (RheaTx, RemusTx, RomulusTx)
rome-evm-client	klien rollup EVM, TxBuilder, ResourceFactory, integrasi emulator
rome-solana	tower Solana, klien RPC, batching dan pelacakan transaksi
rome-utils	utilitas RLP, hex, JSON-RPC, autentikasi
rome-obs	observabilitas OpenTelemetry (trace, metrik, log)
rome-meteora	adapter pool Meteora DEX AMM untuk penetapan harga gas
rome-jito-bundler	pembuat bundle Jito untuk pengiriman atomik multi-transaksi

Tipe Transaksi

// Satu transaksi rollup
let rhea = RheaTx::new(signed_eth_tx);
let mut tx = rome.compose_rollup_tx(rhea).await?;
let sig = rome.send_and_confirm(&mut *tx).await?;

// Transaksi atomik lintas-rollup
let remus = RemusTx::new(vec![tx1, tx2]);
let mut tx = rome.compose_cross_rollup_tx(remus).await?;

// Transaksi atomik lintas-chain (EVM + Solana)
let romulus = RomulusTx::new(eth_txs, sol_ixs);
let mut tx = rome.compose_cross_chain_tx(romulus, signers).await?;

Pooling Sumber Daya

SDK meng-pool keypair Solana (payer) dan indeks akun holder untuk pengiriman transaksi paralel:

let resource = resource_factory.get().await?;
let payer = resource.payer();       // Keypair Solana
let holder = resource.holder();     // Indeks akun holder
// Sumber daya otomatis dikembalikan ke pool saat Drop

Roadmap SDK

Sudah Dibangun dan Berfungsi

• Wrapper token SPL dan antarmuka precompile

• Swap Meteora DAMM v1 via CPI

• Oracle Gateway V1 + V2 (Pyth Pull, Switchboard V3)

• Helper System Program, deserialisasi Borsh

• ERC20SPL Factory + kontrak bridge

Berikutnya

• Deploy Solidity — deploy kontrak pertama Anda menggunakan SDK

• Panggil Solana dari EVM — gunakan CPI untuk berinteraksi dengan program Solana

• Alamat Kontrak — alamat kontrak SDK yang telah di-deploy