> 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/compute-budget.md).

# Compute-Budget

Solana-Compute-Unit-(CU)-Kosten für Rome-EVM-Operationen — atomare vs. iterative Budgets und wie man CU-effiziente Solidity-Contracts entwirft.

Jede Solana-Transaktion hat ein Compute-Budget, das in Compute Units (CU) gemessen wird. Das Verständnis der CU-Kosten hilft Ihnen, effiziente Rome-Contracts zu entwerfen.

## Budgetübersicht

| Modus           | Max. CU                                                                    | Hinweise                                                                                                           |
| --------------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| Atomar (VmAt)   | \~1.400.000 CU                                                             | Eine einzelne Solana-Transaktion                                                                                   |
| Iterativ (VmIt) | Bis zu \~1.400.000 CU pro Abschnitt; höchstens 160 Iterationen pro Sitzung | Jeder Abschnitt ist eine eigene Solana-Transaktion; adaptive Opcodes/Schritt — an das CU-Budget jeder Tx angepasst |

Jede Solana-Transaktion hat standardmäßig ein Budget von 200.000 CU, das über Compute-Budget-Instruktionen auf \~1,4 Mio. CU erweitert werden kann (vom Rome SDK automatisch hinzugefügt).

Iterative Ausführung ist nicht unbegrenzt. Eine Sitzung endet nach 160 Iterationen, und der iterative Composer des Rust-Rome-SDK plant höchstens 128 Abschnitte. Ein Plan, den die Wallet selbst signiert, läuft über `rome_submitSignedV1Plan`, der pro Aufruf höchstens 64 Transaktionen akzeptiert. Die meisten Aufrufe benötigen deutlich weniger. Legacy-Track-CPIs werden innerhalb einer iterativen Sitzung abgelehnt, daher muss ein Aufruf, der sie ausführt, in das atomare Budget passen. Siehe [Weitergeleitete Aufrufe und lange Aufrufe](https://docs.rome.builders/de/entwicklerleitfaden/call-evm-from-solana.md#relayed-calls-and-long-calls) und [Beschränkungen](https://docs.rome.builders/de/kernkonzepte/constraints.md).

## Schätzungen der CU-Kosten

### EVM-Operationen

| Operation                                       | Ungefähre CU         | Hinweise                                                                                           |
| ----------------------------------------------- | -------------------- | -------------------------------------------------------------------------------------------------- |
| Transaktionssignaturprüfung (EVM-Schlüsselpfad) | \~25.000 CU          | Die `secp256k1_recover` Syscall, die gleichen Kosten wie der `ecrecover` unten stehende Precompile |
| Einfache Überweisung                            | \~50.000-100.000 CU  | Nur Saldoaktualisierungen                                                                          |
| ERC-20-Überweisung                              | \~100.000-150.000 CU | Enthält einen SPL-Precompile-Aufruf                                                                |
| Contract-Bereitstellung (klein)                 | \~200.000-400.000 CU | Hängt von der Bytecode-Größe ab                                                                    |
| Speicherschreibvorgang (SSTORE)                 | \~5.000-20.000 CU    | Cold- vs. Warm-Zugriff                                                                             |

### Precompile-Operationen

| Precompile      | Ungefähre CU                          | Hinweise                                                                                                                                                                                                                                                                                     |
| --------------- | ------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ecrecover       | \~25.700 CU                           |                                                                                                                                                                                                                                                                                              |
| SHA-256         | \~257 CU pro 32-Byte-Word gemessen    | Zusätzlich zu einem kleinen Fixbetrag. Das Programm berechnet SHA-256, RIPEMD-160 und das Identity-Precompile mit einem gemeinsamen Pro-Word-Wert von etwa 2.200 CU, ausgerichtet an RIPEMD-160, dem teuersten der drei, sodass ein SHA-256-Aufruf mehr berechnet bekommt, als er verbraucht |
| BN254 ecAdd     | Nahezu 0 CU                           | Günstiger als das Kopieren von 32 Bytes                                                                                                                                                                                                                                                      |
| BN254 ecMul     | \~4.200 CU                            |                                                                                                                                                                                                                                                                                              |
| BN254 ecPairing | \~22.000 CU plus \~12.800 CU pro Paar | Eine Prüfung mit vier Paaren liegt bei etwa 73.000 CU und passt problemlos in eine atomare Transaktion                                                                                                                                                                                       |

Diese Zahlen stammen aus der eigenen Kalibrierung des Programms, die auf einer Testnet-Bereitstellung aus einem Solana-Node gelesene Compute Units verwendet hat. Sie werden für diese Seite nicht neu gemessen; messen Sie Ihren eigenen Aufruf mit `computeUnitsConsumed`.

## Optimierungstechniken

### 1. Verwenden Sie Yul für Hot Paths

Der Optimierer von Solidity erzeugt brauchbaren Code, aber Yul (Inline-Assembly) kann die CU für kritische Operationen deutlich reduzieren:

```solidity
// Vorher: ~600.000 CU
function createPairAccount(bytes32 token0, bytes32 token1) external {
    // Operationen auf Solidity-Ebene
}

// Danach: ~150.000 CU (Yul-Optimierung)
function createPairAccount(bytes32 token0, bytes32 token1) external {
    assembly {
        // Direkte Speicherbearbeitung, den Overhead der ABI-Kodierung überspringen
    }
}
```

### 2. PDA-Ableitungen zwischenspeichern

PDA-Ableitung über `find_program_address` ist teuer. Speichern Sie abgeleitete PDAs im Vertrags-Storage, statt sie bei jedem Aufruf neu zu berechnen:

```solidity
mapping(address => bytes32) private cachedPdas;

function getPda(address user) internal returns (bytes32) {
    bytes32 cached = cachedPdas[user];
    if (cached != bytes32(0)) return cached;

    bytes32 pda = RomeEVMAccount.pda(user);
    cachedPdas[user] = pda;
    return pda;
}
```

### 3. Bekannte Programm-IDs fest codieren

Laden Sie Programm-IDs nicht aus dem Storage — verwenden Sie Konstanten:

```solidity
// Teuer: liest aus dem Storage
bytes32 splTokenProgram = storage_program_id;

// Günstig: Compile-Time-Konstante
bytes32 constant SPL_TOKEN_PROGRAM = 0x06ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9;
```

### 4. Anzahl der Konten minimieren

Jedes Konto in einer Solana-Transaktion erhöht den CU-Overhead. Reduzieren Sie die Anzahl der Konten durch:

* Bündeln von Operationen, die Konten gemeinsam nutzen
* Verwendung weniger Zwischenkonten
* Vermeidung redundanter ATA-Erstellungsprüfungen

### 5. Optimizer-Einstellungen verwenden

```typescript
// hardhat.config.ts — den Optimierer in einem Build-Profil aktivieren
solidity: {
  profiles: {
    default: { version: "0.8.28" },
    production: {
      version: "0.8.28",
      settings: { optimizer: { enabled: true, runs: 200 } },
    },
  },
}
```

Builden mit `npx hardhat compile --build-profile production`.

## CU-Verbrauch messen

`eth_estimateGas` misst keine Compute Units, da eine Gas-Einheit auf Rome einem Lamport Kosten entspricht. Es dimensioniert Ihr Gaslimit. Lesen Sie die Compute Units aus der Solana-Transaktion hinter einem EVM-Hash aus: Holen Sie sich die Signaturen mit `rome_solanaTxForEvmTx`, rufst jede mit Solanas `getTransaction` und `maxSupportedTransactionVersion: 1`, und liest `computeUnitsConsumed`, oder öffnen Sie den Aufruf im Explorer. Ein iterativer Aufruf hat pro Abschnitt eine Transaktion. Um das Gaslimit vor dem Absenden zu bestimmen:

```bash
cast estimate --rpc-url https://hadrian.testnet.romeprotocol.xyz/ \\
  0xCONTRACT "myFunction(uint256)" 42
```

Oder per ethers.js:

```javascript
const gas = await contract.myFunction.estimateGas(42);
console.log("Estimated gas:", gas.toString());
```

## Wie es weitergeht

* [Beschränkungen](https://docs.rome.builders/de/kernkonzepte/constraints.md) — vollständige Liste der Limits und Grenzen


---

# 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/compute-budget.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.
