> 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/spravochnik/precompiles.md).

# Справочник по прекампилам

Каждый метод прекампилов Solana-interop в Rome — адрес, сигнатура Solidity, селектор и указание, читает ли он, вызывает ли он или подготавливает CPI.

Селекторы, которые on-chain программа Rome вызывает через предкомпилятор. Селектор = `keccak256(signature)[:4]`; каждая строка ниже проверяется по нему. Интерфейсы Solidity находятся в [`rome-solidity/contracts/interface.sol`](https://github.com/rome-protocol/rome-solidity/blob/master/contracts/interface.sol).

**Прежде всего прочитайте столбец Dispatch.** В нём указано, что метод делает со состоянием Solana:

| Диспетчеризация       | Что происходит                                                                                                                                                                                                                                                    | Реальный CPI Solana | Разрешено при итеративном выполнении  |
| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- | ------------------------------------- |
| `Вызов` / `Составной` | Один или несколько CPI, подписанные как external-authority PDA вызывающего, если применимы seeds. В **устаревшей** ветке они выполняются немедленно; в **кешированное** кэшированной ветке они помещаются в промежуточный буфер и фиксируются в конце транзакции. | Да                  | Устаревший: **нет**. Кэшированный: да |
| `EthCall`             | Чистое вычисление или чтение собственного состояния Rome                                                                                                                                                                                                          | Нет                 | Да                                    |
| `CrossStateEthCall`   | Чтение байтов другого аккаунта Solana, предварительно загруженных эмуляцией. Без CPI, без побочных эффектов.                                                                                                                                                      | Нет                 | Да                                    |
| `Предкомпилированный` | Детерминированная криптография (предкомпиляторы по стандарту Ethereum)                                                                                                                                                                                            | Нет                 | Да                                    |

Контракт использует **одну ветку**: либо устаревшие предкомпиляторы (`0xff…07`, `0xff…08`, `0xff…09`, `0x42…16`) либо кэшированные (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`). Смешивание изменяющих вызовов из обоих в одной транзакции отклоняется во время выполнения. Чтения остаются разрешены, за одним исключением: после срабатывания invoke в кэшированной ветке чтения устаревшей ветки отклоняются до конца транзакции. См. [Интеграция программы Solana](https://docs.rome.builders/ru/rukovodstva-dlya-razrabotchikov/integrate-solana-program.md).

**Кто платит.** Плательщик комиссии Solana авансирует каждый лампорт, который расходует CPI устаревшей ветки (rent, переводы, `swap_gas_to_lamports`); программа измеряет баланс плательщика вокруг каждого CPI и списывает пользователю чистый расход как газ по цене газа, возвращая лампорты, которые CPI возвращает.

**Кто подписывает.** Контракт, вызывающий предкомпилятор, действует от своего имени: подписантом является external-authority PDA контракта (`["EXTERNAL_AUTHORITY", contract]`). Собственный PDA пользователя подписывает только транзакцию, которую пользователь отправляет напрямую на адрес предкомпилятора. При `DELEGATECALL` / `CALLCODE`, изменяющие селекторы отклоняются, кроме `create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint` и `create_and_init_mint` в HelperProgram, `create_ata*` в ASplCached, и `invoke` / `invoke_signed` в CpiProgram. Они освобождены, потому что их цель привязана к вызывающему или финансируется оператором, а не потому, что они ничего не подписывают: `create_and_init_mint` по-прежнему подписывает с PDA внешнего вызывающего, чтобы оплатить rent mint'а, и может создать только mint, чьи полномочия принадлежат этому PDA, и `invoke` / `invoke_signed` отклоняют голую authority (`DelegatecallOwnerAuthority`) и помещают salted PDAs в namespace по адресу выполняющегося контракта.

Каждый метод не принимает оплату (`msg.value > 0` откатывается с `TransferProhibited`) кроме `withdrawal(bytes32)`. Методы, помеченные как *только одно состояние* отклоняются в цепочках op-geth-stack. CPI не может указывать плательщика комиссии Solana (кроме как внутри обычной инструкции System transfer) или программу Rome, и не может вызывать программу Rome.

## SystemCached (`0xff00000000000000000000000000000000000004`)

Создание PDA + операции system-program (allocate, assign, lamport transfer), помещаемые в overlay. Cached-эквивалент legacy `System @ 0xff..07`изменяющих селекторов (legacy System сохраняет чисто читающие селекторы).

| Сигнатура Solidity                   | Селектор     | Диспетчеризация | Описание                                                                       |
| ------------------------------------ | ------------ | --------------- | ------------------------------------------------------------------------------ |
| `create_pda()`                       | `0xe0402a8d` | `Вызов`         | Создать PDA вызывающего `external_auth` PDA, освобождённый от rent, без данных |
| `create_pda(uint64)`                 | `0x4ceab657` | `Вызов`         | То же, с лампортами, заданными финансирующей стороной, сверх rent              |
| `create_pda(uint64,bytes32)`         | `0x48e2bb86` | `Вызов`         | PDA, полученный из salt, с лампортами                                          |
| `create_pda(bytes32,uint64,bytes32)` | `0xcc258bbf` | `Вызов`         | Собственник указан явно, размер N, полученный из salt                          |
| `allocate(uint64,bytes32)`           | `0x93225c9f` | `Вызов`         | Выделить N байт на PDA, полученном из salt                                     |
| `assign(bytes32,bytes32)`            | `0x8ac00bdc` | `Вызов`         | Назначить нового владельца для PDA, полученного из salt                        |
| `transfer(address,uint64)`           | `0x5d359fbd` | `Вызов`         | Перевод лампортов на PDA, полученный из EVM-addr                               |
| `transfer(bytes32,uint64)`           | `0xfd54d1ea` | `Вызов`         | Перевод лампортов на сырой pubkey Solana                                       |
| `transfer(bytes32,uint64,bytes32)`   | `0x875abfc0` | `Вызов`         | Перевод лампортов на сырой pubkey, источник, полученный из salt                |

## SplCached (`0xff00000000000000000000000000000000000005`)

Переводы SPL Token / Token-2022 + инициализация ATA + чтение аккаунтов cross-state, помещаемые в overlay.

| Сигнатура Solidity                              | Селектор     | Диспетчеризация     | Описание                                                                                                                                                                                                                                                                                                                                                                                                    |
| ----------------------------------------------- | ------------ | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `transfer(address,uint256)`                     | `0xa9059cbb` | `Вызов`             | Перевод SPL, где вызывающий выступает как владелец, на ATA PDA, полученный из EVM-addr, текущий mint rollup                                                                                                                                                                                                                                                                                                 |
| `transfer(bytes32,uint256)`                     | `0x6a467394` | `Вызов`             | То же, получатель указан как сырой pubkey Solana                                                                                                                                                                                                                                                                                                                                                            |
| `transfer(address,uint256,bytes32)`             | `0x57cfeeee` | `Вызов`             | Вариант с явно указанным mint, назначение EVM-addr                                                                                                                                                                                                                                                                                                                                                          |
| `transfer(bytes32,uint256,bytes32)`             | `0x7db527f9` | `Вызов`             | Вариант с явно указанным mint, назначение сырым pubkey                                                                                                                                                                                                                                                                                                                                                      |
| `transferFrom(address,address,uint256,bytes32)` | `0x401e3367` | `Вызов`             | Вариант с delegated source — authority = `external_auth(caller)`, принимается как владелец ATA ИЛИ делегат с достаточной суммой. Используется в `SPL_ERC20_cached.transferFrom` и потоках, управляемых роутером                                                                                                                                                                                             |
| `approve(address,uint256,bytes32)`              | `0x8180f2fc` | `Вызов`             | Одобрение EVM-spender — owner = `external_auth(caller)`, delegate = `external_auth(spender_addr)`. Используется в `SPL_ERC20_cached.approve`                                                                                                                                                                                                                                                                |
| `mint(address,uint256,bytes32)`                 | `0x1e458bee` | `Вызов`             | Caller-PDA подписывает как mint authority. Runtime SPL требует caller-PDA == on-chain mint authority. Используется в `SPL_ERC20_cached.mint_to` и урегулировании входящего bridge                                                                                                                                                                                                                           |
| `init(bytes32,bytes32,bytes32)`                 | `0x0b0ad508` | `Вызов`             | `InitializeAccount3` ix (ata, mint, owner)                                                                                                                                                                                                                                                                                                                                                                  |
| `account(address)`                              | `0x73b9aa91` | `CrossStateEthCall` | Чтение состояния SPL-аккаунта для ATA, полученного из PDA EVM-addr (текущий mint rollup)                                                                                                                                                                                                                                                                                                                    |
| `account(bytes32)`                              | `0x882358ae` | `CrossStateEthCall` | Чтение состояния SPL-аккаунта для сырого pubkey ATA                                                                                                                                                                                                                                                                                                                                                         |
| `account(address,bytes32)`                      | `0xf9827227` | `CrossStateEthCall` | То же, что `account(address)` с явно указанным mint.                                                                                                                                                                                                                                                                                                                                                        |
| `mint_info(bytes32)`                            | `0xe24bf5d4` | `CrossStateEthCall` | Сведения о mint, с учетом overlay: token program, decimals, **активный** hook program (0, если отсутствует *или* неактивен), fee в bps текущей эпохи и bitmap наличия расширений. Тот же селектор, что и у `HelperProgram.mint_info` — одна возможность, два места dispatch, потому что контракт в кэшированной ветке не может использовать устаревшее чтение после того, как сработал кэшированный invoke. |

## ASplCached (`0xff00000000000000000000000000000000000006`)

Создание Associated Token Account, идемпотентно.

| Сигнатура Solidity            | Селектор     | Диспетчеризация | Описание                                                                   |
| ----------------------------- | ------------ | --------------- | -------------------------------------------------------------------------- |
| `create_ata()`                | `0xb6d336ed` | `Вызов`         | Идемпотентное создание ATA для caller-PDA × текущий mint rollup            |
| `create_ata(bytes32)`         | `0x81972e35` | `Вызов`         | Идемпотентное создание ATA для caller-PDA × явно указанного mint           |
| `create_ata(address)`         | `0x5a7c3259` | `Вызов`         | Идемпотентное создание ATA для PDA, полученного из EVM-addr × текущий mint |
| `create_ata(address,bytes32)` | `0x3de2251a` | `Вызов`         | Идемпотентное создание ATA для EVM-addr × явно указанного mint             |

## WithdrawCached (`0xff0000000000000000000000000000000000000b`)

Этапы вывода gas-token (native gas → SPL wrapper, native gas → SOL, native gas → caller PDA), staged. Cached-эквивалент legacy `Withdraw @ 0x42..16`.

| Сигнатура Solidity            | Селектор     | Диспетчеризация | Описание                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ----------------------------- | ------------ | --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32) payable` | `0x4d8b0ea4` | `Составной`     | Сжигание `msg.value` газа Rome, перевод получателю в системном аккаунте Solana                                                                                                                                                                                                                                                                                                                                                                                        |
| `withdraw_to_pda(uint256)`    | `0x7f3124a0` | `Составной`     | Сжечь wei, зачислить лампорты на `EXTERNAL_AUTHORITY` PDA вызывающего. Только одно состояние.                                                                                                                                                                                                                                                                                                                                                                         |
| `withdraw_to_ata(uint256)`    | `0x8059abc0` | `Составной`     | Сжечь wei, зачислить SPL wrapper на ATA вызывающего, принадлежащий PDA. Только одно состояние. Этап wrap моста gas-wrapper.                                                                                                                                                                                                                                                                                                                                           |
| `deposit(uint256)`            | `0xb6b55f25` | `Составной`     | Обратная операция для `withdrawal` — перевод SPL с ATA вызывающего, принадлежащего PDA, на ATA sol\_wallet цепочки на стороне Solana; **mint** `wei` нативный газ вызывающему на стороне EVM. Чистая эмиссия (без компенсирующего дебета по `Withdraw::ADDRESS` — экономическим обеспечением служит SPL-кошелёк цепочки, а не адрес предкомпилятора). Только одно состояние. Этап unwrap моста gas-wrapper. Соответствует `HelperProgram.deposit_from_ata` семантике. |

## System (`0xff00000000000000000000000000000000000007`)

Получение PDA + преобразование в base58 + утилиты идентификационного типа. Предкомпилятор только для чтения — каждый метод `EthCall` (без побочных эффектов в Solana).

| Сигнатура Solidity                                | Селектор     | Диспетчеризация | Описание                                                                     |
| ------------------------------------------------- | ------------ | --------------- | ---------------------------------------------------------------------------- |
| `find_program_address(bytes32,(bytes)[])`         | `0x27e3edda` | `EthCall`       | Solana `find_program_address` через syscall — возвращает `(pda, bump)`       |
| `create_program_address(bytes32,(bytes)[],uint8)` | `0xb99f29e1` | `EthCall`       | Получение PDA за постоянное время с известным bump                           |
| `rome_evm_program_id()`                           | `0xb76fd45b` | `EthCall`       | Возвращает Solana program ID этой Rome EVM программы                         |
| `program_id()`                                    | `0x77764881` | `EthCall`       | Возвращает System Program ID Rome (идентичность этого предкомпилятора)       |
| `mint_id()`                                       | `0xe132a122` | `EthCall`       | Возвращает pubkey mint SPL для gas-token цепочки (`OwnerInfo.chain_mint_id`) |
| `operator()`                                      | `0x570ca735` | `EthCall`       | Возвращает Solana-подписанта внешней транзакции Rome                         |
| `bytes32_to_base58(bytes32)`                      | `0xfa2b1a5f` | `EthCall`       | Байты pubkey → строка base58                                                 |
| `base58_to_bytes32(bytes)`                        | `0x5df01b72` | `EthCall`       | строка base58 → байты pubkey                                                 |

## CpiProgram (`0xff00000000000000000000000000000000000008`)

**Предкомпилятор двойного назначения.** Из 7 селекторов ниже, **2 выполняют реальный CPI Solana** (`invoke`, `invoke_signed` — вызываются как `Вызов`) и **5 являются чистыми cross-state чтениями** (`account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` — вызываются как `CrossStateEthCall`, без syscall, без `found_cpi` флага). Исторический термин "CPI shortcut selectors" относился к селекторам чтения как к экономящим CU заменам более ранних CPI-based чтений — сами они **не являются CPI**. См. таблицу неоднозначностей в начале этого раздела для полной матрицы поведения.

| Сигнатура Solidity                                             | Селектор     | Диспетчеризация     | Описание                                                                                                                                                                                                                                                     |
| -------------------------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `invoke(bytes32,(bytes32,bool,bool)[],bytes)`                  | `0x7480cb86` | `Вызов`             | CPI, подписанный как `EXTERNAL_AUTHORITY(caller)` когда этот аккаунт указан как signer (отклоняется при DELEGATECALL); без salted sub-PDA. Вызывающий передаёт целевую программу + account metas + данные ix                                                 |
| `invoke_signed(bytes32,(bytes32,bool,bool)[],bytes,bytes32[])` | `0xb94f3733` | `Вызов`             | CPI, подписанный как `EXTERNAL_AUTHORITY(caller)` при прямом CALL; salts добавляются к seed каждого PDA. При DELEGATECALL голая authority вызывающего отклоняется, а salted seeds содержат адрес выполняющегося контракта — см. примечание по получению ниже |
| `account_info(bytes32)`                                        | `0xc13465d9` | `CrossStateEthCall` | Чтение полного состояния аккаунта Solana (lamports/owner/flags/data)                                                                                                                                                                                         |
| `account_data_at(bytes32,uint16,uint16)`                       | `0x593762e8` | `CrossStateEthCall` | Чтение среза буфера данных любого аккаунта Solana                                                                                                                                                                                                            |
| `account_u64_at(bytes32,uint16)`                               | `0xb317d4c1` | `CrossStateEthCall` | Типизированное чтение u64 LE по известному смещению — экономит ABI roundtrip                                                                                                                                                                                 |
| `account_lamports(bytes32)`                                    | `0xde79ed54` | `CrossStateEthCall` | Проверка только lamports — без выборки данных                                                                                                                                                                                                                |
| `pdas_batch_derive(bytes[][],bytes32)`                         | `0x944336f8` | `CrossStateEthCall` | N независимых PDA для одной программы за один dispatch                                                                                                                                                                                                       |

## HelperProgram (`0xff00000000000000000000000000000000000009`)

Пользовательские помощники Rome для создания ATA/PDA, SPL-переводов/approve/mint, подписанные `EXTERNAL_AUTHORITY` PDA вызывающего, конвертации gas↔lamports, ATA-deposit и чтений, доступных через SPL\_ERC20 (`user_balance` / `allowance_of`). Каждый метод `не принимает оплату`; изменение проходит через `Вызов` (один CPI), кроме `deposit_from_ata` (`Составной`, только одно состояние), трёх методов только для чтения `pda`/`ata` запросов (`EthCall`), и двух cross-state чтений SPL\_ERC20 (`CrossStateEthCall` — одна выборка аккаунта Solana.

| Сигнатура Solidity                                               | Селектор     | Диспетчеризация     | Описание                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ---------------------------------------------------------------- | ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `create_ata(address)`                                            | `0x5a7c3259` | `Вызов`             | Создать ATA для EVM-пользователя под gas mint цепочки                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `create_ata(address,bytes32)`                                    | `0x3de2251a` | `Вызов`             | Создать ATA для EVM-пользователя под произвольный mint                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `create_ata_for_key(bytes32,bytes32)`                            | `0xd258a69d` | `Вызов`             | Идемпотентное создание ATA для любого сырого pubkey Solana как владельца (не полученного через `external_auth`). Rent оплачивает оператор. Используется в `SPL_ERC20.bridgeOutToSolana` / `ensureRecipientAta` / `create_token_account` потоках с получателем по сырому pubkey                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `create_pda(address)`                                            | `0xff3556ca` | `Вызов`             | Создать PDA пользователя `EXTERNAL_AUTHORITY` PDA (не облагается арендой)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `create_pda(address,uint64)`                                     | `0x58e88298` | `Вызов`             | То же, но профинансировано на `лампортов` сверх порога аренды                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `swap_gas_to_lamports(uint64)`                                   | `0x6e3f24e0` | `Вызов`             | Зачислить на PDA вызывающей стороны `n` лампортов из плательщика комиссии Solana транзакции; вызывающая сторона оплачивает их газом Rome (расход лампортов плательщика в любом legacy CPI добавляется к комиссии транзакции)                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `transfer_lamports(address,uint64)`                              | `0x5fe71665` | `Вызов`             | Перевести лампорты из PDA вызывающей стороны в PDA другого пользователя EVM                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `transfer_spl(address,uint64)`                                   | `0xb12be5ba` | `Вызов`             | Отправить SPL chain-gas из ATA PDA вызывающей стороны в ATA пользователя-получателя                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `transfer_spl(bytes32,uint64)`                                   | `0xba3a5eac` | `Вызов`             | Отправить SPL chain-gas из ATA PDA вызывающей стороны в явный ATA                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `transfer_spl(address,uint64,bytes32)`                           | `0x53b505e0` | `Вызов`             | Отправить SPL с произвольным mint из ATA PDA вызывающей стороны в ATA пользователя-получателя                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `transfer_spl(bytes32,uint64,bytes32)`                           | `0xb6977879` | `Вызов`             | Отправить SPL с произвольным mint из ATA PDA вызывающей стороны в явный ATA                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `transfer_spl(bytes32,bytes32,uint64,bytes32)`                   | `0x766b362a` | `Вызов`             | Вариант с делегатом — вызывающая сторона указывает `src_ata` (должен принадлежать PDA ИЛИ PDA должен быть делегатом с достаточным `delegated_amount`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `transfer_spl(address,address,uint64,bytes32)`                   | `0xe479df56` | `Вызов`             | Вариант с делегатом, привязанный к адресу — внутренне выводит оба ATA из EVM-адресов. Подписывает как `external_auth(caller)`; SPL Token принимает PDA как владельца ИЛИ делегата. Используется для `SPL_ERC20.transferFrom`                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `transfer_spl_to_signer(uint64,bytes32)`                         | `0x46efa679` | `Вызов`             | Солана-нативный выходной этап. Отправляет `сумму` из `mint` из ATA PDA вызывающей стороны в **ATA внешнего подписанта Solana** для данного mint (собственный кошелек пользователя — только на lane Solana, подписанной кошельком; из MetaMask или через relay подписантом является прокси-плательщик Rome; преобразование EVM-адреса не выполняется). Одобрение не требуется — PDA вызывающей стороны владеет исходным ATA. Используйте вместе с `ActivateAta` (слот 18) для сквозного использования EVM только с ключами Solana. Это работает для кошелька на текущем lane v1 и на более старом legacy `DoTxUnsigned` (слот 17), поскольку кошелек подписывает транзакцию Solana в обоих случаях. |
| `approve_spl(address,uint64,bytes32)`                            | `0xabf6f675` | `Вызов`             | PDA вызывающей стороны как владелец устанавливает `delegate_pda(spender)` в owner-ATA через SPL `approve_checked`. Используется в `SPL_ERC20.approve`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `approve_spl_raw_delegate(bytes32,bytes32,uint64,bytes32,uint8)` | `0x7881d453` | `Вызов`             | SPL `approve_checked` с делегатом в виде необработанного открытого ключа, предоставленным вызывающей стороной (например, Wormhole `authority_signer` PDA, без эквивалента EVM-адреса). Вызывающая сторона передает `десятичные знаки` чтобы пропустить чтение mint в цепочке (\~экономия 30–50 тыс. CU). Зашитое `spl_program = SPL Token`. Используется в `RomeBridgeWithdraw.approveBurnETH`                                                                                                                                                                                                                                                                                                     |
| `mint_spl(address,uint64,bytes32)`                               | `0xd795522b` | `Вызов`             | PDA вызывающей стороны как authority mint выполняет mint в ATA пользователя-получателя через SPL `mint_to_checked`. Среда выполнения SPL принудительно проверяет совпадение authority. Используется для `SPL_ERC20.mint_to`                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `create_mint_account(bytes32)`                                   | `0xe97d3291` | `Вызов`             | System CreateAccount, выделяющий PDA, производный от salt (`external_auth_with_salt(caller, salt)`) с пространством=82, принадлежащий SPL Token. Инициатор финансирования = внешний\_auth PDA вызывающей стороны. Два PDA-подписанта. Используется для `ERC20SPLFactory.create_token_mint`                                                                                                                                                                                                                                                                                                                                                                                                         |
| `init_spl_mint(bytes32,uint8,bytes32,bool,bytes32)`              | `0x4f75e987` | `Вызов`             | SPL Token `InitializeMint2` для предварительно выделенного mint. Нет подписанта PDA (mint\_authority/freeze\_authority хранятся как данные, а не как подписанты во время выполнения). Используется для `ERC20SPLFactory.init_token_mint`                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `create_and_init_mint(uint8,bytes32,bool,bytes32,bytes32)`       | `0x20972d0f` | `Составной`         | Объединено: System CreateAccount + SPL InitializeMint2 в одном диспетче. Экономит 1 оболочку Rome DoTx по сравнению с отдельными `create_mint_account` + `init_spl_mint` вызовами                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `deposit_from_ata(uint256)`                                      | `0x4479b709` | `Составной`         | Извлечь SPL из ATA вызывающей стороны в нативный gas Rome. **Только одиночное состояние** — отклоняется в цепочках op-geth                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `pda(address)`                                                   | `0x8854a299` | `EthCall`           | Вывести PDA пользователя `EXTERNAL_AUTHORITY` — только для чтения                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `pda_with_salt(address,bytes32)`                                 | `0x5c6d04b3` | `EthCall`           | PDA, производный от salt `EXTERNAL_AUTHORITY` PDA в одном диспетче. Сводит воедино 2-вызовную композицию на стороне Solidity `rome_evm_program_id() + find_program_address()` композиции. Используется для `RomeEVMAccount.pda_with_salt`, `RomeBridgeWithdraw.{burnUSDC,burnETH}`                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `ata(address)`                                                   | `0x31db4f82` | `EthCall`           | Вывести `getATA(user_pda, chain_mint_id)` — сочетает EXT\_AUTH + ATA — только для чтения                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `ata(address,bytes32)`                                           | `0xfeb1c647` | `EthCall`           | То же, но с явным mint — только для чтения                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `user_balance(address,bytes32)`                                  | `0xdd0119c8` | `CrossStateEthCall` | Прочитать ATA пользователя `сумму` (смещение 64 в SPL TokenAccount). Возвращает 0, если ATA не существует (проверка новой цепочки). Сводит 3 диспетчеризации v1. Используется для `SPL_ERC20.balanceOf`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `mint_info(bytes32)`                                             | `0xe24bf5d4` | `CrossStateEthCall` | Сведения о mint для вызывающего legacy-трека: программный токен, decimals, **активный** hook program (0, если отсутствует *или* (инертный), текущие bps комиссии эпохи, bitmap наличия расширений. Отражено в `SplCached` по тому же селектору. `feeBps` является **предикатом** — он указывает, что комиссия активирована; это не операнд, поскольку фактическая комиссия ограничена `maximum_fee` который здесь намеренно не включен.                                                                                                                                                                                                                                                            |
| `allowance_of(address,address,bytes32)`                          | `0xed72dbc8` | `CrossStateEthCall` | Прочитать delegated\_amount owner-ATA с **проверкой равенства делегата** — возвращает 0, если on-chain delegate == `external_auth(spender)`. Семантически корректно для ERC-20 (ОБЯЗАТЕЛЬНОЕ ТРЕБОВАНИЕ). Используется для `SPL_ERC20.allowance`                                                                                                                                                                                                                                                                                                                                                                                                                                                   |

## Вывод (`0x4200000000000000000000000000000000000016`)

нативный вывод газа Rome → Solana.

| Сигнатура Solidity         | Селектор     | Диспетчеризация         | Описание                                                                                                                 |
| -------------------------- | ------------ | ----------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `withdrawal(bytes32)`      | `0x4d8b0ea4` | `Составной` (`payable`) | Сжигание `msg.value` gas Rome; mint+transfer на системный аккаунт Solana `в`. Единственный оплачиваемый метод precompile |
| `withdraw_to_pda(uint256)` | `0x7f3124a0` | `Составной`             | Сжечь gas; внести на PDA вызывающей стороны. `EXTERNAL_AUTHORITY` PDA. **Только одиночное состояние**                    |
| `withdraw_to_ata(uint256)` | `0x8059abc0` | `Составной`             | Сжечь gas; внести на `getATA(caller_pda, chain_mint_id)`. **Только одиночное состояние**                                 |


---

# 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/spravochnik/precompiles.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.
