Deploy Solidity Contracts

Deploy Solidity smart contracts on Solana with Hardhat or Foundry — Rome network configuration, funded accounts, and step-by-step deployment.

This guide covers deploying Solidity smart contracts on Rome EVM using Hardhat and Foundry.

Prerequisites

• Node.js v22.13+ (Hardhat) or Foundry installed

• A funded Rome EVM address (see Quickstart)

• Your private key exported as an environment variable

export PRIVATE_KEY="0xYOUR_PRIVATE_KEY"

Network Configuration

Network	RPC URL	Chain ID
Local	http://localhost:9090	1001
Hadrian (devnet)	https://hadrian.testnet.romeprotocol.xyz/	200010
Martius (testnet)	https://martius.testnet.romeprotocol.xyz/	121214

Hardhat

Setup

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

Accept the defaults (Hardhat 3, current directory, TypeScript + viem template); dependencies install automatically.

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: {
    rome_local: {
      type: "http",
      chainType: "l1",
      chainId: 1001,
      url: "http://localhost:9090",
      accounts: [configVariable("PRIVATE_KEY")],
    },
    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")],
    },
  },
});

configVariable("PRIVATE_KEY") resolves from the environment (or the encrypted keystore — npx hardhat keystore set PRIVATE_KEY).

Deploy

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

Verify on Block Explorer

npx hardhat verify --network martius 0xCONTRACT_ADDRESS

Needs the Sourcify verifier config from Verify Contracts in your hardhat.config.ts.

Foundry

Setup

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

Deploy

# Local
forge create --rpc-url http://localhost:9090 \
  --private-key $PRIVATE_KEY \
  src/Counter.sol:Counter

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

Call Deployed Contract

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

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

Using the Rome Solidity SDK

For contracts that interact with Solana programs, use the interfaces from the public rome-solidity repo (npm publish pending):

// 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);

    // Transfer an SPL token from the caller's PDA
    function moveSpl(address to, uint64 tokens, bytes32 mint) external {
        Helper.transfer_spl(to, tokens, mint);
    }

    // Invoke any Solana program via CPI
    function callSolanaProgram(
        bytes32 programId,
        ICrossProgramInvocation.AccountMeta[] calldata accounts,
        bytes calldata data
    ) external {
        Cpi.invoke(programId, accounts, data);
    }
}

Bring an existing protocol

Any Solidity contract deploys on Rome unmodified — a compliance contract, a DeFi protocol, or an existing hardened application. Two production examples you can fork and deploy with the same Hardhat / Foundry flow above:

• compound-on-rome-comet — canonical Compound v3 (Comet), standard Foundry.

• rome-aave-v3 — canonical Aave v3.

Both gain Solana execution and CPI composability with no contract changes.

Deployment Constraints

Constraint	Limit	Notes
Max contract size	24 KB	Same as Ethereum (EIP-170, 24,576 bytes)
Transaction size limit	80 KB per holder	Large deploys are split across holder accounts transparently
Compute budget	~1.4M CU (atomic)	Use iterative mode for heavy contracts
Solidity version	0.8.28 recommended	Earlier versions work but 0.8.28 matches the SDK

Common Errors

Error	Cause	Fix
insufficient funds for gas	EVM address has no gas token	Wrap gas via the Rome App (see Quickstart)
nonce too low	Stale nonce in wallet	Reset MetaMask account or specify nonce manually
execution reverted	Contract logic failed	Debug with eth_call or forge test --fork-url
transaction underpriced	Gas price below minimum	Increase gas price in transaction

What's Next

• Call Solana from EVM — use CPI precompiles to interact with Solana programs

• Verify Contracts — publish your source to the block explorer