# 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: ```solidity 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: ```solidity 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: ```solidity 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: ```solidity 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 ```solidity // 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 ```solidity // 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](/de/grundlegende-konzepte/transfer-hooks.md) — EVM-Logik in Token-2022-Transfer-Hooks * [Leitfaden zum Token-Wrapping](https://github.com/rome-protocol/docs/blob/main/developer-guides/token-wrapping.md) — deinen eigenen ERC-20-Wrapper bereitstellen * [Contract-Adressen](/de/referenz/contract-addresses.md) — bereitgestellte Factory-Adressen --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.rome.builders/de/grundlegende-konzepte/token-interop.md?ask= ``` The question should be specific, self-contained, and written in natural language. 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.