> 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/integrate-solana-program.md).

# Интеграция программы Solana

Интеграция программы Solana с Rome EVM — кто является подписантом Solana, как значение попадает в вашу программу и возвращается обратно, правило единого маршрута, атомарный и итеративный режимы, а также выделение аккаунтов.

Это руководство предназначено для команды программы Solana, которая хочет, чтобы пользователи Rome EVM использовали их программу — программу приватности, кредитования или хранилища, которая должна удерживать ценность для счетов EVM. Оно основано на [Вызов Solana из EVM](https://docs.rome.builders/ru/rukovodstva-dlya-razrabotchikov/call-solana-from-evm.md) (механике препкомпилированных вызовов) и отвечает на вопросы, которые возникают, когда на другой стороне уже находится реальная программа: *кто* подписывает, *как* токены поступают и выводятся, и *какие* ограничения определяют архитектуру.

Используемый здесь поток: счет EVM перемещает USDC в вашу программу («shield» или «deposit»), ваша программа хранит его для этого пользователя и позже возвращает его обратно («unshield» или «withdraw»). Замените глаголы на свои.

## 1. Каждый адрес EVM имеет одну идентичность Solana

Rome выводит счет Solana для каждого адреса EVM — и пользователей, и контрактов — называемый его **внешним полномочием**:

```
external_auth(addr) = find_program_address(["EXTERNAL_AUTHORITY", addr_h160], rome_evm_program_id)
```

Он владеет ассоциированными токен-счетами этого адреса (то есть тем местом, где `wUSDC.balanceOf(addr)` читает данные) и это ключ, который подписывает CPI, совершаемые от имени этого адреса. Ваша программа видит 32-байтный публичный ключ Solana; H160 она никогда не видит.

**Кто подписывает, определяется тем, кто вызывает препкомпилированный вызов:**

| Препкомпилированный вызов вызывается                                                                  | Подписывающий Solana                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ----------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Приложение **контрактом**, при обычном `CALL`                                                         | Названия **собственным** внешним полномочием (`external_auth(contract)`), а также любыми под-PDA контракта с солью, которые он запрашивает                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Приложение **пользователя**, в транзакции, отправленной напрямую на адрес препкомпилированного вызова | Названия **собственным** внешним полномочием                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Контракт через `DELEGATECALL`                                                                         | Голое полномочие отклоняется (`DelegatecallOwnerAuthority`). `invoke` без подписанта, а `invoke_signed` с под-PDA с солью все же выполняется — но эти sub-PDA именуются в пространстве адреса выполняющегося контракта (`["EXTERNAL_AUTHORITY", caller, running_contract, salt]`), поэтому `pda_with_salt` не выводит их. В HelperProgram проходят только селекторы создания и финансирования (`create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint`, `create_and_init_mint`); они исключены, потому что их цель привязана к вызывающему или финансируется оператором, а не потому, что они ничего не подписывают |

Следствие — уже знакомое вам правило ERC-20: **контракт не может самостоятельно перемещать активы пользователя.** Он действует как собственная идентичность, и сначала пользователь предоставляет ему права. Для токенов, которые должны перемещаться на стороне Solana, это предоставление прав является SPL-делегацией на токен-счете пользователя; ERC-20- `approve` — это лишь разрешение на стороне EVM, которое учитывают собственные переводы обертки. Именно так работают собственные токенные обертки Rome, и так будет работать ваш адаптер (раздел 3).

Под-PDA с солью: `invoke_signed` принимает список `bytes32` солей bytes32, и Rome подписывает с помощью `["EXTERNAL_AUTHORITY", caller_h160, salt]` для каждой (с добавленным bump; при прямом вызове вызывающим является контракт). `HelperProgram.pda_with_salt(addr, salt)` возвращает адрес из Solidity. Используйте одну соль на пользователя (например, адрес пользователя), когда вашей программе нужен отдельный счет-владелец для каждой позиции.

Финансирование: PDA внешнего полномочия не обязано существовать, чтобы владеть ATA (`create_ata` идемпотентна, а плательщик комиссии Solana в транзакции покрывает аренду). Он должен существовать и хранить lamports только тогда, когда он финансирует счета, создаваемые вашей инструкцией. `HelperProgram.create_pda(addr)` создает его как обычный System `CreateAccount`, поэтому вызывайте его один раз; он не является идемпотентным. `swap_gas_to_lamports(n)` зачисляет на PDA адреса `n` lamports от плательщика комиссии Solana в транзакции, а вызывающий оплачивает их газом Rome: влияние каждого CPI в legacy-потоке на баланс плательщика комиссии прибавляется к комиссии транзакции и списывается с пользователя по цене газа, так же как взимается аренда за счета, создаваемые CPI. Шаг предоставления ресурсов для Solana-канала описан в [Вызов EVM из Solana](https://docs.rome.builders/ru/rukovodstva-dlya-razrabotchikov/call-evm-from-solana.md); контракт подготавливает собственный PDA в конструкторе или при первом вызове.

## 2. Три способа хранить позицию пользователя

**A. Контракт-адаптер (рекомендуется для повторно используемого адаптера).** Один контракт Solidity выступает фронтендом вашей программы. Пользователь предоставляет полномочию адаптера SPL-делегацию на своем токен-счете; адаптер забирает токены на токен-счет, которым владеет, вызывает вашу программу от своего имени и идентифицирует позицию пользователя внутри вашей программы через под-PDA на пользователя либо через идентификатор, который передает в данных инструкции. На выходе он поручает вашей программе перевести средства на собственный токен-счет пользователя. Адаптер — это единственная идентичность Solana, которую вашей программе нужно знать. Это предоставление прав — SPL-делегация, а не ERC-20 `approve`; в разделе 3 объясняется, почему это так и что это стоит пользователю.

**B. Пользователь как подписант Solana.** Фронтенд отправляет транзакцию от EVM-счета пользователя **напрямую в препкомпилированный вызов CpiProgram** (`to = 0xff…08`, calldata = ABI-кодированные `invoke` или `invoke_signed`), поэтому подписывает собственное внешнее полномочие пользователя, а ваша программа привязывает к нему позицию. Никакого контракта-адаптера и никакой делегации, но каждое действие — это непрозрачная транзакция calldata в кошельке, а все, что процессу нужно помимо CPI (ATA, предварительный перевод), оформляется отдельной транзакцией. Это подходит для разовых предоставлений прав (пользовательский `approve_spl` обертке) и для простых программ, но не для многошаговых процессов. [Cardo](https://github.com/rome-protocol/cardo) использует эту схему: его фронтенд отправляет `invoke` прямо в препкомпилированный вызов из кошелька пользователя.

**C. Маршрутизатор без хранения активов.** Контракт, который никогда не хранит токены пользователя. Пользователь предоставляет полномочию маршрутизатора SPL-делегацию на своем токен-счете; маршрутизатор выполняет CPI в вашу программу, используя это полномочие как authority для перевода, так что токены перемещаются с токен-счета пользователя на счет вашей программы (или обратно пользователю), а маршрутизатор ничего не удерживает между вызовами. Маршрутизатор выводит каждый пользовательский счет из `msg.sender`, поэтому предоставление прав одного пользователя нельзя направить на счет другого пользователя, и он вызывает одну фиксированную программу с фиксированными формами инструкций, а не выступает в роли общего `invoke` посредника. `RomeDexRouter` в [rome-dex](https://github.com/rome-protocol/rome-dex) написан именно так; EVM-канал rome-dex также предлагает прямой необработанный `invoke` вариант формы B. Ему требуется то же предоставление прав, что и в A, с той же ценой одного делегата (раздел 3), и без шага забора.

Остальная часть этого руководства следует варианту A; C использует то же предоставление прав и то же правило подписания.

## 3. Токены на вход, токены на выход

USDC в Rome — это один SPL mint, рассматриваемый с двух сторон:  `wUSDC` обертка ERC-20 на стороне EVM и ATA внешнего полномочия на стороне Solana. Для собственного адреса пользователя это один и тот же баланс: `wUSDC.balanceOf(user)` читает ATA пользователя. Между этими двумя представлениями ничего не перемещается и не синхронизируется.

**Баланс обертки контракта — это не токен-счет, которым контролирует контракт.** Фабрика развертывает `SPL_ERC20_cached` для обычного mint, и Hadrian's `wUSDC` является одной из них. Эта обертка не может подписывать от имени контракта, поэтому когда `wUSDC.transferFrom(user, adapter, amount)` или `transfer` отправляет токены контракту, SPL-токены перемещаются в **собственный escrow-токен-счет обертки** (`escrow_ata()`), а обертка фиксирует сумму по каждому контракту в своем хранилище. `wUSDC.balanceOf(adapter)` возвращает эту запись — escrow-реестр, а не баланс токен-счета, принадлежащего `external_auth(adapter)`. Ваш адаптер не может передать эти токены вашей программе в CPI; они могут выйти только через ту же обертку. Поэтому адаптер, который финансирует себя через `transferFrom` не имеет ничего, что можно потратить на стороне Solana.

Рабочий путь — SPL-делегация:

* **Предоставление прав.** Пользователь отправляет `approve_spl(adapter, amount, mint)` как транзакцию **напрямую в HelperProgram** (`to = 0xff…09`), где `mint` является `mint_id()`. Подписывает собственное полномочие пользователя, а делегат, который устанавливается на токен-счете пользователя, — это внешнее полномочие адаптера.
* **На вход.** У адаптера `deposit(amount)` забор средств осуществляется через перегрузку с делегатом `HelperProgram.transfer_spl(srcAta, dstAta, amount, mint)`, с ATA пользователя в качестве источника и собственным ATA адаптера (`HelperProgram.ata(address(this), mint)`, созданным один раз с помощью `create_ata`) в качестве получателя. Полномочие адаптера подписывает как делегат. Теперь токены находятся на токен-счете, принадлежащем `external_auth(adapter)`, который и есть счет, указанный в вашем CPI; подписант и источник — собственные счета адаптера, поэтому дополнительное разрешение не требуется. Они не отображаются в `wUSDC.balanceOf(adapter)`.
* **На выход.** Инструкция withdraw вашей программы переводит на **пользовательский** ATA, `HelperProgram.ata(user, mint)`. Для получения не требуется подпись пользователя, и баланс сразу виден как `wUSDC.balanceOf(user)`. Если ATA еще может не существовать, сначала создайте его с помощью `HelperProgram.create_ata(user, mint)` (идемпотентно).

**У токен-счета есть только один делегат.** Указанное выше предоставление прав заменяет собственное предоставление прав обертки на этом счете. Пока пользователь снова не предоставит права обертке, каждый `wUSDC` `transfer` или `transferFrom` вывод из их адреса откатывается с ошибкой SPL `0x4`. После любого процесса, использующего это предоставление прав, вызывайте `wUSDC.isEnabled(user)`; когда он возвращает `false`, попросите пользователя отправить `approve_spl(wrapper, 2^64-1, mint)` в HelperProgram снова — то же максимальное предоставление прав, вокруг которого построена обертка (см. [Разово: предоставить права обертке](https://docs.rome.builders/ru/rukovodstva-dlya-razrabotchikov/dual-lane-app.md#one-time-grant-the-wrapper)). Ограниченное предоставление прав нарушило бы обычные `wUSDC` переводы пользователя, когда лимит исчерпается, а `isEnabled` остается `true` пока хоть какая-то часть остается, поэтому приложение не поняло бы, что нужно запросить снова.

Чтобы проверить, какая обертка у mint, прочитайте у фабрики `wrapper_kind_by_mint(mint)` (адрес фабрики находится в `contracts.json` в [реестре](https://github.com/rome-protocol/rome-registry)). `1` — это кэшированная обертка, описанная в этом разделе. `2` — это обертка прямого CPI, которую фабрика развертывает для mint Token-2022 с активированным transfer hook; это руководство ее не рассматривает. В реестре `tokens.json` указаны адрес обертки и mint, но не указано, какого она типа.

## 4. Один трек на контракт и на транзакцию

У Rome есть две группы препкомпилированных вызовов, изменяющих состояние Solana, и **транзакция использует только один из них** — runtime отклоняет транзакцию, которая смешивает изменяющие вызовы из обеих групп, даже между контрактами.

| Трек             | Предкомпиляции                                                                                      | Изменения вступают в силу                                                                     | Работает в итеративном выполнении                                                                |
| ---------------- | --------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| **Наследуемый**  | `CpiProgram` `0xff…08` (`invoke`, `invoke_signed`), `HelperProgram` `0xff…09`, `Вывод` `0x42…16`    | Немедленно, как настоящий CPI внутри шага EVM                                                 | **Нет** — legacy-CPI в итеративной транзакции завершается ошибкой с `CpiProhibitedInIterativeTx` |
| **Кэшированный** | `SplCached` `0xff…05`, `ASplCached` `0xff…06`, `SystemCached` `0xff…04`, `WithdrawCached` `0xff…0b` | Подготавливаются в оверлее и подтверждаются как CPI в конце транзакции; откат EVM их отменяет | Да                                                                                               |

Что это означает для интеграции программы:

* **Вызов инструкций собственной программы возможен только в legacy-треке.** У кэшированного трека нет общего `invoke`; он охватывает SPL-переводы, создание ATA, операции системной программы и вывод газа.
* Следовательно, шаг, который финансирует адаптер, тоже должен быть в legacy-треке, если он выполняется в той же транзакции, что и CPI. Кэшированный вызов обертки `transferFrom` — это вызов кэшированного трека, поэтому он не может находиться в одной транзакции с вашим CPI (и, как показывает раздел 3, он лишь пополнил бы escrow-реестр). Забирайте средствами через `HelperProgram.transfer_spl(userAta, adapterAta, amount, mint)` вместо этого, после того как пользователь назначит адаптер SPL-делегатом (`approve_spl`, отправлено пользователем напрямую в HelperProgram). Забор и CPI оба относятся к legacy-треку, поэтому они выполняются в одной транзакции.
* **Исключите обертку из этой транзакции.** Не вызывайте изменяющие функции обертки (`wUSDC.transfer`, `transferFrom`) из адаптера в той же транзакции, что и legacy-CPI. Проверяйте `isEnabled(user)` и балансы на фронтенде с помощью `eth_call`.
* **И транзакция CPI должна быть атомарной.** Таково ограничение, в рамках которого строится архитектура.

Чтение не подпадает под это правило: `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` и `HelperProgram.user_balance` / `allowance_of` — это чтение предварительно загруженных счетов (без CPI), разрешенное в любом треке и в обоих режимах выполнения. Используйте их для предварительных проверок. Одно правило порядка: после того как в транзакции произошла кэшированная мутация, legacy-чтения блокируются до конца транзакции — сначала читайте, затем изменяйте.

## 5. Атомарность — это бюджет

Атомарная транзакция Rome — это одна транзакция Solana: примерно **1,4 млн compute units**, **64-адресный** список счетов и **4 КБ** размер по сети (транзакции Solana v1). Программа Rome и ваш CPI делят этот бюджет. Перевод через обертку занимает около 170K CU на Hadrian, а ваша инструкция добавляет свои; измеряйте по `computeUnitsConsumed`, а не EVM `gasUsed`.

Когда эмуляция определяет, что транзакция не помещается, Rome выполняет ее **итеративно** через несколько транзакций Solana, и legacy-CPI внутри нее затем завершается ошибкой. Сведите каждый из deposit и withdraw к одному перемещению токена плюс одному CPI в вашу программу, а окружающий их Solidity держите небольшим. Все, что больше, разделите на две пользовательские транзакции.

Глубина CPI: Solana разрешает 4 уровня, а Rome использует один, поэтому ваша инструкция выполняется на уровне 2, имея под собой два уровня (ваша программа → SPL Token оставляет один уровень).

## 6. Подготовка счетов

Ваша программа не получает свои счета из Solidity во время выполнения. Прокси **эмулирует** каждую транзакцию перед отправкой, записывает каждый счет Solana, к которому обратились CPI, и помещает их в транзакцию Solana. Ваш адаптер указывает счета в `invoke_signed` списке счетов; эмуляция подтверждает, что они разрешаются. Отсюда следуют три вывода:

* Каждый счет, к которому обращается ваша инструкция, должен выводиться из входных данных, которыми располагает адаптер (его собственный PDA и sub-PDA, ID вашей программы, mint, адрес пользователя). `SystemProgram.find_program_address` и `CpiProgram.pdas_batch_derive` выполняют выводы в Solidity.
* Счет, который еще не существует (новая позиция, новый ATA), все равно должен быть указан в списке счетов; в транзакцию Solana попадает именно его адрес.
* Все, к чему прикасается транзакция — включая собственные счета Rome для пользователя, адаптера и обертки — должно укладываться в 64 адреса. Архитектура, затрагивающая десять рынков за один вызов, не поместится.

Для канала Solana-кошелька, `rome_emulateCallAccounts` предоставляет клиенту тот же механизм обнаружения; SDK использует его.

Два счета, которые CPI никогда не может указывать: плательщик комиссии Solana, отправляющий транзакцию (кроме как внутри обычной инструкции System transfer), и сама программа Rome. CPI обратно в программу Rome отклоняется.

## 7. Deposit и withdraw на Solidity

Минимальный набросок адаптера в legacy-треке. Пользователь уже отправил `approve_spl(adapter, amount, mint)` в HelperProgram (раздел 3). `PRIVACY_PROGRAM` — это ID вашей программы; `encodeDeposit` / `encodeWithdraw` формируют данные вашей инструкции (Borsh, little-endian); метаданные счетов следуют структуре вашей инструкции.

```solidity
import {ICrossProgramInvocation, IHelperProgram}
    from "@rome-protocol/rome-solidity/contracts/interface.sol";

contract PrivacyAdapter {
    ICrossProgramInvocation constant Cpi    = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);
    IHelperProgram          constant Helper = IHelperProgram(0xFF00000000000000000000000000000000000009);
    bytes32 constant SPL_TOKEN = 0x06ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9; // TokenkegQ...

    bytes32 immutable PRIVACY_PROGRAM;
    bytes32 immutable USDC_MINT;

    constructor(bytes32 program, bytes32 mint) {
        PRIVACY_PROGRAM = program; USDC_MINT = mint;
        Helper.create_pda(address(this));                 // собственная идентичность адаптера в Solana
        Helper.create_ata(address(this), USDC_MINT);      // и USDC-счет, которым он владеет
    }

    function _salt(address user) internal pure returns (bytes32) { return bytes32(uint256(uint160(user))); }

    function deposit(uint64 amount) external {
        bytes32 self       = Helper.pda(address(this));                   // signer: authority адаптера
        bytes32 adapterAta = Helper.ata(address(this), USDC_MINT);
        bytes32 position   = Helper.pda_with_salt(address(this), _salt(msg.sender)); // sub-PDA на пользователя, тоже подписывает

        // Забрать со токен-счета пользователя. Полномочие адаптера подписывает как SPL
        //-делегат, выданный пользователем; это вызов legacy-трека, как и CPI ниже.
        Helper.transfer_spl(Helper.ata(msg.sender, USDC_MINT), adapterAta, amount, USDC_MINT);

        ICrossProgramInvocation.AccountMeta[] memory accs = new ICrossProgramInvocation.AccountMeta[](5);
        accs[0] = ICrossProgramInvocation.AccountMeta(self,       true,  true);
        accs[1] = ICrossProgramInvocation.AccountMeta(position,   true,  true);
        accs[2] = ICrossProgramInvocation.AccountMeta(adapterAta, false, true);                          // источник: принадлежит authority адаптера
        accs[3] = ICrossProgramInvocation.AccountMeta(_vaultFor(position), false, true);                 // хранилище вашей программы
        accs[4] = ICrossProgramInvocation.AccountMeta(SPL_TOKEN, false, false);

        bytes32[] memory salts = new bytes32[](1);
        salts[0] = _salt(msg.sender);
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeDeposit(amount), salts);
    }

    function withdraw(uint64 amount) external {
        bytes32 position = Helper.pda_with_salt(address(this), _salt(msg.sender));
        bytes32 userAta  = Helper.ata(msg.sender, USDC_MINT);            // получатель: собственный счет пользователя
        // ... та же схема: ваша программа переводит `amount` из vault на userAta, подписывая `position`
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeWithdraw(amount), salts);
    }
}
```

Адаптер никогда не вызывает `wUSDC` контракт. Забор средств — это вызов HelperProgram, который использует делегацию пользователя, а токены находятся на токен-счете, которым `external_auth(adapter)` владеет, поэтому CPI может их тратить.

Примечания по подписанту. Rome подписывает ровно за два типа счетов: голое полномочие вызывающего контракта (`Helper.pda(address(this))`), которое подписывает, не будучи указанным в `солях`, и по одному sub-PDA с солью на каждую запись в `солях`. Каждая указанная вами соль должна присутствовать в списке счетов как подписант, иначе вызов завершится ошибкой `счет подписанта, вычисленный из предоставленного seed, не найден`. Любому другому счету, помеченному как подписант, включая собственное полномочие пользователя, Rome не выдает seed, и runtime Solana отклоняет CPI. Права пользователя на свои токены возникают из делегации, а не из того, что адаптер подписывает от имени пользователя.

Делегация без забора средств: если вашей программе нужно тратить напрямую с токен-счета пользователя, пользователь отправляет `HelperProgram.approve_spl_raw_delegate(userAta, yourProgramPda, amount, mint, decimals)` напрямую в HelperProgram, указывая PDA вашей программы в качестве SPL-делегата. Мост Rome использует это для Wormhole. Правило одного делегата из раздела 3 действует и здесь: это предоставление прав вытесняет права обертки.

## 8. Тестирование

* Развертывайте в **Hadrian** (testnet, chain 200010) сначала; адреса и RPC находятся в [справочнике Contract Addresses](https://docs.rome.builders/ru/spravochnik/contract-addresses.md) и [реестре](https://github.com/rome-protocol/rome-registry).
* `eth_call` и `eth_estimateGas` выполняет ту же эмуляцию, которую прокси использует для отправки, поэтому CPI, который там не проходит, по той же причине не пройдет и в сети, а данные отката содержат исходную ошибку Solana (`ошибка вызова не-EVM: …` в логе программы Solana).
* Читайте сторону Solana у завершившейся EVM-транзакции с помощью `rome_solanaTxForEvmTx(hash)`; в квитанции Solana находятся CU и логи вашей программы.
* CPI, который работает в `eth_call` но отклоняется при отправке, обычно упирается в ограничение, о котором сообщает эмуляция: лимит 64 адресов, атомарный бюджет CU (транзакция стала итеративной) или правило трека.

## 9. Справочник

* [Справочник пре-компиляций](https://docs.rome.builders/ru/spravochnik/precompiles.md) — каждый селектор каждого препкомпилированного вызова, с его классом диспетчеризации и правилом delegatecall.
* [Ограничения](https://docs.rome.builders/ru/klyuchevye-ponyatiya/constraints.md) — все указанные выше ограничения в одной таблице.
* [Интероперабельность токенов](https://docs.rome.builders/ru/klyuchevye-ponyatiya/token-interop.md) — обертки, канонические mint, deposit и withdraw.
* Справочные приложения в публичных репозиториях: [cardo](https://github.com/rome-protocol/cardo) (пользователь напрямую вызывает препкомпилированный CPI, форма B), [rome-dex](https://github.com/rome-protocol/rome-dex) (прямой `invoke` плюс маршрутизатор без хранения активов, форма C), и [aerarium](https://github.com/rome-protocol/aerarium) (приложение кредитования Compound III поверх одного общего рынка; оно не вызывает программы Solana из Solidity (без CPI), поэтому это не пример адаптера).


---

# 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/integrate-solana-program.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.
