> 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/de/entwicklerleitfaden/open-to-solana-users.md).

# Öffne deinen Vertrag für Solana-Nutzer

Stellen Sie einen Solidity-Vertrag auf Rome (Hadrian-Testnetz, Rubicon-Mainnet) bereit und öffnen Sie ihn für Solana-Wallets — was der Vertrag benötigt, wie ein Solana-Wallet-Nutzer ihn aufruft, Adressen pro Netzwerk und ein Start ch

Eine Bereitstellung, zwei Arten von Nutzern. Ein Vertrag auf Rome wird von MetaMask-Nutzern mit ihrem EVM-Schlüssel und von Solana-Wallet-Nutzern (zum Beispiel Solflare) mit ihrem Solana-Schlüssel erreicht — dieselbe Adresse, derselbe Zustand. Diese Seite ist der End-to-End-Pfad: bereitstellen, den Vertrag Solana-bereit machen, die Solana-Lane in Ihre App einbinden und auf dem Mainnet ausliefern.

## 1. Auf dem Netzwerk bereitstellen, das Sie möchten

Rome-Chains sind standardmäßige EVM-Ziele: Hardhat, Foundry, viem und ethers funktionieren unverändert (vollständige Anleitung in [Solidity-Verträge bereitstellen](https://docs.rome.builders/de/entwicklerleitfaden/deploy-solidity.md)).

| Netzwerk                                                                    | Chain-ID | RPC                                         | Explorer                                                                              | Gas-Token | Wie man Gas bekommt                                                                                                                                                                                              |
| --------------------------------------------------------------------------- | -------- | ------------------------------------------- | ------------------------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [**Rubicon**](https://docs.rome.builders/de/netzwerke/rubicon.md) (Mainnet) | `7531`   | `https://rubicon.mainnet.romeprotocol.xyz/` | [via-rubicon.mainnet.romeprotocol.xyz](https://via-rubicon.mainnet.romeprotocol.xyz/) | USDC      | Bridgen Sie USDC von Ethereum, Base, Arbitrum, Polygon, Avalanche, Monad oder OP (CCTP) oder von Solana mit dem [Rome Bridge](https://bridge-api.mainnet.romeprotocol.xyz/); es landet als Gas                   |
| **Hadrian** (Testnet)                                                       | `200010` | `https://hadrian.testnet.romeprotocol.xyz/` | [via-hadrian.testnet.romeprotocol.xyz](https://via-hadrian.testnet.romeprotocol.xyz/) | Test-USDC | Bridgen Sie Test-USDC von einem Testnet ([Faucets](https://docs.rome.builders/de/ressourcen/faucets.md)) oder verpacken Sie es mit einer Solana-Devnet-Wallet im [Rome-App](https://app.devnet.romeprotocol.xyz) |

Gas ist USDC mit 18 Dezimalstellen auf der EVM-Seite; es gibt keinen Rome-Faucet auf Rubicon oder Hadrian. Schreibvorgänge kosten mehr Gas, als die Ethereum-Intuition vermuten lässt, weil der größte Teil der Kosten aus der Erstellung von Solana-Konten besteht: ein nie verwendeter Empfänger, ein neues Token-Konto, ein bereitgestellter Vertrag. Verwenden Sie `eth_estimateGas`, was Standard-Tools tun, und kodieren Sie niemals 21.000 fest ein. Auf Hadrian gemessen benötigte die Bereitstellung eines 10-Byte-Vertrags geschätzt und tatsächlich 1.147.921 Gas, und eine native Überweisung an eine nie verwendete Adresse 1.086.961, gegenüber 21.000 für eine Überweisung an eine vorhandene Adresse. Rome berechnet das tatsächlich verbrauchte Gas, das in diesen Messungen nie höher war als die Schätzung. Laden Sie vor der ersten Bereitstellung einige USDC auf. Überprüfen Sie danach den Quellcode im Explorer ([Verträge verifizieren](https://docs.rome.builders/de/entwicklerleitfaden/verify-contracts.md); der Mainnet-Verifier ist `https://verify.mainnet.romeprotocol.xyz`).

Entwickeln Sie auf Hadrian und stellen Sie dann dieselben Artefakte auf Rubicon erneut bereit, wobei Sie die Chain-ID und die Mainnet-Wrapper-Adressen austauschen; im Vertrag ändert sich zwischen den Netzwerken nichts. Rubicon ist ab v0.3.0 im öffentlichen Register enthalten, aber `create-rome-app` und `rome-cli` halten weiterhin Registry v0.2.0 fest, das keinen Rubicon-Eintrag hat, sodass sie ihn nicht ansteuern können; für diese Tools tragen Sie die Werte von Hand aus [Rubicon](https://docs.rome.builders/de/netzwerke/rubicon.md). Gas auf Rubicon ist echtes USDC zu etwa dem Zehnfachen von Hadrians Gaspreis, daher kostet eine Bereitstellung dort echtes Geld.

## 2. Was einen Vertrag Solana-bereit macht

Die EVM-Identität eines Solana-Nutzers ist sein **synthetische Adresse**, `keccak256(solana_pubkey)[12:]`: eine gewöhnliche `msg.sender`, mit einem gewöhnlichen Nonce. Die meisten Verträge brauchen überhaupt keine Änderung. Die drei Dinge, die zählen:

* **Wert als ERC-20 annehmen, nicht `msg.value`.** Die Gelder eines Solana-Nutzers sind SPL-Token in seiner Wallet, die auf der EVM-Seite als Wrapper des Tokens erscheinen (`wUSDC`, `wETH`, `wSOL`). Das Synthetic hält im Ruhezustand nichts und die Vermögenswerte des Nutzers kommen als Wrapper an, also ziehen Sie mit `transferFrom` nach einem `approve` und geben Sie zurück mit `transfer`. Jeder Nutzer gewährt dem Wrapper einmal vor dem ersten Abruf das SPL-Delegationsrecht ([Einmalig: dem Wrapper gewähren](https://docs.rome.builders/de/entwicklerleitfaden/dual-lane-app.md#one-time-grant-the-wrapper)). Ein `payable` Einstiegspunkt funktioniert erst, wenn dem Synthetic natives Gas gegeben wurde (der `rome_composeExternalDepositV1`), was das Fund-and-Sweep-Modell nicht tut. Ein bestehender ERC-20-Tresor, AMM oder Kreditmarkt hat bereits die richtige Form.
* **Verwenden Sie die kanonischen Wrapper.** Jede Chain hat einen Wrapper pro Mint; die Adressen stehen in [Contract Addresses](https://docs.rome.builders/de/referenz/contract-addresses.md) (Hadrians auch im öffentlichen [Registry](https://github.com/rome-protocol/rome-registry)). Richten Sie Konstruktoren auf diese Adressen; deployen Sie keine eigenen.
* **Passen Sie das atomare Budget dort an, wo eine Wallet signiert.** Eine Solana-Wallet signiert eine Solana-Transaktion, also muss ein Solana-Lane-Aufruf hineinpassen: etwa 1,4 Mio. Compute Units, 64 Konten, 4 KB ([Beschränkungen](https://docs.rome.builders/de/kernkonzepte/constraints.md)). Auf Hadrian gemessen: eine Überweisung, ein Approve und ein Aave-Supply passen; ein Uniswap-V3-Swap passt mit wenig Puffer (etwa 1,24 Mio. CU); ein Aave-Borrow passt nicht und nimmt im nächsten Abschnitt den Relay-Pfad. Messen Sie anhand des Felds des Solana-Belegs `computeUnitsConsumed`, indem Sie die Transaktion mit `maxSupportedTransactionVersion: 1` (Rome-Legs sind v1-Transaktionen; ohne sie lehnt die RPC-Anfrage ab).

Was Sie nicht brauchen: ein Solana-Programm, eine Bridge, eine zweite Bereitstellung oder irgendwelches Rome-spezifisches Solidity. Wenn der Vertrag außerdem Solana-Programme über die Precompiles aufruft, siehe [Solana aus EVM aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-solana-from-evm.md).

## 3. Lassen Sie eine Solana-Wallet es aufrufen

Der EVM-Pfad Ihrer App bleibt unverändert (MetaMask + `submitRomeTx`, oder reines viem/ethers). Für den Solana-Pfad gibt es zwei Formen.

**Die SDK-Lane — eine Solana-v1-Transaktion pro Aufruf.** [`@rome-protocol/sdk`](https://github.com/rome-protocol/rome-sdk-ts) (`submitRomeTxV1`) lässt den Proxy eine Solana-v1-Transaktion für Ihren EVM-Aufruf zusammenstellen (bis zu 64 Konten und 4 KB, ohne Address Lookup Table; in Ihrem Code gibt es keine ComputeBudget-Instruktion, keine Treasury-Wallet und keine Kontoerkennung). Die Wallet signiert zweimal mit demselben Schlüssel: zuerst eine lesbare Autorisierungsnachricht (`Rome-Autorisierung` in einer Zeile, `0x` und den EVM-Transaktions-Hash in der nächsten), den die Chain über das Ed25519-Programm prüft, dann die Transaktion. Die App sendet die signierte Transaktion an die Solana-RPC; der Aufruf liefert den EVM-Transaktions-Hash und dessen Beleg zurück. Bevor die Wallet die Transaktion signiert, prüft das SDK sie: Der Zahler ist der einzige Signierer, nur das Rome-Programm und der Ed25519-Verifier laufen, die Rome-Instruktion enthält genau den Aufruf, den der Nutzer autorisiert hat, und es gibt keine Prioritätsgebühr. Alles andere wird abgelehnt.

Wenn ein Aufruf nicht in eine Transaktion passt, lehnt der Composer ihn ab und das SDK gibt ihn an den Proxy zum Relaying weiter, mit derselben Autorisierungssignatur, sodass der Nutzer weiterhin nur eine Autorisierungsabfrage sieht. Das Ergebnis hat dann `route: "relay"`. Die Regeln für relayed Aufrufe und lange Aufrufe stehen in [Weitergeleitete Aufrufe und lange Aufrufe](https://docs.rome.builders/de/entwicklerleitfaden/call-evm-from-solana.md#relayed-calls-and-long-calls); ein relayed Aufruf wird mit dem nativen Gas der Chain bezahlt, daher braucht das Synthetic ein Gas-Guthaben: `fundSyntheticGas(deps, amountWei)` verschiebt den Gas-Token der Chain (USDC auf Hadrian und Rubicon) aus dem Token-Konto der Wallet hinein, in einer von der Wallet signierten v1-Transaktion.

Der Funding-Leg (`buildFundLeg`) und das Erstellen des Token-Kontos der Wallet vor einem Sweep sind normale Solana-Instruktionen; `submitSolanaInstructionsV1` sendet sie ebenfalls als v1-Transaktionen, signiert vom selben Wallet-Signer, ohne Beteiligung eines Proxys. Der eigentliche Sweep-Aufruf (`buildSweepLeg`, `HelperProgram.transfer_spl`läuft über `submitRomeTxV1` wie jeder andere, und der Proxy findet die Token-Konten. `submitRomeTxV1` erstellt von sich aus kein neues Konto für das Synthetic: Prüfen Sie vor dem ersten wertbewegenden Aufruf `isSyntheticProvisioned(...)` und senden Sie, wenn es false ist `buildCreatePdaCall(synthetic)` durch `submitRomeTxV1` einmal ab. Eine vollständige Einzahlungs- und Auszahlungsanleitung mit Code finden Sie in [Eine Dual-Lane-App bauen](https://docs.rome.builders/de/entwicklerleitfaden/dual-lane-app.md); die Mechanik steht in [EVM aus Solana aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-evm-from-solana.md). Das frühere `submitRomeTxSolanaLane`, das im Client eine Legacy-Solana-Transaktion erstellt, ist im SDK weiterhin als älterer Pfad enthalten.

**Woher jeder `Abhängigkeiten` Wert kommt.** Des SDKs `Abhängigkeiten` Objekt hat fünf erforderliche Felder (der Rest, wie `fetchImpl` und die Timeouts, sind optional). Vier kommen von der Chain und eines von der Wallet:

| `Abhängigkeiten` Feld | Herkunft                                                                                                                            | Registry-Getter (`@rome-protocol/registry` v0.2.0)                                                                  |
| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| `proxyUrl`            | die RPC-URL der Chain                                                                                                               | `getChain(chainId).rpcUrl`                                                                                          |
| `chainId`             | die Chain-ID                                                                                                                        | `getChain(chainId).chainId`                                                                                         |
| `programId`           | die Rome-Programm-ID, auf der die Chain läuft                                                                                       | `getChain(chainId).romeEvmProgramId`                                                                                |
| `Verbindung`          | eine Solana-RPC für den Cluster der Chain, an die die signierte Transaktion gesendet wird (Devnet für Hadrian, Mainnet für Rubicon) | `getChain(chainId).solana.rpc` (eine öffentliche Devnet-URL für Hadrian); für Mainnet verwenden Sie eine eigene RPC |
| `Signer`              | der Wallet `LaneSigner`, oder ein `Keypair` in Skripten                                                                             | keine                                                                                                               |

Die Leg-Builder nehmen Werte, die nicht in `Abhängigkeiten`. Ihr `mint` (genannt `usdcMint` im Walkthrough) ist der Solana-Mint des Gas-Tokens, aus `getTokens(chainId)` (der Eintrag mit `kind: "gas"`, Feld `mintId`). Die wUSDC-Wrapper-Adresse ist kein Input für den Leg-Builder; Sie verwenden sie für die ERC-20-Aufrufe, und es ist der Eintrag mit `kind: "spl_wrapper"` und Symbol `wUSDC` (Feld `Adresse`). Das Register deckt Hadrian und ab v0.3.0 Rubicon ab. Um die Rubicon-Werte stattdessen von Hand zu füllen: `proxyUrl` `https://rubicon.mainnet.romeprotocol.xyz/`, `chainId` `7531`, `programId` `RomePq9X3iAoTr813HR7uRarafFDUJty6GdiEceYpzX`, `mint` `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`, den Wrapper aus der Tabelle im nächsten Abschnitt und eine Solana-Mainnet-RPC für `Verbindung`. [Rubicon](https://docs.rome.builders/de/netzwerke/rubicon.md) enthält die vollständige Liste.

**Die externen V1-Endpunkte des Proxys — dieselbe Lane ohne das SDK.** Das SDK kapselt das atomare Compose, das Relay und die Gas-Einzahlung (`fundSyntheticGas`). Die rohen RPC-Methoden bleiben für Clients erhalten, die das SDK nicht verwenden, und sie umfassen das iterative Compose, das das SDK nicht kapselt. Die Wallet signiert eine Ed25519-Nachricht über den Aufruf (die lesbare Form `Rome-Autorisierung\n0x<hash>` oder der rohe Hash), und der Proxy stellt entweder die Solana-Transaktion(en) für die Wallet zum Signieren zusammen (`rome_composeUnsignedAtomicV1`, `rome_composeUnsignedIterativeV1` + `rome_submitSignedV1Plan`) oder führt die gesamte Ausführung selbst mit einer Wallet-Signatur aus (`rome_relayUnsignedV1`, nach einer `rome_composeExternalDepositV1` (des SDKs `fundSyntheticGas`) das das Gas-Guthaben des Synthetic auflädt; relayed Aufrufe verbrauchen daraus, also füllen Sie es auf, wenn es knapp wird). [JSON-RPC-Unterstützung](https://docs.rome.builders/de/referenz/json-rpc.md); die Autorisierungsregeln in [EVM aus Solana aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-evm-from-solana.md#the-external-v1-endpoints). Verwenden Sie das Relay für alles Iterative und die SDK-Lane für alles, was passt.

In jedem Fall sieht der Vertrag eine normale Transaktion von der Synthetic-Adresse, und der Nutzer hält niemals einen EVM-Schlüssel.

## 4. Wrapper-Adressen pro Netzwerk

| Netzwerk         | `wUSDC` Wrapper                              | Andere Wrapper                                                                                           |
| ---------------- | -------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| Rubicon (7531)   | `0x0952d233b0c254cd375f3bfb3e5869c1a906f9b3` | `wETH` `0x01e8b3573da1d4b7b4b1ce0932cf07c8af0c92e9`, `wSOL` `0xc4e29e0f726a906e93277cbbc37bf27a9848a113` |
| Hadrian (200010) | `0xbce339ba4c3a8de3bb8af1c5539e6ac11da3112d` | `wETH` `0x02aeace038269f9961c93d04dcacd6fb3adfa55f`, `wSOL` `0x39f36444fcb79b3e691544aee2a832ebef54ca9f` |

Der native Gas-Token erscheint als `0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee` in Token-Listen; er ist kein ERC-20-Vertrag. Wrapper tragen die Dezimalstellen des SPL-Mints, nicht 18: wUSDC 6, wETH 8, wSOL 9.

## 5. Start-Checkliste

1. Auf Hadrian bereitgestellt; der EVM-Pfad funktioniert mit MetaMask.
2. Jeder wertbewegende Einstiegspunkt basiert auf ERC-20 und zeigt auf den kanonischen Wrapper der Chain.
3. Eine Solana-Wallet, die v1-Transaktionen signiert (Solflare tut dies heute auf Devnet; Phantom noch nicht), führt auf Hadrian die komplette Round-Trip aus: das Synthetic bereitstellen (`create_pda`, einmal) → Funding-Leg → Gewähren → Approve → Aufruf → Sweep-Leg, mit der SDK-Lane; oder den Relay-Pfad, wenn der Aufruf iterativ ist.
4. Jeder Solana-Lane-Aufruf `computeUnitsConsumed` wird aus dem Solana-Beleg gelesen und liegt unter dem atomaren Budget, oder der Aufruf wird über das Relay geleitet.
5. Die Wrapper-Gewährung ist in Ihrem First-Deposit-Flow der App für beide Lanes enthalten: `isEnabled(user)` wird geprüft und `approve_spl` wird einmal gesendet, wenn es falsch ist ([Einmalig: dem Wrapper gewähren](https://docs.rome.builders/de/entwicklerleitfaden/dual-lane-app.md#one-time-grant-the-wrapper)).
6. Die Quelle ist im Explorer verifiziert.
7. Auf Rubicon mit den Mainnet-Wrapper-Adressen erneut bereitgestellt. Seine `Abhängigkeiten` Werte stammen aus dem Register (v0.3.0 oder neuer) oder von Hand aus [Rubicon](https://docs.rome.builders/de/netzwerke/rubicon.md). Dieselbe Round-Trip wird einmal mit echten Mitteln ausgeführt, mit einer Wallet, von der Sie überprüft haben, dass sie v1-Transaktionen auf dem Mainnet signiert.

## Was als Nächstes kommt

* [Eine Dual-Lane-App bauen](https://docs.rome.builders/de/entwicklerleitfaden/dual-lane-app.md) — das Tresor-Beispiel, Schritt für Schritt, beide Wallets
* [EVM aus Solana aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-evm-from-solana.md) — Synthetic-Adressen, Kontoerkennung, die externen V1-Endpunkte
* [Solidity-Verträge bereitstellen](https://docs.rome.builders/de/entwicklerleitfaden/deploy-solidity.md) · [Verträge verifizieren](https://docs.rome.builders/de/entwicklerleitfaden/verify-contracts.md) · [Contract Addresses](https://docs.rome.builders/de/referenz/contract-addresses.md)


---

# 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/de/entwicklerleitfaden/open-to-solana-users.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.
