Solidity-Verträge bereitstellen

Stelle Solidity-Smart-Contracts auf Solana mit Hardhat oder Foundry bereit — Rome-Netzwerkkonfiguration, aufgeladene Accounts und schrittweise Bereitstellung.

Dieser Leitfaden behandelt die Bereitstellung von Solidity-Smart-Contracts auf Rome EVM mit Hardhat und Foundry.

Voraussetzungen

• Node.js v22.13+ (Hardhat) oder Foundry installiert

• Eine mit Mitteln ausgestattete Rome-EVM-Adresse (siehe Schnellstart)

• Ihr privater Schlüssel als Umgebungsvariable exportiert

export PRIVATE_KEY="0xYOUR_PRIVATE_KEY"

Netzwerkkonfiguration

Netzwerk	RPC-URL	Chain-ID	Explorer
Hadrian (Devnet)	https://hadrian.testnet.romeprotocol.xyz/	200010	via-hadrian.testnet.romeprotocol.xyz
Martius (Testnet)	https://martius.testnet.romeprotocol.xyz/	121214	via-martius.testnet.romeprotocol.xyz
Rubicon (Mainnet)	https://rubicon.mainnet.romeprotocol.xyz/	7531	via-rubicon.mainnet.romeprotocol.xyz

Gas ist auf jedem Netzwerk USDC. Auf den Testnets erhalten Sie es, indem Sie Test-USDC bridgen oder es aus einer Solana-Devnet-Wallet wrappen (Faucets); auf Rubicon, indem Sie USDC mit dem Rome Bridge. Stellen Sie auf Rubicon mit denselben Artefakten bereit, die Sie auf Hadrian getestet haben — nur die Chain-ID und die Wrapper-Adressen unterscheiden sich.

Hardhat

Einrichtung

mkdir my-rome-project && cd my-rome-project
npx hardhat --init

Übernehmen Sie die Standardwerte (Hardhat 3, aktuelles Verzeichnis, TypeScript- + viem-Vorlage); die Abhängigkeiten werden automatisch installiert.

hardhat.config.ts

import hardhatToolboxViemPlugin from "@nomicfoundation/hardhat-toolbox-viem";
import { configVariable, defineConfig } from "hardhat/config";

export default defineConfig({
  plugins: [hardhatToolboxViemPlugin],
  solidity: {
    profiles: {
      default: { version: "0.8.28" },
      production: {
        version: "0.8.28",
        settings: { optimizer: { enabled: true, runs: 200 } },
      },
    },
  },
  networks: {
    hadrian: {
      type: "http",
      chainType: "l1",
      chainId: 200010,
      url: "https://hadrian.testnet.romeprotocol.xyz/",
      accounts: [configVariable("PRIVATE_KEY")],
    },
    martius: {
      type: "http",
      chainType: "l1",
      chainId: 121214,
      url: "https://martius.testnet.romeprotocol.xyz/",
      accounts: [configVariable("PRIVATE_KEY")],
    },
    rubicon: {
      type: "http",
      chainType: "l1",
      chainId: 7531,
      url: "https://rubicon.mainnet.romeprotocol.xyz/",
      accounts: [configVariable("PRIVATE_KEY")],
    },
  },
});

configVariable("PRIVATE_KEY") wird aus der Umgebung aufgelöst (oder aus dem verschlüsselten Keystore — npx hardhat keystore set PRIVATE_KEY).

Bereitstellen

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

Im Block-Explorer verifizieren

npx hardhat verify --network martius 0xCONTRACT_ADDRESS

Benötigt die Sourcify-Verifier-Konfiguration von Contracts verifizieren in Ihrem hardhat.config.ts.

Foundry

Einrichtung

forge init my-rome-project
cd my-rome-project

Bereitstellen

# Entwicklungsnetz
forge create --rpc-url https://hadrian.testnet.romeprotocol.xyz/ \
  --private-key $PRIVATE_KEY \
  src/Counter.sol:Counter

Bereitgestellten Contract aufrufen

# Lesen
cast call 0xCONTRACT_ADDRESS "number()" \
  --rpc-url https://hadrian.testnet.romeprotocol.xyz/

# Schreiben
cast send 0xCONTRACT_ADDRESS "increment()" \
  --rpc-url https://hadrian.testnet.romeprotocol.xyz/ \
  --private-key $PRIVATE_KEY

Mit dem Rome Solidity SDK

Für Contracts, die mit Solana-Programmen interagieren, verwenden Sie die Schnittstellen aus dem öffentlichen rome-solidity Repo. Es wird von GitHub installiert, nicht von npm:

# Hardhat / npm
npm install github:rome-protocol/rome-solidity

# Foundry
forge install rome-protocol/rome-solidity
# dann in foundry.toml, unter [profile.default]:
# remappings = ["@rome-protocol/rome-solidity/=lib/rome-solidity/"]

Über interface.sol und die Oracle-Schnittstellen (zum Beispiel die ERC-20-Wrapper und die Factory) importieren OpenZeppelin. Mit npm wird es als Abhängigkeit mitgeliefert. Mit Foundry führen Sie außerdem aus forge install OpenZeppelin/openzeppelin-contracts und fügen Sie das Remapping hinzu @openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/.

Mit npm wird das Paket installiert als @rome-protocol/rome-solidity, daher wird der folgende Import aus node_modules. Mit Foundry sorgt das Remapping dafür, dass derselbe Import aus lib/rome-solidity.

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

import {ICrossProgramInvocation, IHelperProgram}
    from "@rome-protocol/rome-solidity/contracts/interface.sol";

contract MyRomeContract {
    IHelperProgram constant Helper =
        IHelperProgram(0xFF00000000000000000000000000000000000009);
    ICrossProgramInvocation constant Cpi =
        ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);

    // Übertrage ein SPL-Token aus dem PDA des Aufrufers
    function moveSpl(address to, uint64 tokens, bytes32 mint) external {
        Helper.transfer_spl(to, tokens, mint);
    }

    // Rufe ein beliebiges Solana-Programm per CPI auf
    function callSolanaProgram(
        bytes32 programId,
        ICrossProgramInvocation.AccountMeta[] calldata accounts,
        bytes calldata data
    ) external {
        Cpi.invoke(programId, accounts, data);
    }
}

Bestehendes Protokoll übernehmen

Jeder Solidity-Contract wird auf Rome unverändert bereitgestellt — ein Compliance-Contract, ein DeFi-Protokoll oder eine bestehende gehärtete Anwendung. Zwei Produktionsbeispiele, die Sie mit demselben oben gezeigten Hardhat-/Foundry-Flow forken und bereitstellen können:

• compound-on-rome-comet — kanonisches Compound v3 (Comet), Standard-Foundry.

• rome-aave-v3 — kanonisches Aave v3.

Beide erhalten Solana-Ausführung und CPI-Komposierbarkeit ohne Änderungen am Contract.

Bereitstellungsbeschränkungen

Einschränkung	Limit	Hinweise
Maximale Contract-Größe	24 KB	Wie bei Ethereum (EIP-170, 24.576 Bytes)
Transaktionsgrößenlimit	80 KB pro Holder	Große Deployments werden transparent über Holder-Konten aufgeteilt
Compute-Budget	~1,4 Mio. CU (atomar)	Verwenden Sie den iterativen Modus für große Contracts
Solidity-Version	0.8.28 empfohlen	Ältere Versionen funktionieren, aber 0.8.28 passt zum SDK

Häufige Fehler

Fehler	Ursache	Behebung
nicht genügend Mittel für Gas	EVM-Adresse hat kein Gas-Token	Testnets: Gas über den Rome-App (siehe Schnellstart); Rubicon: USDC mit dem Rome Bridge
Nonce zu niedrig	Veraltete Nonce in der Wallet	MetaMask-Konto zurücksetzen oder Nonce manuell angeben
Ausführung rückgängig gemacht	Contract-Logik fehlgeschlagen	Debuggen mit eth_call oder forge test --fork-url
Transaktion unterbewertet	Gaspreis unter dem Minimum	Erhöhen Sie den Gaspreis in der Transaktion

Was kommt als Nächstes

• Öffnen Sie Ihren Contract für Solana-Nutzer — lassen Sie Solana-Wallet-Nutzer ausführen, was Sie gerade bereitgestellt haben

• Solana von EVM aus aufrufen — verwenden Sie CPI-Precompiles, um mit Solana-Programmen zu interagieren

• Contracts verifizieren — veröffentlichen Sie Ihren Quellcode im Block-Explorer