Token-Interop

Rome EVM verbindet ERC-20-Token und SPL-Token über ein Single-State-Modell. Diese Seite erklärt, wie Tokens über EVM und Solana hinweg funktionieren.

Das Single-State-Modell

Im Gegensatz zu traditionellen Bridges sperrt Rome keine Tokens auf einer Chain und mintet keine gewrappten Kopien auf einer anderen. Stattdessen sind ERC-20-Token auf Rome EVM transparente Wrapper über den zugrunde liegenden SPL-Token-Konten auf Solana.

┌──────────────────────────────────┐
│ Rome EVM                         │
│                                  │
│   ERC-20 "rUSDC"                 │
│   ┌────────────────────────┐     │
│   │ balanceOf(user)        │─────┼──► liest direkt aus dem SPL-ATA
│   │ transfer(to, amount)   │─────┼──► führt SPL-Transfer über Precompile aus
│   │ totalSupply()          │─────┼──► liest das SPL-Mint-Angebot
│   └────────────────────────┘     │
│                                  │
└──────────────────────────────────┘
                 │
                 │ dieselben zugrunde liegenden Daten
                 ↓
┌──────────────────────────────────┐
│ Solana                           │
│                                  │
│   SPL-Token-Konto (ATA)          │
│   Inhaber: PDA des Benutzers     │
│   Mint: USDC (Circle native)     │
│   Betrag: 1000000 (= 1 USDC)    │
│                                  │
└──────────────────────────────────┘

Das bedeutet:

• Keine Bridging-Verzögerung — ERC-20-Guthaben IST das SPL-Guthaben

• Keine Fragmentierung der Liquidität — DeFi auf beiden Seiten sieht dieselben Tokens

• Kein Bridge-Risiko — es gibt kein separates Escrow, das ausgenutzt werden könnte

ERC20SPL: Der Wrapper-Vertrag

SPL_ERC20 ist der Standard-Wrapper-Vertrag, der eine vollständige ERC-20-Schnittstelle über einen SPL-Token-Mint bereitstellt:

import {SPL_ERC20} from "@rome-protocol/solidity-sdk/contracts/token/ERC20SPL.sol";

// Der Wrapper liest Guthaben aus dem SPL-ATA des Benutzers
uint256 balance = wrapper.balanceOf(userAddress);

// Transfers werden über das SPL-Token-Precompile ausgeführt
wrapper.transfer(recipient, amount);

So funktioniert es unter der Haube:

• balanceOf() → leitet das ATA des Benutzers ab (Associated Token Account) → liest das Guthaben von Solana

• transfer() → ruft das SPL-Token-Precompile auf (0xff...05) → verschiebt Tokens auf Solana

• approve() / allowance() → verwendet EVM-Speicher (standardmäßiges ERC-20-Muster), da SPL von Haus aus keine EVM-ähnlichen Allowances unterstützt

• totalSupply() → liest aus dem SPL-Mint-Konto

ERC20SPLFactory

Der Factory-Vertrag stellt Wrapper für beliebige SPL-Tokens bereit:

import {ERC20SPLFactory} from "@rome-protocol/solidity-sdk/contracts/token/ERC20SPLFactory.sol";

ERC20SPLFactory factory = ERC20SPLFactory(0xfd21da046c282e1d36cc45e46d9599cff5742f2b);

// Einen Wrapper für einen SPL-Mint bereitstellen (lädt Name/Symbol aus Metaplex-Metadaten)
address wrapper = factory.add_spl_token_with_metadata(splMintPubkey);

// Oder Name/Symbol manuell angeben
address wrapper = factory.add_spl_token_no_metadata(splMintPubkey, "USD Coin", "USDC");

Factory-Adresse (devnet): 0xfd21da046c282e1d36cc45e46d9599cff5742f2b

Token-Registry

Das TokenRegistry bietet eine vom Admin gesteuerte Registrierung genehmigter SPL-Tokens mit Cross-Chain-Metadaten:

import {TokenRegistry, TokenOrigin} from "@rome-protocol/solidity-sdk/contracts/token/TokenRegistry.sol";

// Einen nativen SPL-Token registrieren
registry.registerToken(
    splMint,
    TokenOrigin.NativeSPL,
    bytes32(0),   // keine externe Adresse
    0             // keine externe Chain
);

// Einen Wormhole-gewrappten Token mit Cross-Chain-Metadaten registrieren
registry.registerToken(
    wormholeMint,
    TokenOrigin.WormholeWrapped,
    externalTokenAddress,  // ursprünglicher Token auf der Quell-Chain
    2                       // Wormhole-Chain-ID für Ethereum
);

Das Registry stellt sicher, dass jedes Asset auf einen einzigen kanonischen SPL-Mint abgebildet wird — so wird verhindert, dass mehrere USDC-Darstellungen die Liquidität fragmentieren.

Einzahlungs-/Auszahlungsablauf

Einzahlen SPL → EVM

1. Benutzer überträgt SPL-Tokens in den Bridge-Vault

2. Die Bridge erstellt das ATA des Benutzers auf Rome EVM (falls es nicht existiert)

3. Der ERC-20-Wrapper wird aktiv — der Benutzer sieht das Guthaben in MetaMask

Auszahlen EVM → SPL

1. Benutzer ruft das Withdraw-Precompile auf (0x42...16) auf Rome EVM

2. Das Precompile führt einen SPL-Transfer vom PDA des Benutzers zurück zu dessen Solana-Wallet aus

3. SPL-Tokens erscheinen im Solana-Wallet des Benutzers

PDA-Ableitung

Jede EVM-Adresse wird auf einen Solana-PDA abgebildet, der ihre Token-Konten besitzt:

import {RomeEVMAccount} from "@rome-protocol/solidity-sdk/contracts/core/RomeEVMAccount.sol";

// Den Solana-PDA für eine EVM-Adresse abrufen
bytes32 userPda = RomeEVMAccount.pda(msg.sender);

// Das ATA des Benutzers für einen bestimmten Mint abrufen
bytes32 ata = AssociatedSplToken.create_associated_token_account(userPda, mintPubkey);

Wichtige Muster

SPL-Guthaben aus Solidity lesen

// Den rohen Zustand des SPL-Token-Kontos lesen
ISplToken.Account memory account = SplToken.account_state(tokenAccountPubkey);
uint64 balance = account.amount;
uint8 decimals = SplToken.decimals_eq(mintPubkey, 9); // Dezimalstellen verifizieren

Tokens über das SPL-Precompile übertragen

// Direkter SPL-Transfer (niedrigeres Level als der ERC-20-Wrapper)
SplToken.transfer(recipientAta, mintPubkey, amount);

Gas-Token

Jede Rome-EVM-Chain hat ihren eigenen Gas-Token — beliebiger SPL-Token, der bei der Chain-Registrierung ausgewählt wird:

• RSOL — standardmäßiger Gas-Token (gewrappte SOL)

• Benutzerdefinierte Tokens — jeder SPL-Token, bepreist über den Meteora DAMM V1 Pool

Gas-Tokens sind ERC-20-Darstellungen von SPL-Tokens. Transfer Hooks werden bei EVM-internen Gaszahlungen NICHT ausgelöst.

Einschränkungen

• SPL-Token-Beträge sind uint64 — Maximalwert 18,446,744,073,709,551,615

• Standard-Decimals für neue SPL-Mints: 9

• ERC-20-Wrapper-Symbole müssen pro Factory global eindeutig sein

• Allowances verwenden EVM-Speicher (nicht Solana-Delegates)

Was kommt als Nächstes

• Transfer Hooks — EVM-Logik in Token-2022-Transfer-Hooks

• Leitfaden zum Token-Wrapping — deinen eigenen ERC-20-Wrapper bereitstellen

• Contract-Adressen — bereitgestellte Factory-Adressen