> 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/rukovodstva-dlya-razrabotchikov/call-evm-from-solana.md).

# Вызов EVM из Solana

Позвольте кошельку Solana управлять EVM-контрактами в Rome — без Ethereum-ключа. Кошелёк подписывает, а транзакция отправляется в Solana.

Обратная сторона [Вызов Solana из EVM](https://docs.rome.builders/ru/rukovodstva-dlya-razrabotchikov/call-solana-from-evm.md): кошелёк Solana (например, Solflare) напрямую вызывает любой EVM-контракт в Rome, без **ключа Ethereum**. Так [Aerarium](https://docs.rome.builders/ru/prilozheniya-v-rome/apps.md) позволяет нативным пользователям Solana использовать те же контракты, что и пользователи EVM.

Способ с одним вызовом — это `submitRomeTxV1`, при котором прокси формирует одну транзакцию Solana v1 для вызова; на этой странице объясняется механизм.

## Синтетические адреса

EVM-идентичность кошелька Solana — это его **синтетический адрес** — последние 20 байт `keccak256` хэша его 32-байтного открытого ключа Solana:

```
synthetic_evm_address = keccak256(solana_pubkey)[12:]
```

Это `msg.sender` адрес, с которого кошелёк вызывает контракт, и постоянная идентичность, под которой хранятся его nonce и состояние. Способ вывода закреплён в протоколе, поэтому кошелёк всегда сопоставляется с одним и тем же адресом.

```javascript
import { syntheticAddress } from "@rome-protocol/sdk";
const from = syntheticAddress(solanaPubkey); // 0x… 20 bytes
```

## Синтетический адрес — это промежуточный адрес: в простое он не хранит токены

Расходуемый баланс нативного пользователя Solana находится в его **кошелька Solana** (в виде SPL-токенов), а на стороне EVM отображается 1:1 как **ERC20SPL wrapper** (например, `wUSDC`). В простое синтетический адрес ничего не хранит, поэтому стоимость проходит *через* него — каждый этап подписан кошельком Solana:

1. **Подготовка (один раз).** У совершенно нового синтетического адреса PDA внешней авторизации не существует, пока `create_pda` не будет выполнена эта процедура — и нижеприведённые переводы подписываются этим PDA. `submitRomeTxSolanaLane` настраивает его автоматически при первом использовании (или вызовите `provisionSynthetic` для явного шага «Activate»; проверяйте с помощью `isSyntheticProvisioned`). С `submitRomeTxV1`, проверьте `isSyntheticProvisioned` и отправьте `buildCreatePdaCall` через него один раз.
2. **Этап пополнения (кошелёк → синтетический адрес).** Переместите токен из ATA кошелька в ATA синтетического адреса — `ActivateAta` этап, формируемый `buildFundLeg`. Теперь `wrapper.balanceOf(synthetic)` считывает этот баланс, поэтому синтетический адрес расходует его как обычный ERC-20 (`transfer` / `transferFrom`) — **не** как нативный `msg.value`, которым он не владеет.
3. **Вызов(ы) (`DoTxUnsigned`).** Синтетический адрес выполняет EVM-транзакцию(и) — например, `approve` затем хранилище `депозит` который подтягивает через `transferFrom`.
4. **Этап возврата (синтетический адрес → кошелёк).** После того как вывод / заём / получение размещает токены на синтетическом адресе, `buildSweepLeg` он отправляет их обратно в собственный ATA кошелька пользователя (`HelperProgram.transfer_spl`), так что итоговый баланс синтетического адреса равен нулю.

В следующем разделе описано, что старый `submitRomeTxSolanaLane` формирует на стороне клиента. `submitRomeTxV1` вместо этого просит прокси сформировать транзакцию v1, без обнаружения аккаунтов, ComputeBudget или treasure wallet в вашем коде; см. [внешние конечные точки V1](#the-external-v1-endpoints) ниже.

## Как формируется вызов

`submitRomeTxSolanaLane` выполняет всё это. Механика:

1. **Постройте неподписанную транзакцию EIP-1559** с `из` = синтетического адреса — без подписи secp256k1.
2. **Обнаружение аккаунтов** — вызовите [`rome_emulateCallAccounts`](https://docs.rome.builders/ru/spravochnik/json-rpc.md) с `из`, `в`, `data`, **и `value`** (когда вызов payable). Передача `value` имеет значение: прокси эмулирует *реальный* вызов, поэтому любая запись в состояние, зависящая от value — например, новый слот mapping — выделяется, и возвращается соответствующий аккаунт Solana. Пропустите его, и этого аккаунта не будет, а транзакция завершится ошибкой *"instruction modified data of a read-only account."*
3. **Соберите транзакцию Solana:** две **ComputeBudget** инструкции (EVM Rome требует повышенный лимит CU ≈1,35 млн и большой heap frame ≈250 КБ — стандартные значения Solana приводят к сбою) + **`DoTxUnsigned`** инструкцию (неподписанный RLP + обнаруженные аккаунты) + цепочечный **казначейский кошелёк** (за выполнение ему выплачивается небольшая комиссия; при обнаружении он не включается, поэтому SDK добавляет его).
4. **Кошелёк подписывает и отправляет.** Названия **Кошелёк Solana подписывает транзакцию Solana (Ed25519) и отправляет её в Solana RPC — не в прокси.** Среда выполнения Solana проверяет подпись; в блокчейне программа выводит `msg.sender` из этого подписанта. Полномочие подтверждается подписью Solana, а не Ethereum. (Прокси используется только для эмуляции/обнаружения на шаге 2.)

PDA пользователя (`["EXTERNAL_AUTHORITY", synthetic_address]`) владеет их токен-аккаунтами и подписывает SPL CPI от их имени — поэтому пользователь Solana может полностью из своего кошелька Solana выполнять supply, borrow, swap и LP.

## Внешние конечные точки V1

`submitRomeTxV1` — это способ с одним вызовом: он запрашивает у прокси сформированную транзакцию v1, проверяет её, даёт кошельку подписать её и отправляет в Solana RPC, а если вызов не помещается, передаёт его через прокси. Прокси предоставляет тот же канал через методы RPC, поэтому любой клиент может использовать его без SDK (полный список в [Поддержка JSON-RPC](https://docs.rome.builders/ru/spravochnik/json-rpc.md)):

* `rome_composeUnsignedAtomicV1(rlp, pubkey, signature)` — одна транзакция Solana v1; кошелёк подписывает её, а приложение транслирует её в Solana RPC. Отклоняется, если вызов не помещается в одну атомарную транзакцию.
* `rome_composeUnsignedIterativeV1(rlp, pubkey, signature)` — каждый этап выполнения (атомарный, если помещается, иначе итеративные этапы); кошелёк подписывает каждый, `rome_submitSignedV1Plan` транслирует их. Ограничения для длинного плана указаны в [Ретранслируемые вызовы и длинные вызовы](#relayed-calls-and-long-calls).
* `rome_relayUnsignedV1(rlp, pubkey, signature)` — одна подпись кошелька, плательщик прокси выполняет этапы и возвращает хэш EVM-транзакции; синтетический адрес оплачивает gas в Rome, поэтому один раз пополните его с помощью `rome_composeExternalDepositV1`.

**Подписывающая авторизация.** `rlp` — это «голое» неподписанное тело EIP-1559 из 9 полей. Кошелёк подписывает своим ключом Ed25519 либо сырые 32 байта `keccak256(0x02 ‖ rlp)` либо читаемое сообщение

```
Авторизация Rome
0x<64 lowercase hex chars of that hash>
```

Оба варианта принимаются; читаемая форма — это то, что кошелёк отображает разборчиво в своём `signMessage` окне запроса. Программа пересчитывает хэш по телу, которое она выполняет, и требует, чтобы подписанное сообщение в точности соответствовало одной из двух форм, поэтому подпись для одного тела никогда не может авторизовать другое, а nonce тела предотвращает повторное воспроизведение.

## Ретранслируемые вызовы и длинные вызовы

Некоторые вызовы не помещаются в одну транзакцию Solana. В этом разделе описано, что происходит в таком случае и какие ограничения применяются.

### Когда атомарный компоновщик отказывает

`rome_composeUnsignedAtomicV1` отказывает в вызове, который не помещается в одну атомарную транзакцию. `submitRomeTxV1` затем передаёт вызов через прокси с той же **той же** подписью авторизации, поэтому у кошелька не запрашивается подпись повторно. Результат содержит `route: "relay"` и не содержит Solana `подписи`. Передайте `relayOnRefusal: false` чтобы вместо этого получить отказ как ошибку, или вызовите `relayV1` самостоятельно, если хотите передавать через прокси намеренно.

Три важных момента о переданном через прокси вызове:

* **Синтетический адрес оплачивает gas.** На маршруте relay прокси отправляет и оплачивает транзакции Solana, а вызов оплачивается нативным газовым токеном сети из баланса синтетического адреса. Баланс должен быть не меньше `gasLimit × maxFeePerGas`. `fundSyntheticGas(deps, amountWei)` пополняет его из собственного токен-аккаунта кошелька с газовым токеном сети (USDC в Hadrian и Rubicon); кошелёк подписывает одну обычную транзакцию v1 и нуждается в небольшом количестве SOL для комиссии Solana. `amountWei` указан в wei сети с 18 знаками после запятой и должен быть кратен 10^12, иначе прокси отклонит его. Без SDK `rome_composeExternalDepositV1` строится та же транзакция.
* **Revert не вызывает исключение.** Вызов, переданный через relay и завершающийся revert на стороне EVM, разрешается нормально, с `receipt.status === "0x0"`receipt `receipt?.status === "0x1"` перед тем как считать вызов завершённым. `receipt` равен `null` если receipt не появился вовремя.
* **`relayOnRefusal: false` — это выбор, сделанный в SDK, а не ограничение.** Прокси уже хранит подпись авторизации для этой полезной нагрузки и может выполнить её любым из путей, вплоть до `gasLimit × maxFeePerGas`.

```javascript
const res = await submitRomeTxV1(deps, { to, data, value });
if (res.route === "relay" && res.receipt?.status !== "0x1") {
  // вызов, переданный через relay и завершившийся revert, разрешается; он не бросает исключение
}
```

### Длинные вызовы

Вызов, которому требуется более одной транзакции, выполняется как итеративная сессия: программа выполняет столько шагов EVM, сколько помещается в каждую транзакцию Solana, и сохраняет своё состояние между ними. Два способа запускать это из кошелька Solana:

* **Передать через relay.** `rome_relayUnsignedV1` требует одной подписи кошелька, а плательщик прокси отправляет каждый этап. Синтетический адрес оплачивает gas, как указано выше.
* **Подпишите этапы самостоятельно.** `rome_composeUnsignedIterativeV1` возвращает каждый этап с пустым полем подписи, кошелёк подписывает каждый из них, и `rome_submitSignedV1Plan` транслирует их по порядку. Каждый этап — это отдельная транзакция Solana, которую кошелёк должен подписать, поэтому кошелёк, подписывающий по одной транзакции за раз, запрашивает подпись для каждого этапа отдельно, помимо подписи авторизации. Кошелёк оплачивает комиссию Solana на каждом этапе.

Ограничения:

| Лимит                                                         | Значение        | Откуда это берётся                                                                                                           |
| ------------------------------------------------------------- | --------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Транзакции в одном `rome_submitSignedV1Plan` вызове           | 64              | Прокси отклоняет более длинный план                                                                                          |
| Количество этапов, которое спланирует итеративный компоновщик | 128             | Лимит в итеративном компоновщике Rust Rome SDK, который также ограничивает план `rome_composeUnsignedIterativeV1` возвращает |
| Итераций в одной сессии                                       | 160             | программы Rome EVM; после него сессия перестаёт возобновляться, освобождает блокировки аккаунтов и завершается               |
| Размер транзакции Solana и аккаунты                           | 4 КБ, 64 адреса | Каждый этап — транзакция Solana v1                                                                                           |

Большинство реальных вызовов укладываются в значительно меньшее число этапов, чем эти лимиты. Ограничение в 64 транзакции для плана, подписываемого кошельком, — это первое, с которым вы столкнётесь. Вызов, которому требуется больше этапов, нельзя транслировать через `rome_submitSignedV1Plan`.

Длинный вызов не может выполнять CPI legacy-track. Изменяющие вызовы в legacy precompiles (`0xff…08`, `0xff…09` и `0x42…16`) отклоняются в итеративной сессии с `CpiProhibitedInIterativeTx`. Чтение состояния Solana и precompiles cached-track (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`) работают. Вызов, который выполняет CPI legacy-track, должен поместиться в одну атомарную транзакцию, независимо от канала отправки. См. [Ограничения](https://docs.rome.builders/ru/klyuchevye-ponyatiya/constraints.md) и [Бюджет вычислений](https://docs.rome.builders/ru/klyuchevye-ponyatiya/compute-budget.md).

## Референсные реализации

* **Aerarium** — управляет Compound v3 (supply / borrow) из кошелька Solana через `DoTxUnsigned`. Это референс для более старого канала legacy-transaction, описанного выше, а не для `submitRomeTxV1`.
* **Rome DEX** не является примером для этой страницы: его сторона Solana — это нативная программа Solana, для которой кошелёк подписывает напрямую, а его сторона EVM использует тот же пул.

Aerarium не требует второго кошелька — синтетический адрес делает один ключ Solana полноценным EVM-аккаунтом. Для шаблона v1 см. [Сборка приложения с двумя дорожками](https://docs.rome.builders/ru/rukovodstva-dlya-razrabotchikov/dual-lane-app.md).

## Что дальше

* [Вызов Solana из EVM](https://docs.rome.builders/ru/rukovodstva-dlya-razrabotchikov/call-solana-from-evm.md) — обратное направление, через CPI
* [Интероперабельность токенов](https://docs.rome.builders/ru/klyuchevye-ponyatiya/token-interop.md) — как баланс распределяется между EVM и Solana


---

# 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/rukovodstva-dlya-razrabotchikov/call-evm-from-solana.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.
