> 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/produkty/rome-sdk.md).

# Rome SDK

Типизированные интерфейсы Solidity для вызова программ Solana из EVM-контрактов, а также Rust SDK, лежащий в основе офчейн-сервисов Rome.

SDK Rome предоставляет типизированные интерфейсы Solidity для взаимодействия с программами Solana из смарт-контрактов EVM. Это набор инструментов для разработчиков, предназначенный для создания кросс-рантаймных приложений на Rome.

## SDK

У Rome есть SDK для трех аудиторий — разработчиков приложений (TypeScript), разработчиков контрактов (Solidity) и команд, запускающих собственные сервисы на Rome (Rust).

### SDK на TypeScript (`@rome-protocol/sdk`)

**Для разработчиков dapp и frontend** — SDK, с которого начинают большинство разработчиков приложений. [`@rome-protocol/sdk`](https://github.com/rome-protocol/rome-sdk-ts) оборачивает путь записи Rome, чтобы веб-приложение корректно отправляло транзакции Rome: `submitRomeTx` (правильный путь записи плюс обработка газа/комиссии), вывод PDA / ATA, CPI `invoke` / `invoke_signed` энкодеры, биндинги прекомпилов и `/bridge` подпуть. Установка из репозитория в приоритете (публикация в npm ожидается):

```bash
npm install github:rome-protocol/rome-sdk-ts#v0.4.0
```

```typescript
import { submitRomeTx } from '@rome-protocol/sdk';
// Отправить любую запись Rome EVM через правильный путь записи (обрабатывает кодирование газа/комиссии).
```

Публичное [rome-dex](https://github.com/rome-protocol/rome-dex) приложение использует лишь несколько вспомогательных функций SDK (вывод PDA и токен-аккаунтов, `invoke` энкодер и запас газа 1.3x), и [cardo](https://github.com/rome-protocol/cardo) не зависит от него. Ни одно из них не вызывает `submitRomeTx` или `submitRomeTxV1` , поэтому используйте их как пример того, как приложение вызывает прекомпил CPI, а не как путь записи SDK.

**Обе ветки, один SDK.** `submitRomeTx` — это ветка EVM (MetaMask). Для **ветки Solana** — кошелек Solana, управляющий вашим приложением EVM — `submitRomeTxV1` повторяет ее: прокси формирует одну транзакцию Solana v1 для вызова, кошелек дважды подписывает одним и тем же ключом (сначала читаемое сообщение авторизации, затем транзакцию), а Rome выполняет вызов как транзакцию EVM от производного идентификатора пользователя, без ключа EVM. Вызов, который не помещается в одну транзакцию, ретранслируется прокси с той же подписью авторизации, и `fundSyntheticGas` добавляет нативный газ, который расходует ретранслируемый вызов. Ретранслируемый вызов, который откатывается, завершается с `receipt.status === "0x0"` вместо выброса исключения, поэтому проверяйте это; [ретранслируемые вызовы и длинные вызовы](https://docs.rome.builders/ru/rukovodstva-dlya-razrabotchikov/call-evm-from-solana.md#relayed-calls-and-long-calls) содержит правило по газу и ограничения. Значения перемещаются внутрь и наружу через `buildFundLeg` / `buildSweepLeg` как обертка ERC-20 (например, `wUSDC`), а не нативно `msg.value` — синтетический отправитель ничего не держит в покое — а первый синтетический аккаунт подготавливается один раз, явно, с помощью `buildCreatePdaCall`. Более ранний `submitRomeTxSolanaLane`, который собирает устаревшую транзакцию Solana на стороне клиента, по-прежнему находится в SDK. См. [Сборка приложения с двумя дорожками](https://docs.rome.builders/ru/rukovodstva-dlya-razrabotchikov/dual-lane-app.md) и [Вызов EVM из Solana](https://docs.rome.builders/ru/rukovodstva-dlya-razrabotchikov/call-evm-from-solana.md).

### SDK для Solidity (`@rome-protocol/rome-solidity`)

**Для разработчиков Solidity.** Предоставляет интерфейсы прекомпилов, обертки ERC-20/SPL, вывод PDA и утилиты CPI. Публикация в npm пока ожидается; сейчас вы используете их из публичного [`rome-solidity`](https://github.com/rome-protocol/rome-solidity) репозитория (зависимость git или скопированные файлы).

```solidity
import {ISystemProgram, ICrossProgramInvocation, IHelperProgram, IWithdraw}
    from "@rome-protocol/rome-solidity/contracts/interface.sol";
import {SPL_ERC20} from "@rome-protocol/rome-solidity/contracts/erc20spl/erc20spl.sol";
import {RomeEVMAccount} from "@rome-protocol/rome-solidity/contracts/rome_evm_account.sol";
```

### SDK на Rust (`rome-sdk`)

**Для команд, которые запускают собственные сервисы на Rome.** Рабочее пространство Rust, которое отвечает за компоновку транзакций, взаимодействие с Solana, ценообразование газа и индексацию блоков. На нем построены Proxy и Hercules. Исходный код находится в [`rome-protocol/rome-sdk`](https://github.com/rome-protocol/rome-sdk). Оно отправляет транзакции Solana v1 (4 КБ, до 64 аккаунтов).

**Сборка.** Рабочее пространство ожидает, что репозитории [`rome-sdk`](https://github.com/rome-protocol/rome-sdk), [`rome-evm`](https://github.com/rome-protocol/rome-evm) и [`mollusk`](https://github.com/rome-protocol/mollusk) будут клонированы рядом, поскольку оно зависит от двух других по относительному пути. Именно поэтому рекомендуемый способ использовать его из другого проекта — зависимость по пути, а не обычная git-зависимость. Для первой сборки вам нужен Rust 1.85 или новее и доступ к сети. `rome-evm` не имеет сетевой функции по умолчанию, поэтому для любой сборки, которая его компилирует, требуется ровно одна из `ci`, `тестовая сеть` или `основная сеть`; используйте `ci` для локальной работы, например `cargo test -p rome-sdk --features ci`. В README репозитория приведены полные шаги и таблица возможностей.

**Лицензия.** Rust SDK доступен в исходниках, но не является открытым ПО: все права защищены, и его можно использовать в личных, некоммерческих целях. Для коммерческого использования требуется письменное разрешение Rome Protocol; в репозитории `LICENSE` указано, как подать запрос.

## SDK для Solidity: что входит

### Интерфейсы прекомпилов

Привязка интерфейса к его адресу прекомпила:

```solidity
ISystemProgram          constant System   = ISystemProgram(0xFF00000000000000000000000000000000000007);
ICrossProgramInvocation constant Cpi      = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);
IHelperProgram          constant Helper   = IHelperProgram(0xFF00000000000000000000000000000000000009);
IWithdraw               constant Withdraw = IWithdraw(0x4200000000000000000000000000000000000016);
// Кэшированный путь: ISplCached 0xff…05, IAssociatedSplCached 0xff…06, ISystemCached 0xff…04, IWithdrawCached 0xff…0b
```

### Операции с токенами SPL

Используйте `IHelperProgram` (`0xff…09`) для примитивов SPL, подписанных PDA пользователя:

```solidity
// Создать ATA вызывающего для mint
Helper.create_ata(user, mint);

// Перевести SPL с PDA вызывающего
Helper.transfer_spl(to, tokens, mint);
```

В кэшированной ветке эквивалентные операции находятся в `ISplCached` (`0xff…05`) и `IAssociatedSplCached` (`0xff…06`). См. `interface.sol` для всех перегрузок; контракт последовательно использует одну ветку.

### Вывод PDA

```solidity
// Вывести PDA пользователя в Solana
bytes32 userPda = RomeEVMAccount.pda(msg.sender);

// Вывести PDA с солью (для создания нескольких PDA на пользователя)
bytes32 pda = RomeEVMAccount.pda_with_salt(msg.sender, salt);

// Найти произвольный PDA
(bytes32 pda, uint8 bump) = SystemProgram.find_program_address(programId, seeds);
```

### Вызов между программами

```solidity
// Вызвать любую программу Solana
ICrossProgramInvocation.AccountMeta[] memory accounts = new ICrossProgramInvocation.AccountMeta[](2);
accounts[0] = ICrossProgramInvocation.AccountMeta(signerPda, true, true);
accounts[1] = ICrossProgramInvocation.AccountMeta(targetAccount, false, true);

CpiProgram.invoke(programId, accounts, instructionData);

// Вызов с подписанием PDA
CpiProgram.invoke_signed(programId, accounts, data, seeds);

// Прочитать данные аккаунта
(uint64 lamports, bytes32 owner, bool isSigner, bool isWritable, bool executable, bytes memory data)
    = CpiProgram.account_info(pubkey);
```

### ERC-20 поверх токенов SPL

```solidity
// Развернуть обертку для любого mint SPL
ERC20SPLFactory factory = ERC20SPLFactory(FACTORY_ADDRESS);
address wrapper = factory.add_spl_token_with_metadata(splMint);

// Использовать обертку как стандартный ERC-20
SPL_ERC20 token = SPL_ERC20(wrapper);
token.transfer(recipient, amount);
uint256 balance = token.balanceOf(user);
```

### Десериализация Borsh

```solidity
import {Convert} from "@rome-protocol/rome-solidity/contracts/convert.sol";

// Разобрать данные аккаунта Solana (формат Borsh с порядком байт little-endian)
(uint64 value, uint256 newOffset) = Convert.read_u64le(data, offset);
(bytes32 pubkey, uint256 newOffset2) = Convert.read_bytes32(data, offset);
```

### Метаданные Metaplex

```solidity
import {MplTokenMetadataLib} from "@rome-protocol/rome-solidity/contracts/mpl_token_metadata/lib.sol";

// Загрузить метаданные токена из Metaplex
MplTokenMetadataLib.Metadata memory meta = MplTokenMetadataLib.load_metadata(
    mintPubkey, mplProgramId, cpiAddress
);
string memory name = meta.name;
string memory symbol = meta.symbol;
```

## Rust SDK: архитектура

Rust SDK представляет собой рабочее пространство Cargo. Его основные crates:

| Crate               | Назначение                                                                                                                                               |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome-sdk`          | Основной API: `Rome` структура, конфигурация, три типа транзакций (`RheaTx`, `RemusTx`, `RomulusTx`)                                                     |
| `rome-evm-client`   | EVM-клиент для цепочек Rome, TxBuilder, ResourceFactory, интеграция с эмулятором                                                                         |
| `rome-solana`       | Solana tower, RPC-клиент, пакетирование и отслеживание транзакций                                                                                        |
| `rome-utils`        | RLP, hex, JSON-RPC, утилиты аутентификации                                                                                                               |
| `rome-obs`          | Наблюдаемость OpenTelemetry (трейсы, метрики, журналы)                                                                                                   |
| `rome-meteora`      | Читатели пулов Meteora DAMM v1 и v2 для ценообразования газа                                                                                             |
| `rome-meta-hook`    | Клиент для программы Meta-Hook Router: конфигурация transfer-hook Token-2022, разрешение дополнительных аккаунтов, переводы с оценкой бюджета вычислений |
| `rome-jito-bundler` | Сборщик Jito bundle для атомарной отправки нескольких транзакций                                                                                         |

### Типы транзакций

```rust
// Одна EVM-транзакция в одной цепочке Rome
let rhea = RheaTx::new(signed_eth_tx);
let mut tx = rome.compose_rollup_tx(rhea).await?;
let sig = rome.send_and_confirm(&mut *tx).await?;

// Несколько EVM-транзакций в разных цепочках Rome, атомарно в одной транзакции Solana
let remus = RemusTx::new(vec![tx1, tx2]);
let mut tx = rome.compose_cross_rollup_tx(remus).await?;

// EVM-транзакции плюс нативные инструкции Solana, атомарно в одной транзакции Solana
let romulus = RomulusTx::new(eth_txs, sol_ixs);
let mut tx = rome.compose_cross_chain_tx(romulus, signers).await?;
```

### Пул ресурсов

SDK объединяет пары ключей Solana (payer) и индексы аккаунтов-держателей для параллельной отправки транзакций:

```rust
let resource = resource_factory.get().await?;
let payer = resource.payer();       // Пара ключей Solana
let holder = resource.holder();     // Индекс аккаунта-держателя
// Ресурс автоматически возвращается в пул при Drop
```

## Дорожная карта SDK

### Реализовано и работает

* Обертки токенов SPL и интерфейсы прекомпилов
* Обмены Meteora DAMM v1 через CPI
* Oracle Gateway V1 + V2 (Pyth Pull, Switchboard V3)
* Вспомогательные функции System Program, десериализация Borsh
* Фабрика ERC20SPL + bridge-контракты

## Что дальше

* [Разверните Solidity](https://docs.rome.builders/ru/rukovodstva-dlya-razrabotchikov/deploy-solidity.md) — разверните свой первый контракт с помощью SDK
* [Вызов Solana из EVM](https://docs.rome.builders/ru/rukovodstva-dlya-razrabotchikov/call-solana-from-evm.md) — используйте CPI для взаимодействия с программами Solana
* [справочнике Contract Addresses](https://docs.rome.builders/ru/spravochnik/contract-addresses.md) — адреса развернутых контрактов SDK


---

# 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/produkty/rome-sdk.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.
