Rome SDK

Das Rome SDK stellt typisierte Solidity-Schnittstellen bereit, um von EVM-Smart-Contracts aus mit Solana-Programmen zu interagieren. Es ist das Entwickler-Toolkit zum Erstellen von Cross-Runtime-Anwendungen auf Rome.

Zwei SDKs

Rome hat zwei SDKs, die unterschiedlichen Zwecken dienen:

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

Für Solidity-Entwickler. Stellt Precompile-Schnittstellen, ERC-20/SPL-Wrapper, PDA-Ableitung und CPI-Dienstprogramme bereit. Installation über npm und Import in Ihre Solidity-Contracts.

npm install @rome-protocol/solidity-sdk

import {SplToken, CpiProgram, SystemProgram} from "@rome-protocol/solidity-sdk/contracts/core/Precompiles.sol";
import {SPL_ERC20} from "@rome-protocol/solidity-sdk/contracts/token/ERC20SPL.sol";
import {RomeEVMAccount} from "@rome-protocol/solidity-sdk/contracts/core/RomeEVMAccount.sol";

Rust SDK (rome-sdk)

Für Infrastrukturbetreiber. Ein Rust-Workspace aus 9 Crates, der Transaktionszusammenstellung, Solana-Interaktion, Gaspreisgestaltung, Blockindizierung und Service-Orchestrierung übernimmt. Verwendet von Proxy, Hercules und Rhea.

Solidity SDK: Was enthalten ist

Precompile-Schnittstellen

Vorgebundene Singleton-Konstanten für alle Rome-Precompiles:

// Nach dem Import global verfügbar
ISplToken constant SplToken;                    // 0xff...05
IAssociatedSplToken constant AssociatedSplToken; // 0xff...06
ISystemProgram constant SystemProgram;           // 0xff...07
ICrossProgramInvocation constant CpiProgram;     // 0xff...08
IWithdraw constant Withdraw;                     // 0x42...16

SPL-Token-Operationen

// Tokenkontostatus lesen
ISplToken.Account memory acc = SplToken.account_state(tokenAccountPubkey);
uint64 balance = acc.amount;
bytes32 owner = acc.owner;

// Tokens übertragen
SplToken.transfer(recipientAta, mintPubkey, amount);

// Ein neues Tokenkonto initialisieren
SplToken.initialize_account3(newAccount, mintPubkey, ownerPubkey);

PDA-Ableitung

// Ein Solana-PDA eines Benutzers ableiten
bytes32 userPda = RomeEVMAccount.pda(msg.sender);

// PDA mit Salt ableiten (um mehrere PDAs pro Benutzer zu erstellen)
bytes32 pda = RomeEVMAccount.pda_with_salt(msg.sender, salt);

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

Cross-Program Invocation

// Beliebiges Solana-Programm aufrufen
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);

// Mit PDA-Signierung aufrufen
CpiProgram.invoke_signed(programId, accounts, data, seeds);

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

ERC-20 auf SPL-Tokens

// Wrapper für beliebiges SPL-Mint bereitstellen
ERC20SPLFactory factory = ERC20SPLFactory(FACTORY_ADDRESS);
address wrapper = factory.add_spl_token_with_metadata(splMint);

// Den Wrapper als standardmäßiges ERC-20 verwenden
SPL_ERC20 token = SPL_ERC20(wrapper);
token.transfer(recipient, amount);
uint256 balance = token.balanceOf(user);

Token-Registry

TokenRegistry registry = TokenRegistry(REGISTRY_ADDRESS);

// Mit Cross-Chain-Metadaten registrieren
registry.registerToken(splMint, TokenOrigin.WormholeWrapped, externalAddr, chainId);

// Nach externem Token nachschlagen
TokenEntry memory entry = registry.getTokenByExternal(2, ethUsdcAddress);

Borsh-Deserialisierung

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

// Solana-Kontodaten parsen (Little-Endian-Borsh-Format)
(uint64 value, uint256 newOffset) = Convert.read_u64le(data, offset);
(bytes32 pubkey, uint256 newOffset2) = Convert.read_bytes32(data, offset);

Metaplex-Metadaten

import {MplTokenMetadataLib} from "@rome-protocol/solidity-sdk/contracts/programs/metadata/MplTokenMetadataLib.sol";

// Token-Metadaten von Metaplex laden
MplTokenMetadataLib.Metadata memory meta = MplTokenMetadataLib.load_metadata(
    mintPubkey, mplProgramId, cpiAddress
);
string memory name = meta.name;
string memory symbol = meta.symbol;

Rust SDK: Architektur

Das Rust SDK ist ein Workspace mit 9 Crates:

Crate	Zweck
rome-sdk	Kern-API: Rome struct, config, Transaktionstypen (RheaTx, RemusTx, RomulusTx)
rome-evm-client	EVM-Rollup-Client, TxBuilder, ResourceFactory, Emulator-Integration
rome-solana	Solana-Tower, RPC-Client, Transaktionsbündelung und -verfolgung
rome-geth	OP-Geth Engine API-Integration für den Blockaufbau
rome-utils	RLP-, Hex-, JSON-RPC-, Authentifizierungs-Dienstprogramme
rome-obs	OpenTelemetry-Observability (Traces, Metriken, Logs)
rome-da	Celestia-Datenverfügbarkeitsschicht
rome-meteora	Meteora DEX AMM-Pool-Adapter für die Gaspreisgestaltung
rome-meta-hook	Client für Token-2022 Transfer-Hook-Router

Transaktionstypen

// Einzelne Rollup-Transaktion
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?;

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

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

Ressourcenpooling

Das SDK poolt Solana-Keypairs (Zahler) und Holder-Kontoindizes für parallele Transaktionseinreichung:

let resource = resource_factory.get().await?;
let payer = resource.payer();       // Solana-Keypair
let holder = resource.holder();     // Holder-Kontoindex
// Ressource wird beim Drop automatisch an den Pool zurückgegeben

SDK-Roadmap

Erstellt und funktionsfähig

• SPL-Token-Wrapper und Precompile-Schnittstellen

• Meteora DAMM v1 Swaps via CPI

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

• System-Program-Helper, Borsh-Deserialisierung

• ERC20SPL Factory + Bridge-Contracts

• Token-Registry mit Cross-Chain-Metadaten

In Arbeit

• JupiterRouter (Solidity-Schnittstelle für Jupiter-Swaps)

• Meta-Hook Router SDK-Client

Geplant (Phase 2)

Schnittstelle	Protokoll
IJupiter	Jupiter DEX-Aggregator
IDrift	Drift-Perpetuals
IKamino	Kamino Lending
IMeteora	Meteora-Liquidität
IOndoGM	Ondo RWA

Geplant (Phase 3)

Schnittstelle	Programm
IStakeProgram	Solana Stake
IVoteProgram	Solana Vote
ISlotHashes	SlotHashes-Sysvar

Was kommt als Nächstes

• Solidity bereitstellen — stellen Sie Ihren ersten Contract mithilfe des SDK bereit

• Solana von EVM aus aufrufen — verwenden Sie CPI, um mit Solana-Programmen zu interagieren

• Contract-Adressen — bereitgestellte SDK-Contract-Adressen