Token-Interoperabilität

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

Das Single-State-Modell

Im Gegensatz zu herkömmlichen Bridges sperrt Rome keine Token auf einer Chain und mintet keine eingewickelten 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 der 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)         │
│   Eigentümer: PDA des Nutzers    │
│   Mint: USDC (Circle nativ)     │
│   Betrag: 1000000 (= 1 USDC)    │
│                                  │
└──────────────────────────────────┘

Das bedeutet:

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

• Keine Liquiditätsfragmentierung — DeFi auf beiden Seiten sieht dieselben Token

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

ERC20SPL: Der Wrapper-Vertrag

SPL_ERC20 ist der standardmäßige Wrapper-Vertrag, der eine vollständige ERC-20-Schnittstelle über einem SPL-Token-Mint bereitstellt:

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

// Der Wrapper liest Guthaben aus der SPL-ATA des Nutzers
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 die ATA des Nutzers (Associated Token Account) ab → liest das Guthaben aus Solana

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

• approve() / allowance() → verwendet EVM-Speicher (standardmäßiges ERC-20-Muster), da SPL EVM-artige Allowances nicht nativ unterstützt

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

ERC20SPLFactory

Der Factory-Vertrag stellt Wrapper für jeden SPL-Token bereit:

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

ERC20SPLFactory factory = ERC20SPLFactory(0xfd21da046c282e1d36cc45e46d9599cff5742f2b);

// Stelle einen Wrapper für einen SPL-Mint bereit (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-Register

Die TokenRegistry ermöglicht die administrativ gesteuerte Registrierung genehmigter SPL-Token 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
);

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

Einzahlungs-/Auszahlungsablauf

SPL einzahlen → EVM

1. Der Nutzer überträgt SPL-Token an den Bridge-Vault

2. Die Bridge erstellt die ATA des Nutzers auf Rome EVM (falls sie nicht existiert)

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

EVM auszahlen → SPL

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

2. Das Precompile führt eine SPL-Überweisung von der PDA des Nutzers zurück zu seiner Solana-Wallet aus

3. SPL-Token erscheinen in der Solana-Wallet des Nutzers

PDA-Ableitung

Jede EVM-Adresse wird einer Solana-PDA zugeordnet, die ihre Token-Konten besitzt:

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

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

// Die ATA des Nutzers 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 prüfen

Token über das SPL-Precompile übertragen

// Direkte SPL-Übertragung (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 gewählt wird:

• RSOL — Standard-Gas-Token (eingewickeltes SOL)

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

Gas-Token sind ERC-20-Darstellungen von SPL-Token. 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-Dezimalstellen für neue SPL-Mints: 9

• ERC-20-Wrapper-Symbole müssen pro Factory weltweit 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

• Vertragsadressen — bereitgestellte Factory-Adressen