Rome SDK

Typisierte Solidity-Interfaces zum Aufrufen von Solana-Programmen aus EVM-Verträgen sowie das Rust-SDK hinter den Off-Chain-Services von Rome.

Das Rome SDK stellt typisierte Solidity-Interfaces bereit, um von EVM-Smart-Contracts aus mit Solana-Programmen zu interagieren. Es ist das Entwickler-Toolkit für den Aufbau von Anwendungen über Laufzeitumgebungen hinweg auf Rome.

SDKs

Rome hat SDKs für drei Zielgruppen — App-Builder (TypeScript), Contract-Entwickler (Solidity) und Infrastruktur-Betreiber (Rust).

TypeScript-SDK (@rome-protocol/sdk)

Für Dapp- und Frontend-Entwickler — das SDK, mit dem die meisten App-Builder beginnen. @rome-protocol/sdk umhüllt den Rome-Schreibpfad, sodass eine Web-App Rome-Transaktionen korrekt übermittelt: submitRomeTx (der korrekte Schreibpfad plus Gas-/Gebührenbehandlung), PDA-/ATA-Ableitung, CPI invoke / invoke_signed Encoder, Precompile-Bindungen und einen /bridge Subpfad. Installation per Repo zuerst (npm-Veröffentlichung ausstehend):

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

import { submitRomeTx } from '@rome-protocol/sdk';
// Sende jede Rome-EVM-Schreiboperation über den korrekten Schreibpfad ab (behandelt Gas-/Gebührenkodierung).

Die öffentlichen Referenz-Apps — rome-dex und cardo — verwenden dieses SDK.

Beide Pfade, ein SDK. submitRomeTx ist der EVM-Pfad (MetaMask). Für den Solana-Pfad — eine Phantom-/Solana-Wallet, die Ihre EVM-App steuert — submitRomeTxSolanaLane bildet das Gegenstück dazu: Der Nutzer signiert eine Solana-Transaktion, und Rome führt sie als EVM-Transaktion aus seiner abgeleiteten Identität aus, ganz ohne EVM-Schlüssel. Werte fließen hinein und hinaus über buildFundLeg / buildSweepLeg als ERC-20-Wrapper (z. B. wUSDC), nicht nativ msg.value — der synthetische Absender hält im Ruhezustand nichts — und ein erstmals verwendetes synthetisches Konto wird beim ersten Gebrauch automatisch bereitgestellt. Siehe Erstelle eine App mit zwei Pfaden und EVM von Solana aus aufrufen.

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

Für Solidity-Entwickler. Stellt die Precompile-Interfaces, ERC-20/SPL-Wrapper, PDA-Ableitung und CPI-Utilities bereit. Die npm-Veröffentlichung steht noch aus; heute beziehst du diese aus dem öffentlichen rome-solidity Repo (Git-Abhängigkeit oder kopierte Dateien).

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)

Für Infrastruktur-Betreiber. Ein Rust-Workspace, der Transaktionszusammenstellung, Solana-Interaktion, Gaspreisgestaltung und Blockindizierung übernimmt. Verwendet von Proxy und Hercules.

Solidity-SDK: Enthaltenes

Precompile-Interfaces

Binde ein Interface an seine Precompile-Adresse:

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

SPL-Token-Operationen

Verwende IHelperProgram (0xff…09) für mit User-PDA signierte SPL-Primitiven:

// Erstelle das ATA des Aufrufers für einen Mint
Helper.create_ata(user, mint);

// Übertrage SPL vom PDA des Aufrufers
Helper.transfer_spl(to, tokens, mint);

Auf dem Cache-Pfad liegen die entsprechenden Operationen auf ISplCached (0xff…05) und IAssociatedSplCached (0xff…06). Siehe interface.sol für alle Überladungen; ein Vertrag verwendet durchgehend einen Pfad.

PDA-Ableitung

// Leite das Solana-PDA eines Benutzers ab
bytes32 userPda = RomeEVMAccount.pda(msg.sender);

// Leite PDA mit Salt ab (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-Aufruf

// Rufe ein beliebiges Solana-Programm auf
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);

// Aufruf mit PDA-Signierung
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 über SPL-Token

// Stelle einen Wrapper für jeden SPL-Mint bereit
ERC20SPLFactory factory = ERC20SPLFactory(FACTORY_ADDRESS);
address wrapper = factory.add_spl_token_with_metadata(splMint);

// Verwende den Wrapper als Standard-ERC-20
SPL_ERC20 token = SPL_ERC20(wrapper);
token.transfer(recipient, amount);
uint256 balance = token.balanceOf(user);

Borsh-Deserialisierung

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

// Solana-Kontodaten parsen (Borsh-Format im Little-Endian)
(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/rome-solidity/contracts/mpl_token_metadata/lib.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 Cargo-Workspace. Seine Kern-Crates:

Crate	Zweck
rome-sdk	Kern-API: Rome Struktur, Konfiguration, Transaktionstypen (RheaTx, RemusTx, RomulusTx)
rome-evm-client	EVM-Rollup-Client, TxBuilder, ResourceFactory, Emulator-Integration
rome-solana	Solana-Tower, RPC-Client, Transaktions-Batching und -Tracking
rome-utils	RLP-, Hex-, JSON-RPC- und Authentifizierungs-Utilities
rome-obs	OpenTelemetry-Beobachtbarkeit (Traces, Metriken, Logs)
rome-meteora	Meteora-DEX-AMM-Pool-Adapter für die Gaspreisgestaltung
rome-jito-bundler	Jito-Bundle-Builder für atomare Mehrfach-Transaktionsübermittlung

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

Ressourcen-Pooling

Das SDK pooled Solana-Keypairs (Payer) und Holder-Kontoinstanzen für die parallele Transaktionsübermittlung:

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

SDK-Roadmap

Fertig und funktionsfähig

• SPL-Token-Wrapper und Precompile-Interfaces

• Meteora DAMM v1 Swaps über CPI

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

• System-Program-Helper, Borsh-Deserialisierung

• ERC20SPL-Factory + Bridge-Verträge

Was kommt als Nächstes

• Solidity deployen — deploye deinen ersten Vertrag mit dem SDK

• Solana aus EVM aufrufen — verwende CPI, um mit Solana-Programmen zu interagieren

• Contract-Adressen — bereitgestellte SDK-Contract-Adressen