> 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/dual-lane-app.md).

# デュアルレーンアプリを構築する

デュアルレーンアプリのステップバイステップ解説 — MetaMaskユーザーとSolanaウォレットユーザーの両方が使う1つのSolidityコントラクトで、各ステップで何が起こるかを正確に示します。

ある **デュアルレーンアプリ** は、両方が使う1つのSolidityコントラクトです **MetaMask（EVM）** ユーザーと **Solana ウォレット** ユーザーが直接使います — 同じコントラクト、同じ状態で、それぞれが既に持っているウォレットを使います。このページでは、 *ちょうど* 各ステップで、両側で何が起こるか。

例は小さな **保管庫**：あなたは `deposit` USDCを、そして後で `withdraw` それを。「ステーク／アンステーク」「供給／償還」「チップ／請求」は同じ形です。

## あなたが書くもの — 標準的なERC-20保管庫

Rome上では、SolanaユーザーのUSDCはEVM側で通常の **ERC-20トークン** — そのミント用のSPLラッパー（例： `wUSDC`）。そのため、あなたのコントラクトは普通のトークン保管庫です：トークンを `transferFrom` そして `transfer`で返します。

```solidity
interface IERC20 {
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

contract Vault {
    IERC20 public immutable token;                 // wUSDCラッパー
    mapping(address => uint256) public balanceOf;
    constructor(IERC20 _token) { token = _token; }

    function deposit(uint256 amount) external {
        require(token.transferFrom(msg.sender, address(this), amount));
        balanceOf[msg.sender] += amount;
    }
    function withdraw(uint256 amount) external {
        balanceOf[msg.sender] -= amount;
        require(token.transfer(msg.sender, amount));
    }
}
```

> **なぜERC-20なのか、ではなく `payable` / `msg.value`?** Solanaユーザーの使用可能残高は、そのユーザーの **ウォレットのSPLトークンアカウントです**、このERC-20ラッパーとして1対1で表面化します — *ではなく* EVMネイティブ残高です。そのためSolanaユーザーは常に `transferFrom`に資金を入れられます `deposit() payable` は、静止状態では保有していないネイティブ価値を必要とします。トークンを中心に作れば、両方のレーンが同じように動きます。

FoundryまたはHardhatでデプロイし、コンストラクタをあなたのトークンのラッパーアドレス（ [registry](https://github.com/rome-protocol/rome-registry)）。RomeではガストークンはUSDCなので、デプロイするには少量のUSDCガス残高が必要です。

## 2つのレーン

| レーン        | ウォレット                             | アプリがそれを呼び出す方法                                             |
| ---------- | --------------------------------- | --------------------------------------------------------- |
| **EVM**    | MetaMask（EVMキー）                   | `submitRomeTx` — 標準的なRome書き込み                             |
| **Solana** | SolflareのようなSolanaウォレット（Solanaキー） | `submitRomeTxV1` — 1回の呼び出しにつきSolana v1トランザクション1件、EVMキーは不要 |

EVMレーンは通常どおりです。このページの残りは **Solana レーン** — 面白い半分です。

## 重要な考え方：シンセティックはパススルーです

SolanaユーザーのEVMアイデンティティは、そのユーザーの **合成アドレス** — `keccak256(solana_pubkey)[12:]`。それはそのユーザーの `msg.sender` コントラクト上の〜ですが、 **静止状態では何も保持しません。** ユーザーの資金はそのユーザーの **Solana ウォレット** （SPL USDCとして）にあり、EVM側ではその同じ残高が `wUSDC.balanceOf(synthetic)` を読み取ります。価値は *を経由して* シンセティックを通して：

* **入り** （入金）：ウォレットのトークンアカウント → シンセティックのトークンアカウント → コントラクト（ `transferFrom`).
* **出り** （出金）：コントラクト → シンセティックのトークンアカウント → ウォレットのトークンアカウント。

シンセティックは往復のたびに差し引きゼロになります。

## 一度だけ：有効化（シンセティックをプロビジョニング）

新規のシンセティックのオンチェーンアカウントは、作成するまで存在しません。Solanaユーザーが最初に操作するとき、そのシンセティックは **プロビジョニングされます** とともに `create_pda` 呼び出し — その後は、価値を移動する呼び出し（ERC-20 `transferFrom`、スイープ）はそれで署名できます。

`submitRomeTxV1` はこれを自動では行わないので、最初の価値移動呼び出しの前に、明示的に一度プロビジョニングしてください。よい場所は「有効化」ステップ、または最初のapproveの直前です：

```javascript
import { submitRomeTxV1, isSyntheticProvisioned, buildCreatePdaCall, syntheticAddress } from "@rome-protocol/sdk";

const synthetic = syntheticAddress(wallet.publicKey);
const deps = { connection, proxyUrl, chainId, programId, signer }; // signer: スクリプトではKeypair、ウォレットアプリではLaneSigner
if (!(await isSyntheticProvisioned(connection, programId, synthetic))) {
  await submitRomeTxV1(deps, buildCreatePdaCall(synthetic)); // create_pdaを1回
}
```

## を HelperProgram に送るよう求めてください。これはラッパーが想定する最大付与と同じです（

wUSDCラッパーはユーザーのトークンを **SPL デリゲート** そのトークンアカウントの〜なので、各ユーザーは最初の入金前に、ラッパーごとに一度だけその権限を付与する必要があります。これはMetaMaskユーザーにもSolanaユーザーのシンセティックアドレスにも同様に適用されます。許可がないと、すべての `transferFrom` ウォレットからの〜は失敗し、入金はSPLエラーでロールバックします `0x4` （owner mismatch）で revert します。

ラッパーのviewで確認してください `isEnabled(user)`。それが返す場合は `を呼び出し、返り値が`、〜を送ってください `なら、ユーザーに再度` 直接Helperプリコンパイルへ `0xff00000000000000000000000000000000000009`; ミントは `mint_id()` ラッパー上にあります。EVMレーンではこれは〜です `submitRomeTx` 呼び出し、Solanaレーンでは〜 `submitRomeTxV1` 呼び出し：

```javascript
import { submitRomeTx, submitRomeTxV1, syntheticAddress } from "@rome-protocol/sdk";
import { createPublicClient, encodeFunctionData, http, parseAbi } from "viem";

const HELPER = "0xff00000000000000000000000000000000000009";
const wrapperAbi = parseAbi(["function isEnabled(address user) view returns (bool)", "function mint_id() view returns (bytes32)"]);
const grantAbi = parseAbi(["function approve_spl(address spender, uint64 amount, bytes32 mint)"]);

const publicClient = createPublicClient({ transport: http(rpcUrl) }); // チェーンのRPCに接続するviemクライアント

// who: MetaMaskアドレス、またはSolanaユーザーの場合はsyntheticAddress(wallet.publicKey)
let grant = null; // isEnabledがtrueのときはnullのまま
if (!(await publicClient.readContract({ address: wUSDC, abi: wrapperAbi, functionName: "isEnabled", args: [who] }))) {
  const mint = await publicClient.readContract({ address: wUSDC, abi: wrapperAbi, functionName: "mint_id" });
  grant = { to: HELPER, data: encodeFunctionData({ abi: grantAbi, functionName: "approve_spl", args: [wUSDC, 2n ** 64n - 1n, mint] }) };
}
// EVMレーン：grantがあればsubmitRomeTx(provider, { from: who, ...grant })をawaitする
// Solanaレーン：grantがあればsubmitRomeTxV1(deps, grant)をawaitする
```

## それぞれの側に必要なもの

|                       | 必要なもの                                              | 理由                                                                                                                   |
| --------------------- | -------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| **Solanaユーザー**        | **SOL** （少し）                                       | 各レーンのトランザクションごとにSolanaのトランザクション手数料を支払う                                                                               |
|                       | **SPLトークンとしてのUSDC** そのウォレット内の                      | 彼らが入金する価値（EVM側では〜として見える） `wUSDC`)                                                                                    |
| **EVMユーザー（MetaMask）** | **USDC** 彼らのRomeガス残高として                            | ガスとして、そしてラップ後に入金する価値として。彼らはそれを次で補充します **USDCをブリッジする** Romeへ（ファウセットはありません）                                            |
|                       | a **ラップ** そのガスの一部を〜に **wUSDC** (`withdraw_to_ata`) | 保管庫はwUSDC、つまりERC-20ラッパーを受け取り、ネイティブガスは受け取りません。MetaMaskのガスUSDC残高は、ラップされるまではwUSDCではありません                                |
|                       | 一度だけの **ラッパー許可** (`approve_spl`)                   | wUSDCラッパーが彼らのトークンを移動できるようにします。参照： [を HelperProgram に送るよう求めてください。これはラッパーが想定する最大付与と同じです（](#one-time-grant-the-wrapper) |
| **あなた（ビルダー）**         | 〜を持つウォレット **USDC** Rome上のガス                        | コントラクトをデプロイするための                                                                                                     |

## 入力価値 — 入金（ステップごと）

SolanaユーザーはSolanaウォレットにSOL + USDCを持っています。各ステップはSolana v1トランザクションで、 **そのウォレットで**署名され、アプリがそれをSolana RPCに送ります。資金移動レッグはアプリ内で組み立てられ、ウォレットは1回のプロンプトで署名します。各コントラクト呼び出しはプロキシによって構成され、ウォレットは読みやすい承認メッセージの後に署名します：

1. **資金移動レッグ** — `buildFundLeg(...)` → `submitSolanaInstructionsV1(...)`。必要ならシンセティックのUSDCトークンアカウントを作成し、〜を実行します **`ActivateAta`**、 `量` ウォレットのトークンアカウントからのUSDC **シンセティックの**。すると `wUSDC.balanceOf(synthetic)` その残高を示します。
2. **ラッパーに許可を与える** （〜のとき `isEnabled` がfalse）; `submitRomeTxV1(deps, { to: HELPER, data: approve_spl(wUSDC, 2^64-1, mint) })`。参照 [を HelperProgram に送るよう求めてください。これはラッパーが想定する最大付与と同じです（](#one-time-grant-the-wrapper). *（これがユーザーの最初のレーン呼び出しなら、その前にシンセティックをプロビジョニングしてください。）*
3. **承認** — `submitRomeTxV1(deps, { to: wUSDC, data: approve(vault, amount) })`。保管庫がトークンを引き出せるようにします。
4. **入金** — `submitRomeTxV1(deps, { to: vault, data: deposit(amount) })`。保管庫は〜を実行します `transferFrom(synthetic, vault, amount)` — USDCがシンセティックから保管庫へ移動し、シンセティックのアドレスに計上されます。

**正味の効果：** USDCは **Solanaウォレット → （シンセティック）→ 保管庫へ移動しました。**

```javascript
import { syntheticAddress, buildFundLeg, submitSolanaInstructionsV1, submitRomeTxV1 } from "@rome-protocol/sdk";
import { encodeFunctionData, erc20Abi } from "viem";

const synthetic = syntheticAddress(wallet.publicKey);
const deps = { connection, proxyUrl, chainId, programId, signer }; // signer: LaneSigner（payer, signAuthHash, signV1Wire）またはKeypair

// 1) 資金移動レッグ — ウォレットのUSDC → シンセティックのトークンアカウント（ウォレットが署名）
await submitSolanaInstructionsV1(
  buildFundLeg({ programId, chainId, mint: usdcMint, amount: depositAmount, wallet: wallet.publicKey, synthetic }),
  { connection, signer },
);

// 2) ラッパーに一度だけ許可を与える（シンセティックはすでにプロビジョニング済み）; `grant`は「一度だけ：ラッパーに許可を与える」で構成された呼び出し、またはisEnabledがtrueのときはnull
if (grant) await submitRomeTxV1(deps, grant);

// 3) 保管庫を承認する
await submitRomeTxV1(deps, { to: wUSDC, data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [vault, depositAmount] }) });

// 4) 入金 — 保管庫がtransferFromで引き出す
await submitRomeTxV1(deps, { to: vault, data: encodeFunctionData({ abi, functionName: "deposit", args: [depositAmount] }) });
```

## 出力価値 — 出金（ステップごと）

ここでユーザーが出金します。これもウォレット署名で、1回の呼び出しにつき2つのプロンプトがあります：

1. **Withdraw** — `submitRomeTxV1(deps, { to: vault, data: withdraw(amount) })`. `vault.withdraw` を実行します `transfer(synthetic, amount)` — USDCが保管庫から〜へ戻ります **シンセティックの** トークンアカウント。
2. **スイープレッグ** — `buildSweepLeg(...)` を返します `HelperProgram.transfer_spl` 呼び出し + アカウント。必要ならウォレットのトークンアカウントを作成して実行し、 `submitSolanaInstructionsV1`、その後Helper呼び出しを〜で送ります `submitRomeTxV1`; プロキシがトークンアカウントを見つけます）して、USDCをシンセティックから移動します **ユーザー自身のSolanaウォレットへ戻す**。シンセティックは差し引きゼロになります。

**正味の効果：** USDCは **保管庫 → （シンセティック）→ ユーザーのSolanaウォレット。** 取り残されるものはありません。

```javascript
import { buildSweepLeg } from "@rome-protocol/sdk";

// 1) 出金 — 保管庫がUSDCをシンセティックのトークンアカウントへ戻す
await submitRomeTxV1(deps, { to: vault, data: encodeFunctionData({ abi, functionName: "withdraw", args: [amount] }) });

// 2) スイープレッグ — シンセティックのトークンアカウント → ユーザー自身のウォレットのトークンアカウント
const sweep = buildSweepLeg({ programId, mint: usdcMint, amount, wallet: wallet.publicKey, synthetic });
await submitSolanaInstructionsV1([sweep.ensureWalletAtaIx], { connection, signer });
await submitRomeTxV1(deps, { to: sweep.helperTo, data: sweep.calldata });
```

## Hadrianで計測

以下の各Solanaレーンのステップは、Hadrian上でv1トランザクション1件として実行されました：

| ステップ                   | 計算ユニット  | バイト数  | アカウント |
| ---------------------- | ------- | ----- | ----- |
| プロビジョニング（`create_pda`) | 39,008  | 703   | 9     |
| ラッパーの許可（`approve_spl`) | 50,687  | 899   | 13    |
| 承認                     | 79,335  | 769   | 10    |
| 保管庫への入金                | 242,880 | 1,070 | 20    |
| 保管庫からの出金               | 280,903 | 1,037 | 19    |
| スイープ（`transfer_spl`)   | 46,810  | 899   | 13    |

## 注意点

これらは、手作りのSolanaレーン・トランザクションで起こりがちな誤りです。SDKとプロキシのコンポーザーがその大半を処理します：

* **プロビジョニング。** 新しいシンセティックのアカウントは作成される必要があります（`create_pda`）価値を移動する呼び出しの前でなければならず、そうでないと転送に署名できません。 `submitRomeTxV1` は自動では行いません：確認してください `isSyntheticProvisioned` 、そして送信します `buildCreatePdaCall(synthetic)` 一度
* **ラッパーに一度だけ許可を与える。** ラッパーはユーザーのSPLデリゲートとしてトークンを移動します。確認してください `isEnabled` そして送信してください `approve_spl` 最初の入金前にHelperプリコンパイルへ、さもないと入金はSPLエラーでロールバックします `0x4`.
* **ラッパーを使って支払ってください、ネイティブではなく `msg.value`.** Solanaユーザーの残高はそのSPLトークンアカウントであり、ERC-20ラッパーとして表面化します — それを動かすには `transfer` / `transferFrom`、ネイティブ価値では決してありません。
* **あなたのために構成されます。** ComputeBudget、treasure wallet、アカウント探索はプロキシのコンポーザーが行うため、コードには一切現れません。ウォレットが署名前に、SDKは構成済みトランザクションをチェックし、ユーザーが承認した呼び出し以外は拒否します。
* **送信先** ウォレットがv1トランザクションに署名し、 **アプリがそれをSolana RPCに送ります** — プロキシではありません。プロキシはそれを構成します（例外は下のリレード呼び出しです。参照： [中継呼び出しと長い呼び出し](https://docs.rome.builders/ja/gaido/call-evm-from-solana.md#relayed-calls-and-long-calls)）。オンチェーンでは、プログラムが `msg.sender` Solana署名者から
* **1回の呼び出しにつき2つのプロンプト。** ウォレットは読みやすい承認メッセージ（`Rome認可` とEVMトランザクションハッシュ）に署名し、その後トランザクションにも、どちらも同じキーで署名します。
* **あなたのウォレットがv1に署名することを確認してください。** `signV1Wire` はv1メッセージに対する64バイト署名を返さなければなりません。Wallet Standard経由ではそれは `solana:signTransaction` 生のワイヤ上では〜であり、 `signedTransaction.slice(-64)`。まだすべてのウォレットがv1トランザクションを解読できるわけではないので、これに基づいて構築する前にあなたのものをテストしてください。今日のdevnetでは、Solflareは署名しますが、Phantomはまだしません。
* **大きな呼び出しはリレイされます。** 1つのトランザクションに収まらない呼び出しは、同じ承認署名でプロキシによってリレイされ、その結果には `route: "relay"`。リレイ呼び出しの支払いはチェーンのネイティブガスで行われるため、シンセティックを〜で補充してください `fundSyntheticGas(deps, amountWei)`。参照 [中継呼び出しと長い呼び出し](https://docs.rome.builders/ja/gaido/call-evm-from-solana.md#relayed-calls-and-long-calls).
* **ガスはUSDCです。** ファウセットはありません — USDCをブリッジしてください（参照： [資金を用意する](https://docs.rome.builders/ja/rissu/faucets.md)).

以前の `submitRomeTxSolanaLane` はまだSDKにあります：クライアント側でレガシーSolanaトランザクションを構築します（ウォレットのプロンプトは1回で、ComputeBudgetとtreasure walletはSDKが処理します）。

## MetaMaskから同じアプリ

EVMユーザーは同じコントラクトを `submitRomeTx` — 標準的なEVMツールチェーン、ガスはUSDCです。Solanaユーザーとの違いは1つあります：MetaMaskユーザーが持つのは **ネイティブガスUSDC**、wUSDCではありません。保管庫はwUSDCラッパーを受け取るので、ユーザーはまずガスの一部をラップし、その後ラッパーに一度だけ許可を与え、あとは通常どおりERC-20の手順を行います。ラップ済みトークンはすでにEVMアドレスに存在するため、資金移動レッグやスイープレッグはありません。

1. **ガスをwUSDCにラップする** — 送信してください `withdraw_to_ata(wei)` Withdrawプリコンパイルへ〜を `0x4200000000000000000000000000000000000016`。その分のネイティブガスを焼却し、同額をガストークンのユーザーのトークンアカウントに付与します。これは `はユーザーの ATA を参照します。` その後表示されます。 `wei` は18桁のガス単位で、10^12（6桁のwUSDC単位）の倍数でなければならず、そうでないと呼び出しはロールバックします。ユーザーがすでにwUSDCを持っているなら、この手順は省略してください。
2. **ラッパーに許可を与える** （〜のとき `isEnabled` がfalse）—同じ `approve_spl` 上記の呼び出しを〜で送信し、 `submitRomeTx`。参照 [を HelperProgram に送るよう求めてください。これはラッパーが想定する最大付与と同じです（](#one-time-grant-the-wrapper).
3. **承認** — `approve(vault, amount)` wUSDC上で。
4. **入金** — `deposit(amount)` 保管庫上で。出金は `withdraw(amount)`.

```javascript
import { submitRomeTx } from "@rome-protocol/sdk";
import { encodeFunctionData, erc20Abi, parseAbi } from "viem";

const WITHDRAW = "0x4200000000000000000000000000000000000016";
const withdrawAbi = parseAbi(["function withdraw_to_ata(uint256 wei_)"]);

// 1) いくらかのガスUSDCをwUSDCにラップする（weiAmountは18桁のガス単位）
await submitRomeTx(provider, { from: who, to: WITHDRAW, data: encodeFunctionData({ abi: withdrawAbi, functionName: "withdraw_to_ata", args: [weiAmount] }) });

// 2) ラッパーに一度だけ許可を与える：`grant`は「一度だけ：ラッパーに許可を与える」で作成された呼び出し、またはnull
if (grant) await submitRomeTx(provider, { from: who, ...grant });

// 3) 承認し、4) 入金する。通常のERC-20と同じです
await submitRomeTx(provider, { from: who, to: wUSDC, data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [vault, depositAmount] }) });
await submitRomeTx(provider, { from: who, to: vault, data: encodeFunctionData({ abi, functionName: "deposit", args: [depositAmount] }) });
```

両ユーザーは同じ `balanceOf` 保管庫内の状態

## 次は何をするか

* [Solana から EVM を呼び出す](https://docs.rome.builders/ja/gaido/call-evm-from-solana.md) — Solanaレーンの仕組みの詳細
* [EVM から Solana を呼び出す](https://docs.rome.builders/ja/gaido/call-solana-from-evm.md) — 逆方向（CPI）
* [資金を用意する](https://docs.rome.builders/ja/rissu/faucets.md) — ガストークンとしてのUSDC。ブリッジして取り込む


---

# 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/dual-lane-app.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.
