> 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-Interfaces für die Interaktion mit Solana-Programmen aus EVM-Smart Contracts. Es ist das Entwickler-Toolkit für den Aufbau von Cross-Runtime-Anwendungen auf Rome.

## SDKs

Rome hat SDKs für drei Zielgruppen — App-Ersteller (TypeScript), Vertragsentwickler (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-Ersteller 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 korrekte Schreibpfad plus Gas-/Gebührenbehandlung), PDA-/ATA-Ableitung, CPI `invoke` / `invoke_signed` Encoder, Precompile-Bindings und einen `/bridge` Unterpfad. Repo-first-Installation (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';
// Jede Rome-EVM-Schreiboperation über den korrekten Schreibpfad übermitteln (handhabt Gas-/Gebührenkodierung).
```

Die öffentliche [rome-dex](https://github.com/rome-protocol/rome-dex) App nutzt nur wenige der Helfer des SDK (PDA- und Token-Account-Ableitung, den CPI `invoke` Encoder und den 1,3x-Gas-Puffer), und [cardo](https://github.com/rome-protocol/cardo) ist nicht davon abhängig. Weder ruft `submitRomeTx` oder `submitRomeTxV1`es auf, daher lesen Sie sie, um zu sehen, wie eine App das CPI-Precompile aufruft, nicht für den Schreibpfad des SDK.

**Beide Wege, ein SDK.** `submitRomeTx` ist der EVM-Weg (MetaMask). Für den **Solana-Weg** — eine Solana-Wallet, die Ihre EVM-App steuert — `submitRomeTxV1` spiegelt es wider: Der Proxy setzt für den Aufruf eine einzelne Solana-v1-Transaktion zusammen, die Wallet signiert zweimal mit demselben Schlüssel (eine lesbare Autorisierungsnachricht, dann die Transaktion), und Rome führt den Aufruf als EVM-Transaktion aus der abgeleiteten Identität des Nutzers aus, ohne EVM-Schlüssel. Ein Aufruf, der nicht in eine Transaktion passt, wird vom Proxy mit derselben Autorisierungs-Signatur weitergeleitet, und `fundSyntheticGas` gleicht das native Gas aus, das ein weitergeleiteter Aufruf verbraucht. Ein weitergeleiteter Aufruf, der revertet, wird mit `receipt.status === "0x0"` statt einen Fehler zu werfen, also prüfen Sie das; die [weitergeleitete Aufrufe und lange Aufrufe](https://docs.rome.builders/de/entwicklerleitfaden/call-evm-from-solana.md#relayed-calls-and-long-calls) Abschnitt enthält die Gasregel und die Limits. Werte fließen 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 synthetisches Konto wird beim ersten Mal einmalig, ausdrücklich, mit `buildCreatePdaCall`. Das frühere `submitRomeTxSolanaLane`, das im Client eine Legacy-Solana-Transaktion erstellt, ist weiterhin im SDK. Siehe [Eine Dual-Lane-App bauen](https://docs.rome.builders/de/entwicklerleitfaden/dual-lane-app.md) und [EVM aus Solana aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-evm-from-solana.md).

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

**Für Solidity-Entwickler.** Bietet die Precompile-Interfaces, ERC-20/SPL-Wrappers, PDA-Ableitung und CPI-Dienstprogramme. Die npm-Veröffentlichung steht noch aus; heute beziehen Sie 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, Gas-Preise und Block-Indexierung ü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).

**Wie man es baut.** 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 werden, da er von den anderen beiden per relativem Pfad abhängt. Das ist auch der Grund, warum die unterstützte Art, ihn von einem anderen Projekt aus zu verwenden, eine Pfadabhängigkeit ist und keine einfache Git-Abhängigkeit. Sie benötigen Rust 1.85 oder neuer und beim ersten Build Netzwerkzugang. `rome-evm` hat keine standardmäßige Netzwerkfunktion, daher benötigt jeder Build, der es kompiliert, genau eines von `ci`, `Testnet` oder `Mainnet`; verwenden Sie `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. Für kommerzielle Nutzung ist die schriftliche Erlaubnis von Rome Protocol erforderlich; die `LICENSE` des Repositories erklärt, wie man sie anfragt.

## Solidity SDK: Was enthalten ist

### Precompile-Interfaces

Binde ein Interface an seine Precompile-Adresse:

```solidity
ISystemProgram          constant System   = ISystemProgram(0xFF00000000000000000000000000000000000007);
ICrossProgramInvocation constant Cpi      = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);
IHelperProgram          constant Helper   = IHelperProgram(0xFF00000000000000000000000000000000000009);
IWithdraw               constant Withdraw = IWithdraw(0x4200000000000000000000000000000000000016);
// Cache-Track: 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-Grundoperationen:

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

// SPL vom PDA des Aufrufers übertragen
Helper.transfer_spl(to, tokens, mint);
```

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

### PDA-Ableitung

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

// PDA mit Salt ableiten (zum Erstellen mehrerer PDAs pro Benutzer)
bytes32 pda = RomeEVMAccount.pda_with_salt(msg.sender, salt);

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

### Programmübergreifender Aufruf

```solidity
// 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-Signatur 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 ü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);

// Den Wrapper als standardmäßiges ERC-20 verwenden
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-Account-Daten parsen (Borsh-Format mit Little Endian)
(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 aus 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, die drei Transaktionstypen (`RheaTx`, `RemusTx`, `RomulusTx`)                                                            |
| `rome-evm-client`   | EVM-Client für Rome-Chains, TxBuilder, ResourceFactory, Emulator-Integration                                                                                       |
| `rome-solana`       | Solana-Tower, RPC-Client, Transaktions-Batching und -Tracking                                                                                                      |
| `rome-utils`        | RLP-, Hex-, JSON-RPC- und Authentifizierungsdienstprogramme                                                                                                        |
| `rome-obs`          | OpenTelemetry-Beobachtbarkeit (Traces, Metriken, Logs)                                                                                                             |
| `rome-meteora`      | Meteora DAMM v1- und v2-Pool-Leser für die Gas-Preisermittlung                                                                                                     |
| `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 Mehrfach-Transaktionsübermittlung                                                                                                  |

### Transaktionstypen

```rust
// Eine EVM-Transaktion auf einer Rome-Chain
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?;

// Mehrere EVM-Transaktionen auf verschiedenen Rome-Chains, atomar in einer Solana-Transaktion
let remus = RemusTx::new(vec![tx1, tx2]);
let mut tx = rome.compose_cross_rollup_tx(remus).await?;

// EVM-Transaktionen plus native Solana-Instruktionen, atomar in einer Solana-Transaktion
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-Account-Indizes für parallele Transaktionsübermittlung:

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

## SDK-Roadmap

### Gebaut und funktionsfähig

* SPL-Token-Wrapper und Precompile-Interfaces
* Meteora DAMM v1 Swaps via CPI
* Oracle Gateway V1 + V2 (Pyth Pull, Switchboard V3)
* System-Program-Helfer, Borsh-Deserialisierung
* ERC20SPL-Factory + Bridge-Verträge

## Wie es weitergeht

* [Solidity bereitstellen](https://docs.rome.builders/de/entwicklerleitfaden/deploy-solidity.md) — deployen Sie Ihren ersten Vertrag mit dem SDK
* [Solana aus EVM aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-solana-from-evm.md) — verwenden Sie CPI, um mit Solana-Programmen zu interagieren
* [Contract Addresses](https://docs.rome.builders/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=<question>&goal=<user_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.
