> For the complete documentation index, see [llms.txt](https://docs.rome.builders/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rome.builders/de/produkte/rome-sdk.md). # Rome SDK Typisierte Solidity-Interfaces zum Aufrufen von Solana-Programmen aus EVM-Verträgen, plus das Rust-SDK hinter Roms Off-Chain-Diensten. Das Rome SDK bietet typisierte Solidity-Schnittstellen für die Interaktion mit Solana-Programmen aus EVM-Smart-Contracts. Es ist das Entwickler-Toolkit zum Erstellen von Anwendungen über Laufzeitumgebungen hinweg auf Rome. ## SDKs Rome hat SDKs für drei Zielgruppen — App-Builder (TypeScript), Contract-Entwickler (Solidity) und Teams, die ihre eigenen Dienste auf Rome betreiben (Rust). ### TypeScript SDK (`@rome-protocol/sdk`) **Für Dapp- und Frontend-Entwickler** — das SDK, mit dem die meisten App-Builder beginnen. [`@rome-protocol/sdk`](https://github.com/rome-protocol/rome-sdk-ts) umhüllt den Rome-Schreibpfad, sodass eine Web-App Rome-Transaktionen korrekt übermittelt: `submitRomeTx` (der richtige Schreibpfad plus Gas-/Gebührenbehandlung), PDA-/ATA-Ableitung, CPI `invoke` / `invoke_signed` Encoder, Precompile-Bindings und einen `/bridge` Unterpfad. Installieren direkt aus dem Repo (npm-Veröffentlichung steht noch aus): ```bash npm install github:rome-protocol/rome-sdk-ts#v0.4.0 ``` ```typescript import { submitRomeTx } from '@rome-protocol/sdk'; // Sende jeden Rome-EVM-Schreibvorgang über den korrekten Schreibpfad (behandelt Gas-/Gebührenkodierung). ``` Die öffentliche [rome-dex](https://github.com/rome-protocol/rome-dex) App verwendet nur einige der SDK-Hilfsfunktionen (PDA- und Token-Account-Ableitung, die CPI `invoke` Encoder und das 1,3-fache Gas-Padding) und [cardo](https://github.com/rome-protocol/cardo) ist nicht davon abhängig. Keines davon ruft `submitRomeTx` oder `submitRomeTxV1`, also lies sie, um zu sehen, wie eine App das CPI-Precompile aufruft, nicht den Schreibpfad des SDK. **Beide Wege, ein SDK.** `submitRomeTx` ist der EVM-Pfad (MetaMask). Für den **Solana-Pfad** — eine Solana-Wallet, die deine EVM-App steuert — `submitRomeTxV1` spiegelt ihn wider: Der Proxy setzt eine einzige Solana-v1-Transaktion für den Aufruf zusammen, die Wallet signiert zweimal mit demselben Schlüssel (eine lesbare Autorisierungsnachricht, dann die Transaktion), und Rome führt den Aufruf als EVM-Transaktion von der abgeleiteten Identität des Benutzers aus, ohne EVM-Schlüssel. Ein Aufruf, der nicht in eine Transaktion passt, wird vom Proxy mit derselben Autorisierungssignatur weitergeleitet, und `fundSyntheticGas` erhöht das native Gas, das ein weitergeleiteter Aufruf verbraucht. Ein weitergeleiteter Aufruf, der revertiert, wird mit `receipt.status === "0x0"` statt einen Fehler auszulösen aufgelöst, also prüfe das; die [weitergeleitete Aufrufe und lange Aufrufe](/de/entwicklerleitfaden/call-evm-from-solana.md#relayed-calls-and-long-calls) Sektion hat die Gasregel und die Limits. Werte bewegen sich hinein und hinaus über `buildFundLeg` / `buildSweepLeg` als ERC-20-Wrapper (z. B. `wUSDC`), nicht nativ `msg.value` — der synthetische Sender hält im Ruhezustand nichts — und ein erstmaliges synthetisches Konto wird einmalig und explizit bereitgestellt mit `buildCreatePdaCall`. Die frühere `submitRomeTxSolanaLane`, die im Client eine Legacy-Solana-Transaktion erstellt, ist weiterhin im SDK. Siehe [Eine Dual-Lane-App bauen](/de/entwicklerleitfaden/dual-lane-app.md) und [EVM aus Solana aufrufen](/de/entwicklerleitfaden/call-evm-from-solana.md). ### Solidity SDK (`@rome-protocol/rome-solidity`) **Für Solidity-Entwickler.** Bietet die Precompile-Schnittstellen, ERC-20/SPL-Wrapper, PDA-Ableitung und CPI-Dienstprogramme. Die npm-Veröffentlichung steht noch aus; heute beziehst du diese aus dem öffentlichen [`rome-solidity`](https://github.com/rome-protocol/rome-solidity) Repo (Git-Abhängigkeit oder kopierte Dateien). ```solidity 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 Teams, die ihre eigenen Dienste auf Rome betreiben.** Ein Rust-Workspace, der Transaktionszusammenstellung, Solana-Interaktion, Gaspreisgestaltung und Blockindexierung übernimmt. Der Proxy und Hercules bauen darauf auf. Der Quellcode befindet sich in [`rome-protocol/rome-sdk`](https://github.com/rome-protocol/rome-sdk). Es sendet Solana-v1-Transaktionen (4 KB, bis zu 64 Konten). **Erstellen.** Der Workspace erwartet, dass die Repositories [`rome-sdk`](https://github.com/rome-protocol/rome-sdk), [`rome-evm`](https://github.com/rome-protocol/rome-evm) und [`mollusk`](https://github.com/rome-protocol/mollusk) nebeneinander geklont sind, weil er von den anderen beiden über einen relativen Pfad abhängt. Das ist auch der Grund, warum der unterstützte Weg, ihn aus einem anderen Projekt zu verwenden, eine Pfadabhängigkeit ist, nicht eine einfache Git-Abhängigkeit. Du benötigst Rust 1.85 oder neuer und Netzwerkzugriff für den ersten Build. `rome-evm` hat keine Standard-Netzwerkfunktion, daher benötigt jeder Build, der es kompiliert, genau eine von `ci`, `testnet` oder `mainnet`; verwende `ci` für lokale Arbeit, zum Beispiel `cargo test -p rome-sdk --features ci`. Die README des Repositories enthält die vollständigen Schritte und die Feature-Tabelle. **Lizenz.** Das Rust-SDK ist source-available, nicht Open Source: Alle Rechte vorbehalten und darf für persönliche, nicht-kommerzielle Zwecke verwendet werden. Die kommerzielle Nutzung erfordert die schriftliche Genehmigung von Rome Protocol; die `LICENSE` des Repositories sagt, wie man sie anfragt. ## Solidity SDK: Was enthalten ist ### Precompile-Schnittstellen Binde eine Schnittstelle an ihre Precompile-Adresse: ```solidity ISystemProgram constant System = ISystemProgram(0xFF00000000000000000000000000000000000007); ICrossProgramInvocation constant Cpi = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008); IHelperProgram constant Helper = IHelperProgram(0xFF00000000000000000000000000000000000009); IWithdraw constant Withdraw = IWithdraw(0x4200000000000000000000000000000000000016); // Zwischengespeicherte Spur: ISplCached 0xff…05, IAssociatedSplCached 0xff…06, ISystemCached 0xff…04, IWithdrawCached 0xff…0b ``` ### SPL-Token-Operationen Verwenden Sie `IHelperProgram` (`0xff…09`) für vom Benutzer-PDA signierte SPL-Primitiven: ```solidity // Erstelle den 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 der zwischengespeicherten Spur liegen die entsprechenden Operationen auf `ISplCached` (`0xff…05`) und `IAssociatedSplCached` (`0xff…06`). Siehe `interface.sol` für alle Überladungen; ein Vertrag verwendet konsequent eine Spur. ### PDA-Ableitung ```solidity // 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); // Finde beliebiges PDA (bytes32 pda, uint8 bump) = SystemProgram.find_program_address(programId, seeds); ``` ### Cross-Program Invocation ```solidity // 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-Signatur 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 ```solidity // Wrapper für jedes SPL-Mint bereitstellen 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 ```solidity import {Convert} from "@rome-protocol/rome-solidity/contracts/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 ```solidity 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` 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-utils` | RLP-, Hex-, JSON-RPC- und Authentifizierungs-Dienstprogramme | | `rome-obs` | OpenTelemetry-Beobachtbarkeit (Traces, Metriken, Logs) | | `rome-meteora` | Meteora DAMM v1- und v2-Pool-Reader für die Gaspreisgestaltung | | `rome-meta-hook` | Client für das Meta-Hook-Router-Programm: Token-2022-Transfer-Hook-Konfiguration, Auflösung zusätzlicher Konten, Übertragungen mit Schätzungen des Compute-Budgets | | `rome-jito-bundler` | Jito-Bundle-Builder für atomare Multi-Transaktions-Übermittlung | ### Transaktionstypen ```rust // 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 poolt Solana-Keypairs (Payer) und Holder-Kontoinstanzen für die parallele Übermittlung von Transaktionen: ```rust 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 ### Gebaut und funktionsfähig * SPL-Token-Wrapper und Precompile-Schnittstellen * Meteora DAMM v1 Swaps via CPI * Oracle Gateway V1 + V2 (Pyth Pull, Switchboard V3) * Hilfsfunktionen des Systemprogramms, Borsh-Deserialisierung * ERC20SPL Factory + Bridge-Contracts ## Wie es weitergeht * [Solidity bereitstellen](/de/entwicklerleitfaden/deploy-solidity.md) — deploye deinen ersten Vertrag mit dem SDK * [Solana aus EVM aufrufen](/de/entwicklerleitfaden/call-solana-from-evm.md) — verwende CPI, um mit Solana-Programmen zu interagieren * [Contract Addresses](/de/referenz/contract-addresses.md) — bereitgestellte SDK-Vertragsadressen --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://docs.rome.builders/de/produkte/rome-sdk.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.