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

# Çift hatlı bir uygulama oluşturma

Çift şeritli bir uygulamanın adım adım incelemesi — hem bir MetaMask kullanıcısı hem de bir Solana cüzdanı kullanıcısı tarafından kullanılan tek bir Solidity sözleşmesi ve her adımda tam olarak ne olduğu.

Bir **çift şeritli uygulama** hem bir **MetaMask (EVM)** kullanıcısı hem de bir **Solana cüzdanı** kullanıcısının doğrudan kullandığı tek bir Solidity sözleşmesidir — aynı sözleşme, aynı durum; her biri zaten sahip olduğu cüzdanla. Bu sayfa *tam olarak* her adımda, her iki tarafta neler olduğunu açıklar.

Örnek, küçük bir **kasadır**: siz `yatırma` USDC yatırır ve daha sonra `withdraw` onu çekersiniz. "Stake / unstake", "supply / redeem", "tip / claim" aynı yapıya sahiptir.

## Yazdığınız şey — standart bir ERC-20 kasası

Rome'da, bir Solana kullanıcısının USDC'si EVM tarafında sıradan bir **ERC-20 tokenı** olarak görünür — o mint için SPL sarmalayıcısı (ör. `wUSDC`). Dolayısıyla sözleşmeniz normal bir token kasasıdır: tokenları şununla çeker `transferFrom` ve şununla iade eder `transfer`. Rome'a özgü hiçbir şey yok:

```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 sarmalayıcısı
    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));
    }
}
```

> **Neden ERC-20, neden değil `payable` / `msg.value`?** Bir Solana kullanıcısının harcanabilir bakiyesi, onun **cüzdanının SPL token hesabıdır**, bu ERC-20 sarmalayıcısı olarak 1:1 yansıtılır — *değil* EVM yerel bakiyesi değil. Dolayısıyla bir Solana kullanıcısı her zaman bir `transferFrom`fonlayabilir, ancak bir `deposit() payable` normalde sahip olmadıkları yerel değere ihtiyaç duyar. Token etrafında geliştirin; her iki şerit de aynı şekilde çalışır.

Foundry veya Hardhat ile dağıtın; oluşturucuyu tokenınızın sarmalayıcı adresine yönlendirin ( [kaydında](https://github.com/rome-protocol/rome-registry)). Rome'da gas tokenı USDC'dir; dolayısıyla dağıtım için biraz USDC gas bakiyesine ihtiyacınız vardır.

## İki şerit

| Şerit      | Cüzdan                                                 | Uygulamanın onu çağırma şekli                                               |
| ---------- | ------------------------------------------------------ | --------------------------------------------------------------------------- |
| **EVM**    | MetaMask (bir EVM anahtarı)                            | `submitRomeTx` — standart Rome yazma işlemi                                 |
| **Solana** | Solflare gibi bir Solana cüzdanı (bir Solana anahtarı) | `submitRomeTxV1` — çağrı başına bir Solana v1 işlemi, EVM anahtarı gerekmez |

EVM şeridi sıradandır. Bu sayfanın geri kalanı **Solana kanalı** — ilginç yarıdır.

## Temel fikir: sentetik bir geçiş yoludur

Bir Solana kullanıcısının EVM kimliği şudur: **sentetik adresidir** — `keccak256(solana_pubkey)[12:]`. Sözleşmedeki `msg.sender` kimliğidir, ancak **dinlenme hâlinde hiçbir şey tutmaz.** Kullanıcının parası şurada bulunur: **Solana cüzdanı** (SPL USDC olarak) ve EVM tarafında aynı bakiye `wUSDC.balanceOf(synthetic)` tarafından okunur. Değer şuradan akar: *içinden* sentetik üzerinden:

* **Girişte** (yatırma): cüzdan token hesabı → sentetik token hesabı → sözleşme ( `transferFrom`).
* **Çıkışta** (çekme): sözleşme → sentetik token hesabı → cüzdan token hesabı.

Sentetik, her gidiş-dönüşün ardından tekrar sıfıra iner.

## Tek seferlik: Etkinleştirme (sentetiği sağlama)

Yepyeni bir sentetiğin zincir üzerindeki hesabı, siz onu oluşturana kadar mevcut değildir. Bir Solana kullanıcısı ilk kez işlem yaptığında, sentetikleri **sağlanır** ile bir `create_pda` çağrısıyla — sonrasında değer taşıyan çağrılar (ERC-20 `transferFrom`, sweep) onun tarafından imzalanabilir.

`submitRomeTxV1` bunu sizin için yapmaz; bu nedenle ilk değer taşıyan çağrıdan önce açıkça, bir kez sağlayın. Bunun için iyi bir yer "Etkinleştir" adımı veya ilk approve işleminden hemen öncesidir:

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

const synthetic = syntheticAddress(wallet.publicKey);
const deps = { connection, proxyUrl, chainId, programId, signer }; // signer: scriptlerde bir Keypair, cüzdan uygulamasında bir LaneSigner
if (!(await isSyntheticProvisioned(connection, programId, synthetic))) {
  await submitRomeTxV1(deps, buildCreatePdaCall(synthetic)); // bir create_pda
}
```

## Tek seferlik: sarmalayıcıya yetki verin

wUSDC sarmalayıcısı, kullanıcının tokenlarını kendi **SPL delegesi** token hesabının delegesi olarak taşır; dolayısıyla her kullanıcının ilk yatırmadan önce sarmalayıcı başına bir kez buna izin vermesi gerekir. Bu hem MetaMask kullanıcısı hem de Solana kullanıcısının sentetik adresi için geçerlidir. İzin olmadan, cüzdandan yapılan her `transferFrom` işlem başarısız olur ve yatırma SPL hatasıyla geri alınır `0x4` (sahip uyuşmazlığı).

Sarmalayıcının görünüm fonksiyonuyla kontrol edin `isEnabled(user)`. Eğer şunu döndürürse: `false`, şunu gönderin: `approve_spl(wrapper, 2^64-1, mint)` doğrudan şu adresteki Helper ön derlemesine: `0xff00000000000000000000000000000000000009`; mint şudur: `mint_id()` sarmalayıcı üzerinde. EVM şeridinde bu bir `submitRomeTx` çağrısıdır, Solana şeridinde ise bir `submitRomeTxV1` çağrısıdır:

```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) }); // zincirin RPC'sinde bir viem istemcisi

// who: MetaMask adresi veya Solana kullanıcısı için syntheticAddress(wallet.publicKey)
let grant = null; // isEnabled true olduğunda null kalır
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 şeridi:    if (grant) await submitRomeTx(provider, { from: who, ...grant });
// Solana şeridi: if (grant) await submitRomeTxV1(deps, grant);
```

## Her tarafın ihtiyaçları

|                                | İhtiyaçlar                                                                               | Neden                                                                                                                                 |
| ------------------------------ | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| **Solana kullanıcısı**         | **SOL** (az miktarda)                                                                    | her şerit işleminde Solana işlem ücretini öder                                                                                        |
|                                | **SPL tokenı olarak USDC** cüzdanında                                                    | yatırdığı değer (EVM tarafında şu şekilde görülür: `wUSDC`)                                                                           |
| **EVM kullanıcısı (MetaMask)** | **USDC** Rome gas bakiyesi olarak                                                        | gas ve sarıldıktan sonra yatırdığı değer; bunu **USDC köprüleyerek** Rome'a aktararak yükler (faucet yoktur)                          |
|                                | bir **sarma işlemi** bu gasın bir kısmını şuna dönüştürme: **wUSDC** (`withdraw_to_ata`) | kasa, yerel gası değil ERC-20 sarmalayıcısı olan wUSDC'yi kabul eder. MetaMask'taki gas USDC bakiyesi sarılana kadar wUSDC değildir   |
|                                | tek seferlik **sarmalayıcı izni** (`approve_spl`)                                        | wUSDC sarmalayıcısının tokenlarını taşımasına izin verir; bkz. [Tek seferlik: sarmalayıcıya yetki verin](#one-time-grant-the-wrapper) |
| **Siz (geliştirici)**          | şunu içeren bir cüzdan: **USDC** Rome'da gas                                             | sözleşmeyi dağıtmak için                                                                                                              |

## Değer GİRİŞİ — yatırma (adım adım)

Solana kullanıcısının Solana cüzdanında SOL + USDC vardır. Her adım bir Solana v1 işlemidir, **bu cüzdan tarafından imzalanır**, ve uygulama bunu Solana RPC'ye gönderir. Fonlama ayağı uygulamada oluşturulur ve cüzdan bunu tek bir istemle imzalar; her sözleşme çağrısı proxy tarafından oluşturulur ve cüzdan okunabilir bir yetkilendirme mesajından sonra bunu imzalar:

1. **Fonlama ayağı** — `buildFundLeg(...)` → `submitSolanaInstructionsV1(...)`. Sentetiğin USDC token hesabını (gerekirse) oluşturur ve şunu çalıştırır: **`ActivateAta`**, taşıyarak `miktar` cüzdanın token hesabından USDC'nin **sentetiğin hesabına**tarafından oluşturulan `wUSDC.balanceOf(synthetic)` bu bakiyeyi gösterir.
2. **Sarmalayıcıya izin verin** (şu durumda: `isEnabled` false) — `submitRomeTxV1(deps, { to: HELPER, data: approve_spl(wUSDC, 2^64-1, mint) })`. Bkz. [Tek seferlik: sarmalayıcıya yetki verin](#one-time-grant-the-wrapper). *(Kullanıcının ilk şerit çağrısıysa, bundan önce sentetiği sağlayın.)*
3. **Onayla** — `submitRomeTxV1(deps, { to: wUSDC, data: approve(vault, amount) })`. Kasanın tokenları çekmesini sağlar.
4. **Yatırma** — `submitRomeTxV1(deps, { to: vault, data: deposit(amount) })`. Kasa şunu çalıştırır: `transferFrom(synthetic, vault, amount)` — USDC, sentetikten kasaya taşınır ve sentetiğin adresine alacak kaydedilir.

**Net etki:** USDC şuraya gitti: **Solana cüzdanı → (sentetik) → kasa.**

```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: bir LaneSigner (payer, signAuthHash, signV1Wire) veya bir Keypair

// 1) fonlama ayağı — cüzdan USDC'si → sentetik token hesabı (cüzdan imzalar)
await submitSolanaInstructionsV1(
  buildFundLeg({ programId, chainId, mint: usdcMint, amount: depositAmount, wallet: wallet.publicKey, synthetic }),
  { connection, signer },
);

// 2) sarmalayıcıya bir kez izin verin (sentetik zaten sağlandı); `grant`, "Tek seferlik: sarmalayıcıya izin ver" altında oluşturulan çağrıdır veya isEnabled true olduğunda null'dır
if (grant) await submitRomeTxV1(deps, grant);

// 3) kasayı onaylayın
await submitRomeTxV1(deps, { to: wUSDC, data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [vault, depositAmount] }) });

// 4) yatırın — kasa transferFrom aracılığıyla çeker
await submitRomeTxV1(deps, { to: vault, data: encodeFunctionData({ abi, functionName: "deposit", args: [depositAmount] }) });
```

## Değer ÇIKIŞI — çekme (adım adım)

Şimdi kullanıcı çekim yapar. Bu da cüzdanla imzalanır; çağrı başına iki istem vardır:

1. **Çekme** — `submitRomeTxV1(deps, { to: vault, data: withdraw(amount) })`. `vault.withdraw` şunu çalıştırır: `transfer(synthetic, amount)` — USDC kasadan tekrar **sentetiğin** token hesabına taşınır.
2. **Süpürme ayağı** — `buildSweepLeg(...)` size şunu verir: `HelperProgram.transfer_spl` çağrı + hesaplar; USDC'yi sentetikten taşımak için bunu çalıştırın (gerekirse cüzdanın token hesabını şununla oluşturun: `submitSolanaInstructionsV1`, ardından Helper çağrısını şunun üzerinden gönderin: `submitRomeTxV1`; proxy token hesaplarını bulur) **kullanıcının kendi Solana cüzdanına geri**. Sentetik tekrar sıfıra iner.

**Net etki:** USDC şuraya gitti: **kasa → (sentetik) → kullanıcının Solana cüzdanı.** Hiçbir şey mahsur kalmaz.

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

// 1) çekme — kasa USDC'yi sentetiğin token hesabına iade eder
await submitRomeTxV1(deps, { to: vault, data: encodeFunctionData({ abi, functionName: "withdraw", args: [amount] }) });

// 2) süpürme ayağı — sentetik token hesabı → kullanıcının kendi cüzdan token hesabı
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 üzerinde ölçüldü

Aşağıdaki her Solana şeridi adımı Hadrian'da bir sürüm-1 işlemi olarak çalıştı:

| Adım                       | Hesaplama birimleri | Bayt  | Hesaplar |
| -------------------------- | ------------------- | ----- | -------- |
| Sağlama (`create_pda`)     | 39,008              | 703   | 9        |
| Sarma izni (`approve_spl`) | 50,687              | 899   | 13       |
| Onayla                     | 79,335              | 769   | 10       |
| Kasa yatırma               | 242,880             | 1,070 | 20       |
| Kasadan çekme              | 280,903             | 1,037 | 19       |
| Süpürme (`transfer_spl`)   | 46,810              | 899   | 13       |

## Dikkat edilmesi gerekenler

Elle oluşturulmuş bir Solana şeridi işleminin yanlış yaptığı şeyler bunlardır. SDK ve proxy'nin oluşturucusu bunların çoğunu ele alır:

* **Sağlama.** Yeni bir sentetiğin hesabı, herhangi bir değer taşıyan çağrıdan önce (`create_pda`) oluşturulmalıdır; aksi takdirde transferi imzalayamaz. `submitRomeTxV1` bunu sizin için yapmaz: şunu kontrol edin: `isSyntheticProvisioned` ve gönderin `buildCreatePdaCall(synthetic)` bir kez.
* **Sarmalayıcıya bir kez izin verin.** Sarmalayıcı, tokenları kullanıcının SPL delegesi olarak taşır. Şunu kontrol edin: `isEnabled` ve şunu gönderin: `approve_spl` ilk yatırmadan önce Helper ön derlemesine; aksi hâlde yatırma SPL hatasıyla geri alınır `0x4`.
* **Yerel değeri değil, sarmalayıcıyı harcayın `msg.value`.** Bir Solana kullanıcısının bakiyesi, ERC-20 sarmalayıcısı olarak yansıtılan SPL token hesabıdır — onu şununla taşıyın: `transfer` / `transferFrom`, asla yerel değerle değil.
* **Sizin için oluşturulur.** ComputeBudget, treasure cüzdanı ve hesap keşfi proxy'nin oluşturucusu tarafından yapılır; dolayısıyla bunların hiçbiri kodunuzda görünmez. Cüzdan imzalamadan önce SDK oluşturulan işlemi kontrol eder ve kullanıcının yetkilendirdiği çağrı dışındaki her şeyi reddeder.
* **Nereye gönderildiği.** Cüzdan v1 işlemini imzalar ve **uygulama bunu Solana RPC'ye gönderir** — işlemi oluşturan proxy'ye değil (aşağıdaki aktarımlı çağrı tek istisnadır; bkz. [İletilen çağrılar ve uzun çağrılar](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-evm-from-solana.md#relayed-calls-and-long-calls)). Zincir üzerinde program şunu türetir: `msg.sender` Solana imzalayıcısından.
* **Çağrı başına iki istem.** Cüzdan okunabilir bir yetkilendirme mesajını (`Rome yetkilendirmesi` ve EVM işlem hash'ini), ardından işlemi aynı anahtarla imzalar.
* **Cüzdanınızın v1 imzaladığını kontrol edin.** `signV1Wire` v1 mesajı üzerindeki 64 baytlık imzayı döndürmelidir; Wallet Standard üzerinden bu, `solana:signTransaction` ham wire üzerindedir ve `signedTransaction.slice(-64)`. Her cüzdan v1 işlemlerini henüz çözümlemiyor; bu nedenle üstüne geliştirme yapmadan önce sizinkini test edin. Bugün devnet'te Solflare bunları imzalar; Phantom henüz imzalamaz.
* **Büyük çağrılar aktarılır.** Tek bir işleme sığmayan bir çağrı, aynı yetkilendirme imzasıyla proxy tarafından aktarılır ve sonuç şuna sahiptir: `route: "relay"`. Aktarılan bir çağrı zincirin yerel gası ile ödenir; bu yüzden sentetiği şununla yükleyin: `fundSyntheticGas(deps, amountWei)`. Bkz. [İletilen çağrılar ve uzun çağrılar](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-evm-from-solana.md#relayed-calls-and-long-calls).
* **Gas USDC'dir.** Faucet yok — USDC'yi köprüleyin (bkz. [Fonlanma](https://docs.rome.builders/tr/kaynaklar/faucets.md)).

Önceki `submitRomeTxSolanaLane` hala SDK'dedir: istemcide eski bir Solana işlemi oluşturur (SDK tarafından ele alınan ComputeBudget ve treasure cüzdanıyla, tek cüzdan istemi).

## MetaMask'ten aynı uygulama

Bir EVM kullanıcısı aynı sözleşmeyi şununla çağırır: `submitRomeTx` — standart EVM araçları, USDC cinsinden gas. Solana kullanıcısından bir farkı vardır: MetaMask kullanıcısı **yerel gas USDC'si**tutar, wUSDC değil. Kasa wUSDC sarmalayıcısını kabul eder; bu nedenle kullanıcı önce gasının bir kısmını sarar, sonra sarmalayıcıya bir kez izin verir, ardından her zamanki ERC-20 adımlarını uygular. Sarılmış tokenlar zaten EVM adreslerinde bulunduğu için fonlama veya süpürme ayakları yoktur.

1. **Gas'ı wUSDC'ye sarın** — şunu gönderin: `withdraw_to_ata(wei)` şu adresteki Withdraw ön derlemesine: `0x4200000000000000000000000000000000000016`. Bu, o kadar yerel gası yakar ve eşdeğer miktarı kullanıcının gas tokenındaki token hesabına alacak kaydeder; bunu `wUSDC.balanceOf(user)` daha sonra gösterir. `wei` 18 ondalıklı gas birimindedir ve 10^12'nin (bir 6 ondalıklı wUSDC birimi) katı olmalıdır; aksi takdirde çağrı geri alınır. Kullanıcı zaten wUSDC tutuyorsa bu adımı atlayın.
2. **Sarmalayıcıya izin verin** (şu durumda: `isEnabled` false) — aynı `approve_spl` yukarıdaki çağrı, şununla gönderilir: `submitRomeTx`. Bkz. [Tek seferlik: sarmalayıcıya yetki verin](#one-time-grant-the-wrapper).
3. **Onayla** — `approve(vault, amount)` wUSDC üzerinde.
4. **Yatırma** — `deposit(amount)` kasa üzerinde. Çekme işlemi şudur: `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) bir miktar gas USDC'sini wUSDC'ye sarın (weiAmount 18 ondalıklı gas birimlerindedir)
await submitRomeTx(provider, { from: who, to: WITHDRAW, data: encodeFunctionData({ abi: withdrawAbi, functionName: "withdraw_to_ata", args: [weiAmount] }) });

// 2) sarmalayıcıya bir kez izin verin: `grant`, "Tek seferlik: sarmalayıcıya izin ver" altında oluşturulan çağrıdır veya null'dır
if (grant) await submitRomeTx(provider, { from: who, ...grant });

// 3) onaylama ve 4) yatırma, herhangi bir ERC-20'de olduğu gibi
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] }) });
```

Her iki kullanıcı da aynı `balanceOf` durumu kasada paylaşır.

## Sırada ne var

* [Solana'dan EVM'yi çağırma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-evm-from-solana.md) — Solana şeridi mekanikleri ayrıntılı olarak
* [EVM'den Solana'yı çağırma](https://docs.rome.builders/tr/gelistirici-kilavuzlari/call-solana-from-evm.md) — diğer yön (CPI)
* [Fonlanma](https://docs.rome.builders/tr/kaynaklar/faucets.md) — gas tokenı olarak USDC; köprüleyerek getirin


---

# 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/tr/gelistirici-kilavuzlari/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.
