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

# Quickstart

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

Bereitstelle deinen ersten Solidity-Vertrag auf Rome in unter 5 Minuten. Dieser Leitfaden richtet sich an [**Hadrian**](/de/netzwerke/hadrian.md), die öffentliche Testnet-Chain. [Rubicon](/de/netzwerke/rubicon.md) ist die Mainnet-Chain, auf der Gas echtes USDC ist; probiere alles zuerst 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 du von Solana aus finanzierst (Schritt 2). Das Aufrufen von Verträgen aus einer Solana-Wallet erfordert eine Wallet, die Solana-v1-Transaktionen signiert, was in [Öffne deinen Vertrag für Solana-Nutzer](/de/entwicklerleitfaden/open-to-solana-users.md).

## 1. Füge Hadrian zu MetaMask hinzu

Füge sie 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. Lade deine Wallet auf

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

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

**Durch das Bridging von einer EVM-Chain aus** — präge Test-USDC auf Ethereum Sepolia über die [Circle-Faucet](https://faucet.circle.com/), dann bringe es mit der [Rome Bridge](/de/apps-auf-rome/bridge-api.md) (CCTP). Du brauchst etwas Sepolia-ETH für die Transaktion auf der Quellseite — siehe [Faucets](/de/ressourcen/faucets.md) für jeden Faucet.

**Wie viel?** Ein Schreibvorgang auf Rome kostet mehr, als die Ethereum-Intuition vermuten lässt, weil der Großteil seines 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. Verwende `eth_estimateGas`, was Standard-Tools tun, und hardcode niemals 21.000. Die Schätzung umfasst die Kontoerstellung, Rome berechnet das Gas, das eine Transaktion tatsächlich verbraucht (in Messungen auf Hadrian war das nie mehr als die Schätzung), und des SDKs `submitRomeTx` erhöht die Schätzung mit einem Faktor von 1,3 als Puffer, was nichts kostet, weil nur das verbrauchte Gas berechnet wird. Lade mindestens **0,5 USDC Gas**; 1 USDC lässt komfortablen Spielraum. Zahlen in [JSON-RPC-Unterstützung](/de/referenz/json-rpc.md) zeigen, was einzelne Schreibvorgänge kosten.

Wenn eine Einzahlung auf der Solana-Seite trotz aufgeladener Wallet mit der Warnung "insufficient SOL" fehlschlägt, stelle deine Solana-Wallet auf Testnet-Modus / Devnet ein (siehe die [FAQ](/de/ressourcen/faq.md)).

## 3. Erstelle ein Hardhat-Projekt

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

Übernimm bei der Aufforderung die Standardwerte — Hardhat 3, das aktuelle Verzeichnis und die Vorlage TypeScript + Node Test Runner + viem — und lasse die Abhängigkeiten installieren. Die Vorlage enthält ein Beispiel `Zähler` Vertrag mit Tests; sie stören diesen Leitfaden nicht.

## 4. Konfiguriere Hardhat für Rome

Bearbeite die generierte `hardhat.config.ts` und füge die Rome-Netzwerke in `defineConfig({ ... })`:

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

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

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

(Für alles, was über einen Wegwerf-Schlüssel hinausgeht, verwende lieber den verschlüsselten Keystore, der mit dem Werkzeugkasten mitgeliefert wird: `npx hardhat keystore set PRIVATE_KEY`.)

## 5. Schreibe einen Vertrag

Erstelle `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

Erstelle `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 (deine Adresse wird abweichen):

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

Öffne die bereitgestellte Adresse im [Explorer](https://via-hadrian.testnet.romeprotocol.xyz/) um die Solana-Instruktionen hinter deiner Transaktion zu sehen. Dein Solidity-Vertrag läuft jetzt auf Solana.

## Wie es weitergeht

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

## Häufige Fehler

| Fehler                          | Ursache                                                    | Lösung                                                                                                    |
| ------------------------------- | ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
| `Nicht genügend Guthaben`       | Nicht genügend Gas-Token für das Gaslimit mal den Gaspreis | Lade mindestens 0,5 USDC Gas auf (siehe Schritt 2) mit der [Rome Bridge](/de/apps-auf-rome/bridge-api.md) |
| `Nonce zu niedrig`              | Nonce der Transaktion stimmt nicht überein                 | Setze das Konto zurück (MetaMask → Einstellungen → Erweitert → Aktivität löschen)                         |
| `Ausführung rückgängig gemacht` | Vertragsausführung fehlgeschlagen                          | Prüfe die Vertragslogik; verwende `eth_call` zum Debuggen                                                 |
| Verbindungs-Timeout             | RPC nicht erreichbar                                       | Überprüfe 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/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.