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

# Бюджет вычислений

Затраты вычислительных единиц Solana (CU) для операций Rome EVM — атомарные и итеративные бюджеты и то, как проектировать контракты Solidity, эффективно использующие CU.

Каждая транзакция Solana имеет бюджет вычислений, измеряемый в вычислительных единицах (CU). Понимание затрат в CU помогает проектировать эффективные контракты Rome.

## Обзор бюджета

| Режим              | Макс. CU                                                         | Примечания                                                                                                        |
| ------------------ | ---------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| Атомарный (VmAt)   | \~1,400,000 CU                                                   | Одна транзакция Solana                                                                                            |
| Итеративный (VmIt) | До \~1,400,000 CU на каждый этап; не более 160 итераций за сеанс | Каждый этап — это отдельная транзакция Solana; адаптивные опкоды/шаг — укладываются в бюджет CU каждой транзакции |

Каждая транзакция Solana имеет бюджет по умолчанию 200,000 CU, который можно расширить примерно до 1.4M CU с помощью инструкций бюджета вычислений (добавляются автоматически SDK Rome).

Итеративное выполнение не является неограниченным. Один сеанс завершается после 160 итераций, а итеративный компоновщик Rust SDK Rome планирует не более 128 этапов. План, который кошелёк подписывает самостоятельно, проходит через `rome_submitSignedV1Plan`, который принимает не более 64 транзакций за вызов. Большинству вызовов требуется гораздо меньше. CPI устаревшего трека отклоняются внутри итеративного сеанса, поэтому вызов, который их использует, должен укладываться в атомарный бюджет. См. [Ретранслируемые вызовы и длинные вызовы](https://docs.rome.builders/ru/rukovodstva-dlya-razrabotchikov/call-evm-from-solana.md#relayed-calls-and-long-calls) и [Ограничения](https://docs.rome.builders/ru/klyuchevye-ponyatiya/constraints.md).

## Оценки затрат CU

### Операции EVM

| Операция                                      | Примерный CU         | Примечания                                                                                                         |
| --------------------------------------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------ |
| Проверка подписи транзакции (канал EVM-ключа) | \~25,000 CU          | Названия `secp256k1_recover` вызов syscall, с той же стоимостью, что и `ecrecover` предварительная компиляция ниже |
| Простой перевод                               | \~50,000-100,000 CU  | Только обновление балансов                                                                                         |
| Перевод ERC-20                                | \~100,000-150,000 CU | Включает вызов SPL precompile                                                                                      |
| Развертывание контракта (малого размера)      | \~200,000-400,000 CU | Зависит от размера байткода                                                                                        |
| Запись в хранилище (SSTORE)                   | \~5,000-20,000 CU    | Холодный и тёплый доступ                                                                                           |

### Операции предварительной компиляции

| Пре-компиляция  | Примерный CU                         | Примечания                                                                                                                                                                                                                                                                             |
| --------------- | ------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ecrecover       | \~25,700 CU                          |                                                                                                                                                                                                                                                                                        |
| SHA-256         | \~257 CU на 32-байтное слово         | Плюс небольшая фиксированная стоимость. Программа оценивает SHA-256, RIPEMD-160 и identity precompile по одной общей ставке примерно 2,200 CU за слово, рассчитанной по RIPEMD-160, самому дорогому из трёх, поэтому за вызов SHA-256 списывается больше, чем он фактически использует |
| BN254 ecAdd     | Почти 0 CU                           | Дешевле, чем копирование 32 байт                                                                                                                                                                                                                                                       |
| BN254 ecMul     | \~4,200 CU                           |                                                                                                                                                                                                                                                                                        |
| BN254 ecPairing | \~22,000 CU плюс \~12,800 CU за пару | Проверка на четыре пары составляет около 73,000 CU, что вполне укладывается в одну атомарную транзакцию                                                                                                                                                                                |

Эти значения получены из собственной калибровки программы, которая использовала вычислительные единицы, считанные с узла Solana при развертывании в testnet. Для этой страницы они не измерялись повторно; измерьте свой вызов с помощью `computeUnitsConsumed`.

## Методы оптимизации

### 1. Используйте Yul для критичных участков

Оптимизатор Solidity генерирует приемлемый код, но Yul (встроенный ассемблер) может значительно снизить CU для критически важных операций:

```solidity
// До: ~600K CU
function createPairAccount(bytes32 token0, bytes32 token1) external {
    // Операции на уровне Solidity
}

// После: ~150K CU (оптимизация Yul)
function createPairAccount(bytes32 token0, bytes32 token1) external {
    assembly {
        // Прямое манипулирование памятью, без накладных расходов на ABI-кодирование
    }
}
```

### 2. Кэшируйте вычисление PDA

Вычисление PDA через `find_program_address` дорогостояще. Храните вычисленные PDA в хранилище контракта, а не вычисляйте их при каждом вызове:

```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. Жёстко задавайте известные идентификаторы программ

Не загружайте идентификаторы программ из хранилища — используйте константы:

```solidity
// Дорого: чтение из хранилища
bytes32 splTokenProgram = storage_program_id;

// Дёшево: константа времени компиляции
bytes32 constant SPL_TOKEN_PROGRAM = 0x06ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9;
```

### 4. Минимизируйте количество аккаунтов

Каждый аккаунт в транзакции Solana добавляет накладные CU-затраты. Сократите количество аккаунтов за счёт:

* Пакетирования операций, использующих общие аккаунты
* Использования меньшего числа промежуточных аккаунтов
* Избежания избыточных проверок создания ATA

### 5. Используйте настройки оптимизатора

```typescript
// hardhat.config.ts — включите оптимизатор в профиле сборки
solidity: {
  profiles: {
    default: { version: "0.8.28" },
    production: {
      version: "0.8.28",
      settings: { optimizer: { enabled: true, runs: 200 } },
    },
  },
}
```

Соберите с помощью `npx hardhat compile --build-profile production`.

## Измерение потребления CU

`eth_estimateGas` не измеряет вычислительные единицы, поскольку одна единица газа в Rome соответствует одному лампорту стоимости. Она определяет ваш лимит газа. Считайте вычисления из транзакции Solana, стоящей за хешем EVM: получите её подписи с помощью `rome_solanaTxForEvmTx`, затем извлеките каждую через `getTransaction` и `maxSupportedTransactionVersion: 1`, и прочитайте `computeUnitsConsumed`, или откройте вызов в обозревателе. Итеративный вызов имеет одну транзакцию на каждый этап. Чтобы определить лимит газа перед отправкой:

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

Или через ethers.js:

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

## Что дальше

* [Ограничения](https://docs.rome.builders/ru/klyuchevye-ponyatiya/constraints.md) — полный список ограничений и границ


---

# 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/ru/klyuchevye-ponyatiya/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.
