> 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/kernkonzepte/constraints.md).

# Einschränkungen

Grenzen beim Entwickeln auf Rome EVM — Solana-Transaktionsgröße, Budget von \~1,4 Mio. CU, Account-Grenzen, Speicher-Layout und wie Rome jede davon umgeht.

Wichtige Grenzen und Beschränkungen beim Aufbau auf Rome EVM. Das Verständnis dieser Einschränkungen hilft Ihnen, Verträge zu entwerfen, die zuverlässig funktionieren.

## Solana-Transaktionslimits

| Beschränkung                  | Wert               | Auswirkung                                                                                                                                              |
| ----------------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Transaktionsgröße             | 4 KB (4.096 Bytes) | Rome sendet Solana-v1-Transaktionen; größere EVM-Transaktionen werden in Holder-Konten zwischengelagert (transparent)                                   |
| Compute Units pro Transaktion | \~1,4 Mio. CU      | Operationen, die dies überschreiten, verwenden den iterativen Modus, der eigene Obergrenzen hat (unten)                                                 |
| Konten pro Transaktion        | 64 Adressen        | Die Obergrenze für v1-Transaktionen; alles, was die EVM-Transaktion und ihre CPIs berühren, einschließlich der eigenen Konten von Rome, wird mitgezählt |
| Maximale Holder-Größe         | 80 KB              | Maximale RLP-Größe für eine einzelne EVM-Transaktion                                                                                                    |

## EVM-Ausführungsgrenzen

| Beschränkung                             | Wert                                                   | Hinweise                                                                                                                                                                                                                    |
| ---------------------------------------- | ------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Vertrags-Speicher-Slots                  | 256 pro Speicherkonto                                  | Pro Vertrag können mehrere Speicherkonten erstellt werden                                                                                                                                                                   |
| Opcodes pro Iteration                    | Adaptiv                                                | An das CU-Budget jeder Solana-Transaktion gepackt (VmIt)                                                                                                                                                                    |
| TTL der Kontensperre                     | 3 s (4 s, wenn die Sitzung mehr als 28 Konten berührt) | Während der iterativen Ausführung; bei jedem Schritt erneuert                                                                                                                                                               |
| Länge der iterativen Sitzung             | 160 Schritte                                           | Nach Überschreiten der Obergrenze gibt der nächste Schritt die Sperren der Sitzung frei und beendet sie, ohne etwas zu committen                                                                                            |
| Vom Rust-Rome-SDK geplante Legs          | 128                                                    | Die Obergrenze des iterativen Composers; echte Aufrufe kommen mit deutlich weniger aus                                                                                                                                      |
| Transaktionen pro wallet-signiertem Plan | 64                                                     | Die meisten `rome_submitSignedV1Plan` akzeptiert in einem Aufruf; siehe [Weitergeleitete Aufrufe und lange Aufrufe](https://docs.rome.builders/de/entwicklerleitfaden/call-evm-from-solana.md#relayed-calls-and-long-calls) |
| Treasury-Wallets                         | 64                                                     | Fee-Pool-Wallets                                                                                                                                                                                                            |
| Vertragsgrößenlimit                      | 24 KB                                                  | Wie bei Ethereum (EIP-170, 24.576 Bytes)                                                                                                                                                                                    |

## CPI-Beschränkungen

| Beschränkung                   | Wert                                                                       | Hinweise                                                                                                                                    |
| ------------------------------ | -------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| CPI-Tiefe                      | maximal 4 Ebenen                                                           | Solanas CPI-Tiefenlimit                                                                                                                     |
| Konten pro CPI-Aufruf          | Innerhalb der 64-Adressen-Obergrenze der Transaktion                       | Wird mit jedem anderen Konto geteilt, das die Transaktion berührt                                                                           |
| CPI- + Transfer-Hook-Tiefe     | Verwendet CPI-Ebenen                                                       | Transfer-Hooks innerhalb von CPI können die Tiefe überschreiten                                                                             |
| Ein Track pro Vertrag          | Legacy (`0xff…07/08/09`, `0x42…16`) **oder** gecached (`0xff…04/05/06/0b`) | Das Mischen verändernder Aufrufe aus beiden in einer Transaktion wird abgelehnt                                                             |
| Legacy-CPI im iterativen Modus | Nicht erlaubt                                                              | Eine Legacy-Track-CPI in einer iterativen Transaktion schlägt fehl mit `CpiProhibitedInIterativeTx`; Effekte des Cached-Tracks sind erlaubt |

**CPI-Tiefe ist die kritischste Beschränkung.** Rome EVM verbraucht eine CPI-Ebene, wenn Solana das Rome-Programm aufruft. Wenn Ihr Solidity-Vertrag dann über CPI ein weiteres Solana-Programm aufruft, ist das Ebene 2. Wenn dieses Programm ein weiteres aufruft, ist das Ebene 3. Insgesamt haben Sie höchstens 4 Ebenen.

```
Ebene 0: Solana Runtime → Rome-EVM-Programm
Ebene 1: Rome-EVM-Programm → Ihr CPI-Ziel (z. B. Jupiter)
Ebene 2: Jupiter → ein anderes Programm (z. B. Raydium)
Ebene 3: Raydium → SPL Token (maximale Tiefe)
```

## Token-2022-Transfer-Hook-Beschränkungen

| Beschränkung            | Auswirkung                                                                                  |
| ----------------------- | ------------------------------------------------------------------------------------------- |
| Ein Hook pro Mint       | Ein Token-2022-Mint hat genau einen Transfer-Hook-Slot                                      |
| `transfer_checked` nur  | Hooks werden bei einfachem `transfer`. Rome-Bridge-Operationen verwenden `transfer_checked` |
| Mint/Burn nicht gehookt | Wird über die Mint-Authority gesteuert, nicht über Hooks                                    |

## Gas- und Preisbeschränkungen

| Beschränkung           | Hinweise                                                              |
| ---------------------- | --------------------------------------------------------------------- |
| Gas-Preisquelle        | Meteora-DAMM-Pool, v1 oder v2 (SPL-Gas-Token)                         |
| Gaspreis-Multiplikator | Pro Proxy konfigurierbar (`gas_price_mul`)                            |
| Mindestgaspreis        | Durch die Proxy-Konfiguration festgelegt                              |
| Gas-Schätzung          | Vor der Übermittlung off-chain über den Mollusk-Emulator durchgeführt |

## Netzwerkspezifische Beschränkungen

| Umgebung           | Chain-ID | rome-evm-Programm-ID                          |
| ------------------ | -------- | --------------------------------------------- |
| Hadrian (Testnetz) | 200010   | `RPTWwELXAY4KC9ZPHhaxp7Sq1hHtU3HNEgLbSegCcWf` |
| Rubicon (Mainnet)  | 7531     | `RomePq9X3iAoTr813HR7uRarafFDUJty6GdiEceYpzX` |

## Precompile-Beschränkungen

| Precompile                 | Beschränkung                                                                                                                            |
| -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| Modexp (0x05)              | **Deaktiviert** — ein Aufruf revertiert mit `big_mod_exp-Aufruf ist deaktiviert` bis Solana das `big_mod_exp` Syscall                   |
| BN254 ecPairing (0x08)     | Etwa 22K CU plus 12,8K pro Paar gemäß der Preisgestaltung des Programms; eine Prüfung mit vier Paaren passt in eine atomare Transaktion |
| CPI-Precompile (0xFF...08) | Konten müssen in der Solana-Transaktion im Voraus deklariert werden                                                                     |

## Transaktionsvalidierung

| Regel                          | Wirkung                                                                                                                                                                                                                  |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Signatur-Malleabilität (EIP-2) | Eine signierte Transaktion, deren `s` über der Hälfte der Kurvenordnung liegt, wird abgelehnt                                                                                                                            |
| RLP-Form                       | Eine Transaktion, deren RLP-Liste nach ihrem letzten Element noch nachfolgende Bytes enthält, wird abgelehnt                                                                                                             |
| Nicht implementierter Opcode   | Bricht die gesamte Transaktion ab (`IncompatibleVersionEVM(opcode)`); nichts wird committed und ein aufrufender Vertrag kann es nicht abfangen                                                                           |
| Gas-Messung                    | Rome hat keinen gasbezogenen Zeitplan pro Opcode: Das an `CALL`/`CREATE` übergebene Gas wird nicht erzwungen, und es gibt kein 2300-Gas-Stipendium — verlassen Sie sich nicht auf Schutz vor Reentrancy durch Stipendien |

## Oracle-Beschränkungen

| Beschränkung                        | Wert                                                                      |
| ----------------------------------- | ------------------------------------------------------------------------- |
| Standardmäßige maximale Veralterung | 60 Sekunden                                                               |
| Historische Rundendaten             | Nicht unterstützt — `getRoundData(roundId)` revertiert                    |
| Switchboard EMA                     | Nicht unterstützt — `latestEMAData()` revertiert auf SwitchboardV3        |
| Parser-Offsets                      | Empirisch validiert — vor einer erneuten Bereitstellung erneut validieren |

## Design-Empfehlungen

1. **Halten Sie die CPI-Tiefe flach.** Entwerfen Sie Verträge so, dass Verschachtelung minimiert wird. Wenn Sie Jupiter aufrufen, das Raydium aufruft, das SPL Token aufruft, sind Sie bei 3 Ebenen — gefährlich nah am Limit.
2. **Bevorzugen Sie den atomaren Modus.** Entwerfen Sie Operationen so, dass sie in \~1,4 Mio. CU passen. Der iterative Modus erhöht die Latenz (3-4 Sekunden Sperren), begrenzt auf 160 Iterationen pro Sitzung, und erzeugt eine Wallet-Abfrage pro Leg auf der Solana-Lane, wenn die Wallet die Legs selbst signiert. Ein Aufruf, der Legacy-Track-CPIs macht, kann überhaupt nicht iterativ ausgeführt werden.
3. **Konten im Voraus deklarieren.** Alle von CPI berührten Solana-Konten müssen zum Zeitpunkt der Transaktionserstellung bekannt sein (die Emulation des Proxys entdeckt sie). Dynamische Kontenermittlung innerhalb eines CPI-Aufrufs ist nicht möglich, und die Gesamtzahl muss in die 64-Adressen-Obergrenze passen.
4. **Wählen Sie pro Vertrag einen Precompile-Track.** Das Aufrufen eines benutzerdefinierten Solana-Programms (`invoke_signed`) ist Legacy-Track und nur atomar; siehe [Integrieren Sie ein Solana-Programm](https://docs.rome.builders/de/entwicklerleitfaden/integrate-solana-program.md).
5. **Verwenden Sie `transfer_checked`.** Wenn Sie etwas entwickeln, das Token-2022-Token berührt, verwenden Sie immer `transfer_checked` , damit Hooks ausgelöst werden.
6. **CU-Verbrauch testen.** Messen Sie die tatsächlichen Solana-Compute-Units anhand der Transaktionsquittung (`computeUnitsConsumed`) — EVM `gasUsed` ist kein verlässlicher Stellvertreter für Solana-CU. Optimieren Sie Hot Paths mit Yul.

## Wie es weitergeht

* [Compute-Budget](https://docs.rome.builders/de/kernkonzepte/compute-budget.md) — detaillierte CU-Kosten pro Operation
* [Token-Interop](https://docs.rome.builders/de/kernkonzepte/token-interop.md) — ERC-20 ↔ SPL-Bridge-Modell
* [Precompile-Referenz](https://docs.rome.builders/de/referenz/precompiles.md) — jeder Selektor und seine Dispatch-Klasse


---

# 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/kernkonzepte/constraints.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.
