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

# Solana プログラムを統合する

SolanaプログラムをRome EVMと統合します — Solana署名者は誰か、資産がどうあなたのプログラムに届き、どう戻るか、1本の経路のルール、アトミックとイテレーティブの違い、そしてアカウントの準備。

このガイドは、Rome EVM のユーザーに自分たちのプログラムを使ってほしい Solana プログラムチーム向けです。対象は、EVM アカウントに価値を保持すべきプライバシー、レンディング、または Vault プログラムです。これは次を基にしています [EVM から Solana を呼び出す](https://docs.rome.builders/ja/gaido/call-solana-from-evm.md) （プリコンパイルの仕組み）を基にしており、実際のプログラムが向こう側にあるときに出てくる疑問に答えます： *誰が* 署名するか、 *どう* トークンが出入りするか、そして *どの* 制約が設計を形作るか。

ここで一貫して使う流れはこうです。EVM アカウントが USDC をあなたのプログラムへ移し（"shield" または "deposit"）、あなたのプログラムがそれをそのユーザーのために保持し、後でそれを戻します（"unshield" または "withdraw"）。動詞はあなたのものに置き換えてください。

## 1. すべての EVM アドレスには 1 つの Solana アイデンティティがある

Rome は、すべての EVM アドレス — ユーザーもコントラクトも含めて — ごとに Solana アカウントを導出します。これはその **外部権限**:

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

が所有する関連トークンアカウント（つまり `wUSDC.balanceOf(addr)` が参照する先）であり、そのアドレスに代わって作られた CPI に署名する鍵でもあります。あなたのプログラムには 32 バイトの Solana pubkey しか見えず、H160 は見えません。

**誰が署名するかは、プリコンパイルを誰が呼ぶかで決まります：**

| プリコンパイルを呼ぶのは                             | Solana の署名者                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| ある **コントラクト**、通常の `CALL`                 | 上記の **コントラクト自身の** 外部権限（`external_auth(contract)`）に加え、要求したコントラクトのソルト付きサブ PDA も含めて                                                                                                                                                                                                                                                                                                                                                                       |
| ある **ユーザー**、プリコンパイルのアドレスへ直接送られるトランザクションで | 上記の **ユーザー自身の** 外部権限                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| コントラクトが `DELEGATECALL`                   | 素の権限は拒否されます（`DelegatecallOwnerAuthority`). `invoke` 署名者なしでは、そして `invoke_signed` ソルト付きサブ PDA 付きなら実行は続行されます — ただしそれらのサブ 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` は、ラッパー自身の transfer が尊重する EVM 側の allowance にすぎません。Rome 自身のトークンラッパーがそう動作し、あなたのアダプタもそう動作します（セクション 3）。

ソルト付きサブ PDA： `invoke_signed` は `bytes32` 個のソルトのリストを取り、Rome は `["EXTERNAL_AUTHORITY", caller_h160, salt]` で署名します（各項目ごとに bump が付与されます。caller は直接呼び出し時のコントラクトです）。 `HelperProgram.pda_with_salt(addr, salt)` は Solidity からそのアドレスを返します。あなたのプログラムがポジションごとに別の所有者アカウントを必要とするなら、ユーザーごとに 1 つのソルト（たとえばユーザーのアドレス）を使ってください。

資金供給：ATA を所有するために、外部権限 PDA が存在している必要はありません（`create_ata` は冪等で、トランザクションの Solana 料金支払者が rent を負担します）。ただし、あなたの命令が作成するアカウントに資金を出すときだけは、それが存在し lamports を保持している必要があります。 `HelperProgram.create_pda(addr)` は通常の System `CreateAccount`として作成するので、一度だけ呼び出してください。冪等ではありません。 `swap_gas_to_lamports(n)` は、そのアドレスの PDA にトランザクションの Solana 料金支払者から lamports を付与し、呼び出し元は Rome gas でそれを支払います。つまり、レガシー・トラックの各 CPI が料金支払者の残高に与える影響はトランザクション手数料に加算され、アカウント作成に対する rent が課金されるのと同じように、ガス価格でユーザーに請求されます。Solana レーンのプロビジョニング手順は `n` で説明されています。コントラクトは、コンストラクタまたは最初の呼び出しで自身の PDA をプロビジョニングします。 [Solana から EVM を呼び出す](https://docs.rome.builders/ja/gaido/call-evm-from-solana.md)；コントラクトは、コンストラクタまたは最初の呼び出しで自身の PDA をプロビジョニングします。

## 2. ユーザーのポジションを保持する 3 つの方法

**A. アダプタ・コントラクト（再利用可能なアダプタ向けに推奨）。** 1 つの Solidity コントラクトがあなたのプログラムの前面に立ちます。ユーザーは、自分のトークンアカウントに対してアダプタの権限へ SPL デリゲーションを付与します。アダプタはトークンを自分が所有するトークンアカウントへ引き込み、自身としてあなたのプログラムを呼び出し、ユーザーごとのサブ PDA か、命令データで渡す識別子によって、あなたのプログラム内のユーザーのポジションにキーを付けます。戻すときは、あなたのプログラムにユーザー自身のトークンアカウントへ解放するよう指示します。アダプタは、あなたのプログラムが知る必要のある唯一の Solana アイデンティティです。付与は ERC-20 `approve`ではなく SPL デリゲーションです。なぜそうなのか、そしてそれがユーザーに何を費やさせるのかはセクション 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 デリゲーションを付与します。ルーターはその権限を transfer authority として使ってあなたのプログラムへ CPI を行うので、トークンはユーザーのトークンアカウントからあなたのプログラムのアカウントへ（またはユーザーのアカウントへ戻る）移動し、ルーターは呼び出しの間なにも保持しません。ルーターは `msg.sender`からすべてのユーザー側アカウントを導出するので、1 人のユーザーの付与を別のユーザーのアカウントに向けることはできず、一般的な `invoke` パススルーとして振る舞うのではなく、固定の instruction shape を持つ 1 つの固定プログラムを呼び出します。 `RomeDexRouter` で [rome-dex](https://github.com/rome-protocol/rome-dex) はこの方法で書かれています。rome-dex の EVM レーンも、形 B の生の直接 `invoke` を提供します。これには A と同じ付与が必要で、同じ 1 デリゲートのコスト（セクション 3）で、pull ステップは不要です。

このガイドの残りは A に従います。C も同じ付与と同じ署名ルールを使います。

## 3. トークンを入れる、トークンを出す

Rome 上の USDC は、2 つの側面から見た 1 つの SPL mint です。EVM 側の ERC-20 ラッパーと、Solana 側の外部権限の ATA です。ユーザー自身のアドレスについては、この 2 つは同じ残高です： `wUSDC` wUSDC.balanceOf(user) `はユーザーの ATA を参照します。` 2 つの見え方の間で何も移動も同期もされません。

**コントラクトのラッパー残高は、コントラクトが制御するトークンアカウントではありません。** ファクトリは通常の mint 用に `SPL_ERC20_cached` ラッパーをデプロイし、Hadrian の `wUSDC` ものもその 1 つです。 `wUSDC.transferFrom(user, adapter, amount)` または `transfer` がコントラクトへトークンを送ると、SPL トークンは **ラッパー自身の escrow トークンアカウント** (`escrow_ata()`）に入り、ラッパーはその額をコントラクトごとにストレージへ記録します。 `wUSDC.balanceOf(adapter)` は、その記録、つまり escrow 台帳を返すのであって、 `external_auth(adapter)`が所有するトークンアカウントの残高ではありません。 `transferFrom` を使って自己資金化したアダプタには、Solana 側で使えるものは何もありません。

うまくいく経路は SPL デリゲーションです：

* **付与。** ユーザーは `approve_spl(adapter, amount, mint)` をトランザクションとして **HelperProgram に直接送ります** (`to = 0xff…09`）、ここで `mint` はラッパーの `mint_id()`です。ユーザー自身の権限が署名し、ユーザーのトークンアカウントに設定される delegate はアダプタの外部権限です。
* **入力。** アダプタの `deposit(amount)` は delegate オーバーロードで引き込みます `HelperProgram.transfer_spl(srcAta, dstAta, amount, mint)`を使い、ソースはユーザーの ATA、宛先はアダプタ自身の ATA（`HelperProgram.ata(address(this), mint)`、これは一度だけ `create_ata`で作成します）です。アダプタの権限が delegate として署名します。トークンはそれがあなたの CPI が名指しするアカウントです。署名者とソースはアダプタ自身のものなので、これ以上の権限は必要ありません。これらは `external_auth(adapter)`出力。 `wUSDC.balanceOf(adapter)`.
* **出力。** あなたのプログラムの withdraw 命令は **ユーザーの** ATA へ転送します、 `HelperProgram.ata(user, mint)`。受け取りにユーザーの署名は不要で、残高は直ちに `はユーザーの ATA を参照します。`として見えるようになります。ATA がまだ存在しない可能性があるなら、先に `HelperProgram.create_ata(user, mint)` （冪等）で作成してください。

**トークンアカウントにはデリゲートは 1 つしかありません。** 上の付与は、そのアカウントに対するラッパー自身の付与を置き換えます。ユーザーがラッパーにもう一度付与するまでは、彼らのアドレスからのすべての `wUSDC` `transfer` または `transferFrom` 送信は SPL エラー `0x4`でリバートします。 `この付与を使うフローの後は、`wUSDC.isEnabled(user) `を呼び出し、返り値が`false `なら、ユーザーに再度` approve\_spl(wrapper, 2^64-1, mint) [を HelperProgram に送るよう求めてください。これはラッパーが想定する最大付与と同じです（](https://docs.rome.builders/ja/gaido/dual-lane-app.md#one-time-grant-the-wrapper)一度だけ：ラッパーに付与 `wUSDC` ）。上限付きの付与は、残高が少なくなったあとにユーザーの通常の `isEnabled` 再送信を `true` に保ったままになり、アプリは再度尋ねるべきだと分からなくなります。

どのラッパーがどの mint に対応するかを確認するには、ファクトリの `wrapper_kind_by_mint(mint)` を読みます（チェーンの factory アドレスは `contracts.json` の [registry](https://github.com/rome-protocol/rome-registry)). `1` にあり、ここで説明しているのはキャッシュされたラッパーです。 `2` は、アームされた transfer hook を持つ Token-2022 mint に対してファクトリがデプロイする direct-CPI ラッパーです。このガイドでは扱いません。registry の `tokens.json` はラッパーのアドレスと mint は列挙しますが、それがどの種類かは示しません。

## 4. コントラクトごと、そしてトランザクションごとに 1 つのトラック

Rome には Solana の状態を変更する 2 系統のプリコンパイルがあり、 **1 つのトランザクションはそのうちのどちらか 1 つだけを使います** — ランタイムは、コントラクトをまたいでいても両方の mutating 呼び出しを混ぜたトランザクションを拒否します。

| トラック       | Precompiles                                                                                         | 効果が反映される場所                                                       | 反復実行で動作するか                                                       |
| ---------- | --------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ---------------------------------------------------------------- |
| **Legacy** | `CpiProgram` `0xff…08` (`invoke`, `invoke_signed`), `HelperProgram` `0xff…09`, `Withdraw` `0x42…16` | 即時に、EVM ステップ内の実際の CPI として                                        | **いいえ** — 反復トランザクション内の legacy CPI は `CpiProhibitedInIterativeTx` |
| **Cached** | `SplCached` `0xff…05`, `ASplCached` `0xff…06`, `SystemCached` `0xff…04`, `WithdrawCached` `0xff…0b` | オーバーレイにステージされ、トランザクションの最後に CPI として確定されます。EVM の revert はそれらを破棄します | はい                                                               |

プログラム統合にとってこれが意味すること：

* **自分のプログラムの命令を呼ぶのは legacy トラックのみです。** cached トラックには汎用 `invoke`はありません。SPL 転送、ATA 作成、system-program 操作、ガス引き出しをカバーします。
* したがって、アダプタに資金を出すステップも、CPI と同じトランザクション内で実行されるなら legacy トラックでなければなりません。cached ラッパーの `transferFrom` は cached トラックの呼び出しなので、あなたの CPI と同じトランザクションを共有できません（そしてセクション 3 が示すように、そこでできるのは escrow 台帳への記帳だけです）。代わりに `HelperProgram.transfer_spl(userAta, adapterAta, amount, mint)` で引き込んでください。ユーザーがアダプタを SPL delegate にしたあとで（`approve_spl`、これはユーザーが HelperProgram に直接送ります）。引き込みと CPI はどちらも legacy トラックなので、1 つのトランザクションで実行されます。
* **そのトランザクションからラッパーを外してください。** ラッパーの mutating 関数（`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 なし）。どちらのトラックでも、どちらの実行モードでも許可されます。前提チェックはそれらで行ってください。1 つ順序ルールがあります。トランザクション内で cached の変更が一度でも発火したら、その残りでは legacy トラックの読み取りがブロックされます。先に読んでから変更してください。

## 5. アトミックが予算です

アトミックな Rome トランザクションは 1 つの Solana トランザクションです。およそ **140 万 compute unit**、 **64 アドレス** のアカウントリストと **4 KB** のワイヤサイズ（Solana v1 トランザクション）です。Rome プログラムとあなたの CPI はその予算を共有します。ラッパー転送は Hadrian では約 170K CU で、あなたの命令も独自の CU を加えます。Solana レシートの `computeUnitsConsumed`を使って計測してください、EVM ではなく `gasUsed`.

エミュレーションがトランザクションに収まらないと判断すると、Rome はそれを **反復的に** 複数の Solana トランザクションにまたがって実行し、その中の legacy CPI は失敗します。deposit と withdraw はそれぞれ 1 回のトークン移動と、あなたのプログラムへの 1 回の CPI に収め、周囲の Solidity は小さく保ってください。より大きいものは 2 つのユーザートランザクションに分割してください。

CPI 深さ：Solana は 4 階層を許し、Rome はそのうち 1 階層を使うので、あなたの命令は 2 階層目で実行され、その下に 2 階層あります（あなたのプログラム → SPL Token で 1 階層残る）。

## 6. アカウントのプロビジョニング

あなたのプログラムは、実行時に Solidity からアカウントを受け取りません。プロキシ **は** 送信前にすべてのトランザクションをエミュレートし、CPI が触れたすべての Solana アカウントを記録して、Solana トランザクションにそれらを配置します。あなたのアダプタは `invoke_signed` アカウントリストにアカウントを名指しします。エミュレーションがそれらを解決できることを証明します。そこから 3 つのことが導かれます：

* あなたの命令が触れるすべてのアカウントは、アダプタが持つ入力（自身の PDA とサブ PDA、あなたのプログラム ID、mint、ユーザーのアドレス）から導出できなければなりません。 `SystemProgram.find_program_address` および `CpiProgram.pdas_batch_derive` は Solidity で導出を行います。
* まだ存在しないアカウント（新しいポジション、新しい ATA）も、アカウントリストに名指しされていなければなりません。そのアドレスが Solana トランザクションへ渡されます。
* トランザクションが触れるすべて — ユーザー、アダプタ、ラッパー向けの Rome 自身のアカウントも含めて — は 64 アドレス未満に収まらなければなりません。1 回の呼び出しで 10 の市場に触れる設計は収まりません。

Solana ウォレット・レーンでは、 `rome_emulateCallAccounts` が同じディスカバリをクライアントに公開します。SDK がそれを使います。

CPI が決して名指ししてはならない 2 つのアカウントがあります。トランザクションを送る Solana の料金支払者（ただし通常の System transfer instruction の内部は除く）と、Rome プログラム自身です。Rome プログラムへの CPI 呼び戻しは拒否されます。

## 7. Solidity での deposit と withdraw

legacy トラック上のアダプタの最小スケッチです。ユーザーはすでに `approve_spl(adapter, amount, mint)` を HelperProgram へ送っています（セクション 3）。 `PRIVACY_PROGRAM` があなたのプログラム ID です； `encodeDeposit` / `encodeWithdraw` はあなたの命令データを構築します（Borsh、little-endian）；アカウント meta はあなたの命令のレイアウトに従います。

```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: アダプタの権限
        bytes32 adapterAta = Helper.ata(address(this), USDC_MINT);
        bytes32 position   = Helper.pda_with_salt(address(this), _salt(msg.sender)); // ユーザーごとのサブ PDA、これも署名する

        // ユーザーのトークンアカウントから引き込みます。アダプタの権限が、ユーザーが付与した SPL
        // delegate として署名します。これは下の CPI と同じく、legacy トラックの呼び出しです。
        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);                          // source: アダプタの権限が所有
        accs[3] = ICrossProgramInvocation.AccountMeta(_vaultFor(position), false, true);                 // あなたのプログラムの vault
        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);            // 宛先：ユーザー自身のアカウント
        // ... 同じ形です：あなたのプログラムが vault から userAta へ `amount` を移し、`position` が署名します
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeWithdraw(amount), salts);
    }
}
```

アダプタは決して `wUSDC` コントラクトを呼びません。引き込みはユーザーのデリゲーションを使って支払う HelperProgram の呼び出しであり、トークンは `external_auth(adapter)` が所有するトークンアカウントに置かれるため、CPI でそのトークンを使えるのです。

署名者についての注記。Rome が署名するのは 2 種類のアカウントだけです：呼び出し元コントラクトの素の権限（`Helper.pda(address(this))`）、これは `ソルト`なしで署名し、そして `ソルト`の各エントリに対して 1 つのソルト付きサブ PDA です。列挙したソルトはすべて署名者としてアカウントリストに現れなければならず、そうでないと呼び出しは `提供されたシードから計算された signer account が見つかりませんでした`で失敗します。ユーザー自身の権限を含め、署名者としてマークされたその他のアカウントには Rome から seed は与えられず、Solana runtime は CPI を拒否します。ユーザーが自分のトークンに対して持つ権利はデリゲーションから来るのであって、アダプタがユーザーとして署名することから来るのではありません。

引き込みなしのデリゲーション：あなたのプログラムがユーザーのトークンアカウントから直接使うべきなら、ユーザーは `HelperProgram.approve_spl_raw_delegate(userAta, yourProgramPda, amount, mint, decimals)` を HelperProgram に直接送り、あなたのプログラムの PDA を SPL delegate として指定します。Rome ブリッジはこれを Wormhole に使います。セクション 3 の 1 デリゲート規則はここにも当てはまります：その付与はラッパーのものを置き換えます。

## 8. テスト

* へデプロイしてください **Hadrian** （testnet、chain 200010）を最初に。アドレスと RPC は [Contract Addresses](https://docs.rome.builders/ja/rifarensu/contract-addresses.md) そして [registry](https://github.com/rome-protocol/rome-registry).
* `eth_call` および `eth_estimateGas` プロキシが送信に使うのと同じエミュレーションを実行するので、そこで失敗する CPI は同じ理由でチェーン上でも失敗し、revert データには基底の Solana エラー（`non-evm call error: …` ）が Solana プログラムログに載ります。
* 着地した EVM トランザクションの Solana 側は `rome_solanaTxForEvmTx(hash)`で読み取ります。Solana レシートに CU とあなたのプログラムのログがあります。
* が動作する CPI は `eth_call` として送ると拒否されるものの、たいていはエミュレーションが報告する制約に引っかかっています：64 アドレス上限、アトミック CU 予算（トランザクションが iterative になった）、またはトラック規則です。

## 9. リファレンス

* [プリコンパイルリファレンス](https://docs.rome.builders/ja/rifarensu/precompiles.md) — すべてのプリコンパイル上のすべてのセレクタと、その dispatch クラスおよび delegatecall ルール。
* [制約](https://docs.rome.builders/ja/ji-ben-gai-nian/constraints.md) — 上記の制約を 1 つの表にまとめたもの。
* [トークン相互運用](https://docs.rome.builders/ja/ji-ben-gai-nian/token-interop.md) — ラッパー、canonical 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) （1 つの共有マーケット上の Compound III レンディングアプリ。Solidity から Solana プログラムを呼び出しません（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/ja/gaido/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.
