Rome SDK

Typed Solidity interfaces for calling Solana programs from EVM contracts, plus the Rust SDK behind Rome's off-chain services.

The Rome SDK provides typed Solidity interfaces for interacting with Solana programs from EVM smart contracts. It's the developer toolkit for building cross-runtime applications on Rome.

SDKs

Rome has SDKs for three audiences — app builders (TypeScript), contract developers (Solidity), and infrastructure operators (Rust).

TypeScript SDK (@rome-protocol/sdk)

For dapp and frontend developers — the SDK most app builders start with. @rome-protocol/sdk wraps the Rome write path so a web app submits Rome transactions correctly: submitRomeTx (the correct write path plus gas/fee handling), PDA / ATA derivation, CPI invoke / invoke_signed encoders, precompile bindings, and a /bridge subpath. Repo-first install (npm publish pending):

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

import { submitRomeTx } from '@rome-protocol/sdk';
// Submit any Rome EVM write through the correct write path (handles gas/fee encoding).

The public reference apps — rome-dex and cardo — consume this SDK.

Both lanes, one SDK. submitRomeTx is the EVM lane (MetaMask). For the Solana lane — a Phantom/Solana wallet driving your EVM app — submitRomeTxSolanaLane mirrors it: the user signs a Solana transaction and Rome runs it as an EVM transaction from their derived identity, with no EVM key. Value moves in and out through buildFundLeg / buildSweepLeg as an ERC-20 wrapper (e.g. wUSDC), not native msg.value — the synthetic sender holds nothing at rest — and a first-time synthetic is auto-provisioned on first use. See Build a dual-lane app and Call EVM from Solana.

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

For Solidity developers. Provides the precompile interfaces, ERC-20/SPL wrappers, PDA derivation, and CPI utilities. The npm publish is pending; today you consume these from the public rome-solidity repo (git dependency or copied files).

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";

Rust SDK (rome-sdk)

For infrastructure operators. A Rust workspace that handles transaction composition, Solana interaction, gas pricing, and block indexing. Used by the Proxy and Hercules.

Solidity SDK: What's Included

Precompile Interfaces

Bind an interface to its precompile address:

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

SPL Token Operations

Use IHelperProgram (0xff…09) for user-PDA-signed SPL primitives:

// Create the caller's ATA for a mint
Helper.create_ata(user, mint);

// Transfer SPL from the caller's PDA
Helper.transfer_spl(to, tokens, mint);

On the cached track, the equivalent operations live on ISplCached (0xff…05) and IAssociatedSplCached (0xff…06). See interface.sol for all overloads; a contract uses one track consistently.

PDA Derivation

// Derive a user's Solana PDA
bytes32 userPda = RomeEVMAccount.pda(msg.sender);

// Derive PDA with salt (for creating multiple PDAs per user)
bytes32 pda = RomeEVMAccount.pda_with_salt(msg.sender, salt);

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

Cross-Program Invocation

// Call any Solana program
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);

// Call with PDA signing
CpiProgram.invoke_signed(programId, accounts, data, seeds);

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

ERC-20 over SPL Tokens

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

// Use the wrapper as standard ERC-20
SPL_ERC20 token = SPL_ERC20(wrapper);
token.transfer(recipient, amount);
uint256 balance = token.balanceOf(user);

Borsh Deserialization

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

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

Metaplex Metadata

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

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

Rust SDK: Architecture

The Rust SDK is a Cargo workspace. Its core crates:

Crate	Purpose
rome-sdk	Core API: Rome struct, config, transaction types (RheaTx, RemusTx, RomulusTx)
rome-evm-client	EVM rollup client, TxBuilder, ResourceFactory, emulator integration
rome-solana	Solana tower, RPC client, transaction batching and tracking
rome-utils	RLP, hex, JSON-RPC, authentication utilities
rome-obs	OpenTelemetry observability (traces, metrics, logs)
rome-meteora	Meteora DEX AMM pool adapters for gas pricing
rome-jito-bundler	Jito bundle builder for atomic multi-transaction submission

Transaction Types

// Single rollup transaction
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?;

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

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

Resource Pooling

The SDK pools Solana keypairs (payers) and holder account indices for parallel transaction submission:

let resource = resource_factory.get().await?;
let payer = resource.payer();       // Solana keypair
let holder = resource.holder();     // Holder account index
// Resource automatically returned to pool on Drop

SDK Roadmap

Built and Working

• SPL Token wrappers and precompile interfaces

• Meteora DAMM v1 swaps via CPI

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

• System Program helpers, Borsh deserialization

• ERC20SPL Factory + bridge contracts

What's Next

• Deploy Solidity — deploy your first contract using the SDK

• Call Solana from EVM — use CPI to interact with Solana programs

• Contract Addresses — deployed SDK contract addresses