> 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/erste-schritte-1/quickstart.md).

# Quickstart

Stelle deinen ersten Solidity-Contract auf Rome in unter 5 Minuten bereit.

Stellen Sie Ihren ersten Solidity-Vertrag auf Rome in unter 5 Minuten bereit. Dieser Leitfaden richtet sich an [**Hadrian**](https://docs.rome.builders/de/netzwerke/hadrian.md), die öffentliche Testnet-Kette. [Rubicon](https://docs.rome.builders/de/netzwerke/rubicon.md) ist die Mainnet-Chain, auf der Gas echtes USDC ist; probiere zuerst alles auf einer Test-Chain aus.

## Voraussetzungen

* [Node.js](https://nodejs.org/) v22.13+
* [MetaMask](https://metamask.io/) Browser-Erweiterung
* Eine Solana-Wallet, eingestellt auf **Devnet**, nur wenn Sie über Solana einzahlen (Schritt 2). Das Aufrufen von Verträgen aus einer Solana-Wallet erfordert eine, die Solana-v1-Transaktionen signiert, was in [Öffne deinen Contract für Solana-Nutzer](https://docs.rome.builders/de/entwicklerleitfaden/open-to-solana-users.md).

## 1. Hadrian zu MetaMask hinzufügen

Fügen Sie es manuell hinzu (Einstellungen → Netzwerke → Netzwerk hinzufügen):

| Feld           | Wert                                            |
| -------------- | ----------------------------------------------- |
| Netzwerkname   | Rome Hadrian                                    |
| RPC-URL        | `https://hadrian.testnet.romeprotocol.xyz/`     |
| Chain-ID       | `200010`                                        |
| Währungssymbol | `USDC`                                          |
| Block-Explorer | `https://via-hadrian.testnet.romeprotocol.xyz/` |

## 2. Laden Sie Ihre Wallet auf

Gas wird in dem Gas-Token der Chain bezahlt, der auf Hadrian USDC ist. Auf Hadrian wird er durch Circles Solana-Devnet-USDC gedeckt (Mint `4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU`), daher ist Devnet-SOL kein Gas. Es gibt keinen Rome-Faucet. Zwei Wege, USDC auf Hadrian zu bekommen:

**Von Solana** — holen Sie sich Solana-Devnet-USDC von der [Circle-Faucet](https://faucet.circle.com/) (wählen Sie Solana Devnet) und etwas Devnet-SOL für Solana-Gebühren von der [Solana Faucet](https://faucet.solana.com/), mit Ihrer Solana-Wallet auf Devnet eingestellt. Verwenden Sie dann die [Rome Bridge](https://docs.rome.builders/de/apps-auf-rome/bridge-api.md) mit Hadrian als Ziel und ihrer Solana-Route, mit der Adresse Ihrer EVM-Wallet als Empfänger; die Bridge fordert diese EVM-Wallet auf, eine Claim-Transaktion auf Hadrian zu signieren, wodurch das USDC in Gas umgewandelt wird.

**Durch Bridging von einer EVM-Chain aus** — prägen Sie Test-USDC auf Ethereum Sepolia mit dem [Circle-Faucet](https://faucet.circle.com/), dann bringen Sie es mit dem zu Rome [Rome Bridge](https://docs.rome.builders/de/apps-auf-rome/bridge-api.md) (CCTP). Sie benötigen etwas Sepolia-ETH für die Transaktion auf der Quellseite — siehe [Faucets](https://docs.rome.builders/de/ressourcen/faucets.md) für jeden Faucet.

**Wie viel?** Eine Schreiboperation auf Rome kostet mehr, als die Ethereum-Intuition vermuten lässt, weil der Großteil des Gases für das Erstellen von Solana-Konten bezahlt wird: ein Empfänger, der noch nie verwendet wurde, ein neues Token-Konto, ein bereitgestellter Vertrag. Verwenden Sie `eth_estimateGas`, was Standard-Tooling tut, und hardcoden Sie niemals 21.000. Die Schätzung umfasst die Kontoerstellung, Rome berechnet das Gas, das eine Transaktion tatsächlich verbraucht (in Messungen auf Hadrian lag das nie über der Schätzung), und die `submitRomeTx` SDK erhöht die Schätzung als Puffer um den Faktor 1,3, was nichts kostet, da nur das verbrauchte Gas berechnet wird. Laden Sie mindestens **0,5 USDC Gas**; 1 USDC lässt komfortablen Spielraum. Zahlen in [JSON-RPC-Unterstützung](https://docs.rome.builders/de/referenz/json-rpc.md) zeigen, was einzelne Schreibvorgänge kosten.

Wenn eine Einzahlung auf der Solana-Seite trotz gefüllter Wallet mit der Warnung „insufficient SOL“ fehlschlägt, stellen Sie Ihre Solana-Wallet auf Testnet Mode / Devnet ein (siehe die [FAQ](https://docs.rome.builders/de/ressourcen/faq.md)).

## 3. Erstellen Sie ein Hardhat-Projekt

```bash
mkdir rome-hello && cd rome-hello
npx hardhat --init
```

Akzeptieren Sie die Standardwerte, wenn Sie dazu aufgefordert werden — Hardhat 3, das aktuelle Verzeichnis und die TypeScript- + Node Test Runner- + viem-Vorlage — und lassen Sie die Abhängigkeiten installieren. Die Vorlage liefert ein Beispiel `Zähler` Vertrag mit Tests; sie stören diesen Leitfaden nicht.

## 4. Konfigurieren Sie Hardhat für Rome

Bearbeiten Sie die erzeugte `hardhat.config.ts` und fügen Sie die Rome-Netzwerke innerhalb von `defineConfig({ ... })`:

```typescript
  networks: {
    hadrian: {
      type: "http",
      chainType: "l1",
      chainId: 200010,
      url: "https://hadrian.testnet.romeprotocol.xyz/",
      accounts: [configVariable("PRIVATE_KEY")],
    },
  },
```

`configVariable("PRIVATE_KEY")` aus der Umgebung aufgelöst wird, exportieren Sie also Ihren MetaMask-Private-Key:

```bash
export PRIVATE_KEY="0xYOUR_PRIVATE_KEY"
```

(Für alles, was über einen Wegwerf-Key hinausgeht, bevorzugen Sie den verschlüsselten Keystore, der mit dem Toolbox ausgeliefert wird: `npx hardhat keystore set PRIVATE_KEY`.)

## 5. Schreiben Sie einen Vertrag

Erstellen Sie `contracts/HelloRome.sol`:

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

contract HelloRome {
    string public greeting = "Hallo von Solana!";
    uint256 public counter;

    event Greeted(address indexed sender, uint256 count);

    function greet() external returns (string memory) {
        counter++;
        emit Greeted(msg.sender, counter);
        return greeting;
    }

    function setGreeting(string calldata _greeting) external {
        greeting = _greeting;
    }
}
```

## 6. Bereitstellen

Erstellen Sie `scripts/deploy.ts`:

```typescript
import hardhat from "hardhat";

async function main() {
  const { viem } = await hardhat.network.connect();
  const publicClient = await viem.getPublicClient();

  const hello = await viem.deployContract("HelloRome");
  console.log("HelloRome bereitgestellt unter:", hello.address);

  const hash = await hello.write.greet();
  await publicClient.waitForTransactionReceipt({ hash });

  console.log("Zähler:", (await hello.read.counter()).toString());
  console.log("Begrüßung:", await hello.read.greeting());
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
```

Auf Hadrian bereitstellen:

```bash
npx hardhat run scripts/deploy.ts --network hadrian
```

Erwartete Ausgabe (Ihre Adresse wird abweichen):

```
HelloRome bereitgestellt unter: 0x09c437e305eeb698e1776cff23ca16c1bb25aabd
Zähler: 1
Begrüßung: Hallo von Solana!
```

Öffnen Sie die bereitgestellte Adresse im [Explorer](https://via-hadrian.testnet.romeprotocol.xyz/) um Ihre Transaktion zu sehen, und folgen Sie dem Link „Settled in“ zur Solana-Transaktion, die sie abgewickelt hat. Ihr Solidity-Vertrag läuft jetzt auf Solana.

## Wie es weitergeht

* [Solidity bereitstellen](https://docs.rome.builders/de/entwicklerleitfaden/deploy-solidity.md) — Hardhat- und Foundry-Bereitstellung im Detail
* [Solana aus EVM aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-solana-from-evm.md) — Solana-Programme aus Solidity per CPI aufrufen
* [Architektur](https://docs.rome.builders/de/erste-schritte-1/architecture.md) — wie Rome EVM innerhalb von Solana ausführt

## Häufige Fehler

| Fehler                          | Ursache                                                    | Behebung                                                                                                                                    |
| ------------------------------- | ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `unzureichende Mittel`          | Nicht genügend Gas-Token für das Gaslimit mal den Gaspreis | Laden Sie mindestens 0,5 USDC an Gas auf (siehe Schritt 2) mit der [Rome Bridge](https://docs.rome.builders/de/apps-auf-rome/bridge-api.md) |
| `Nonce zu niedrig`              | Nonce der Transaktion stimmt nicht überein                 | Setzen Sie das Konto zurück (MetaMask → Einstellungen → Erweitert → Aktivität löschen)                                                      |
| `Ausführung rückgängig gemacht` | Vertragsausführung fehlgeschlagen                          | Prüfen Sie die Vertragslogik; verwenden Sie `eth_call` zum Debuggen                                                                         |
| Verbindungs-Timeout             | RPC nicht erreichbar                                       | Überprüfen Sie die RPC-URL                                                                                                                  |


---

# 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/erste-schritte-1/quickstart.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.
