
So migrierst du von Ethereum zu Solana: Ein Leitfaden für Entwickler
Inhaltsverzeichnis
- Worum geht es in diesem Artikel?
- Grundlegende Unterschiede
- Konsensmechanismen
- Transaktionsverarbeitung und Ausführungsumgebungen
- Smart-Contract-Sprachen
- Das Account-Modell verstehen
- Adressen und Program Derived Addresses (PDAs)
- Mit einem Account interagieren
- Solang
- Installation
- Neues Projekt erstellen
- Annotationen
- Einschränkungen
- Vorteile
- Neon EVM
- Architektur
- EVM-Kompatibilität
- Verbindung mit einem Neon RPC
- Transaktionslebenszyklus und Gasgebühren
- NeonPass
- Bereitstellung
- Vorteile und Einschränkungen
- Frühere Migrationen
- Fazit
- Weitere Ressourcen
Worum geht es in diesem Artikel?
Ethereum ist eine der bedeutendsten Innovationen der letzten Zeit. Zum ersten Mal in der Geschichte haben wir eine dezentrale, globale Plattform für die gesellschaftliche Koordination, die viele Branchen revolutionieren könnte. Trotz dieser Bedeutung eignet sich die Laufzeitumgebung von Ethereum, die Ethereum Virtual Machine (EVM), in ihrem aktuellen Zustand nicht für Anwendungen auf Verbraucherniveau. Das Netzwerk ist Single-Thread-basiert und verwendet Gas sowie schwankende Gebühren. Solana hingegen ist ein Netzwerk mit hohem Durchsatz und niedriger Latenz. Es bietet eine parallelisierte Infrastruktur mit niedrigen, vorhersehbaren Gebühren. Damit behebt es die Einschränkungen der EVM direkt und verbessert deren ursprüngliches Design. Das macht Solana zu einer überzeugenden Wahl für Entwickler, die skalierbare und effiziente Anwendungen entwickeln möchten.
Dieser Artikel ist ein umfassender Migrationsleitfaden für EVM-Entwickler, die auf Solana entwickeln möchten. Er behandelt die grundlegenden Unterschiede zwischen beiden Plattformen. Dazu gehören die Konsensmechanismen von Ethereum und Solana, ihre Transaktionsverarbeitung und die Sprachen für die Entwicklung von Smart Contracts. Anschließend geht es um das Account-Modell von Solana, das einen einheitlicheren und vielseitigeren Ansatz für Accounts bietet. Der Artikel erläutert außerdem Solang und Neon EVM, zwei Solidity-freundliche Tools, die die Entwicklung auf Solana vereinfachen.
Grundlegende Unterschiede
Dieser Abschnitt untersucht die entscheidenden Unterschiede zwischen Ethereum und Solana. Beide Blockchains wollen eine dezentrale Zustandsmaschine für die globale Koordination schaffen. Ihre Konsensmechanismen, Methoden zur Transaktionsverarbeitung und Sprachen für die Smart-Contract-Entwicklung unterscheiden sich jedoch deutlich. Ein genaueres Verständnis dieser grundlegenden Unterschiede verdeutlicht den besonderen Vorteil von Solana gegenüber Ethereum als äußerst leistungsfähige globale Zustandsmaschine.
Konsensmechanismen
Konsensmechanismen bilden die Grundlage jedes Blockchain-Netzwerks. Sie bestimmen, wie Transaktionen verifiziert und Blöcke sicher, effizient und dezentral zur Blockchain hinzugefügt werden. Sowohl Ethereum als auch Solana sind Proof-of-Stake-Netzwerke (PoS). Obwohl beide auf PoS basieren, verfolgen sie aufgrund ihrer Bestätigungsregeln unterschiedliche Ansätze, um einen Konsens zu erreichen.
Ethereum verwendet Gasper, eine Kombination aus Casper the Friendly Finality Gadget (Casper-FFG) und dem LMD-GHOST-Algorithmus zur Fork-Auswahl. Diese Kombination bildet den Konsensmechanismus, der Ethereum absichert.
Casper ist ein auf PoS basierendes Finalitätssystem, das den Bestätigungsstatus eines Blocks auf „finalisiert“ hochstuft. Ein Block gilt auf Ethereum als finalisiert, wenn zwei Drittel des gesamten Stakes für seine Aufnahme stimmen und ein weiterer Block darauf aufgebaut wird. Da für die Finalität zwei Drittel des gesamten Stakes zustimmen müssen, dass ein Block kanonisch ist, kann ein Angreifer keine alternative finalisierte Chain erstellen, ohne zwei Drittel des gesamten Stakes zu besitzen oder zu manipulieren und mindestens ein Drittel durch Slashing zu vernichten. Casper ermöglicht es neuen Teilnehmern, sich zuverlässig mit der kanonischen Chain zu synchronisieren.
LMD-GHOST ist ein Akronym für „Latest Message-Driven Greedy Heaviest Observed Sub-Tree“. Der Algorithmus entscheidet, welcher Fork von Ethereum verfolgt wird. Dazu wählt er den Fork aus, der von den Validatoren des Netzwerks die meiste Unterstützung, also das größte „Gewicht“, erhalten hat – daher „greedy heaviest sub-tree“. Anschließend stellt er sicher, dass nur die jeweils neueste Nachricht jedes Validators berücksichtigt wird. Bei jedem neuen Blockvorschlag auf Ethereum entscheiden die Validatoren anhand dieser Regel, ob der Block Teil der kanonischen Chain werden soll.
Im Vergleich dazu nutzt Solana Proof-of-History-Hashes (PoH), um einen Konsens zu erzielen. Trotz der missverständlichen Bezeichnung ist PoH kein Konsensalgorithmus. Es ist eine Methode, um Zeit in einem adversen Netzwerk nachzuweisen. Genauer gesagt handelt es sich um eine kryptografische Zeitstempelfunktion, mit der sich Nodes auf eine Reihenfolge von Ereignissen einigen können, ohne miteinander zu kommunizieren. Der Leader, also der Validator, der dem Ledger Einträge hinzufügt, versieht Blöcke mit Zeitstempeln. So weist er nach, dass seit dem letzten Block eine bestimmte Zeit vergangen ist.
Diese Zeitstempel erzeugen einen historischen Datensatz, da sie belegen, dass Daten zu einem bestimmten Zeitpunkt existierten. Dieser Datensatz entsteht mithilfe einer sequenziellen, gegen Urbildangriffe resistenten Hashfunktion, bei der jeder Hash von seinem Vorgänger abhängt. Verifiable Delay Functions (VDFs) spielen bei der Erzeugung dieser Hashes eine zentrale Rolle. Sie sorgen dafür, dass jeder Hash auf dem vorherigen aufbaut und die seitdem verstrichene Zeit einbezieht. Durch die Integration von VDFs erhält der Hashprozess eine zeitliche Dimension. So lässt sich auf Solana eine verifizierbare Abfolge von Ereignissen mit Zeitstempeln erstellen.
Nachdem wir geklärt haben, wie der Proof-of-History-Mechanismus von Solana mithilfe kryptografischer Zeitstempel eine zuverlässige Ereignisfolge erstellt, müssen wir verstehen, wie er mit dem Konsensmechanismus Tower BFT zusammenspielt. Tower Byzantine Fault Tolerance (BFT) ist Solanas für PoH optimierte Variante des klassischen Konsensmodells Byzantine Fault Tolerance. Tower BFT verwendet den von PoH erzeugten historischen Datensatz als Referenzrahmen. Dadurch können Validatoren effizient und präzise über den Zustand des Ledgers abstimmen. Bei Tower BFT geben Validatoren Stimmen ab, die lange gesperrt bleiben. Mit jeder weiteren Stimme wird ihre Bindung stärker. Dank PoH können Validatoren schneller fundierte Entscheidungen über den Zustand des Ledgers treffen, ohne miteinander kommunizieren zu müssen. Die Kombination aus PoH und Tower BFT beschleunigt den Konsens und verbessert die Sicherheit sowie Zuverlässigkeit des Netzwerks. Das Ergebnis ist eine skalierbare Blockchain-Umgebung mit hohem Durchsatz, in der Transaktionen schnell bestätigt werden.
Transaktionsverarbeitung und Ausführungsumgebungen
Die Effizienz und Skalierbarkeit einer Blockchain hängen vor allem von ihrer Transaktionsverarbeitung und Ausführungsumgebung ab. Diese Faktoren bestimmen, wie schnell Transaktionen ausgeführt werden und wie kosteneffizient Vorgänge im Netzwerk sind. Der Ansatz einer Blockchain zur Transaktionsverarbeitung und die Besonderheiten ihrer Ausführungsumgebungen beeinflussen die Entwicklererfahrung erheblich.
Die Laufzeitumgebung von Ethereum ist eine deterministische, Single-Thread-basierte Stackmaschine namens Ethereum Virtual Machine (EVM). Sie verhält sich wie eine mathematische Funktion. Das heißt: Bei einer bestimmten Eingabe erzeugt die EVM eine deterministische Ausgabe. Ethereum lässt sich als Zustandsübergangsfunktion definieren: f(S, T) = S’. Ausgehend von einem alten Zustand (S) und einer neuen Menge gültiger Transaktionen (T) erzeugt die EVM einen neuen gültigen Ausgabezustand (S’). Bei derselben Transaktionsmenge erreicht die EVM immer denselben Endzustand. Das ist entscheidend, um die Konsistenz zwischen den Nodes des Netzwerks zu wahren.
Die EVM verarbeitet Transaktionen sequenziell. Dadurch wird jede Transaktion in einer Umgebung ausgeführt, die den bis zu diesem Zeitpunkt aktuellen Netzwerkzustand exakt abbildet. Die sequenzielle Ausführung ermöglicht präzise Berechnungen von Zustandsänderungen und Gas-Kosten. Diese Vorhersehbarkeit vermittelt Entwicklern und Nutzern ein klares Bild von den Ergebnissen und Kosten einer Transaktion.
Ethereum vereinfacht die Ausführungsumgebung für Smart Contracts durch ein Single-Thread-Ausführungsmodell. Entwickler profitieren dadurch von vorhersehbaren Zustandsänderungen, da jede Transaktion sequenziell verarbeitet wird. Das macht die Entwicklungsumgebung von Ethereum für neue Entwickler vermutlich zugänglicher. Sie können sich stärker auf die Logik ihrer Smart Contracts konzentrieren als auf die Komplexität der Ausführung. Diese Einfachheit erschwert jedoch die Skalierung. Die sequenzielle Verarbeitung begrenzt den Durchsatz des Netzwerks. Bei hoher Nachfrage kann das zu Überlastung, längeren Wartezeiten für Transaktionen und höheren Gas-Gebühren führen. Da jede Transaktion Gas verbraucht, müssen Entwickler ihren Code auf Gas-Effizienz optimieren. Diese Optimierung verbessert die allgemeine Nutzererfahrung und wirkt Überlastungen entgegen, bei denen ineffizienter Code Anwendungen für durchschnittliche Nutzer unbrauchbar machen kann.
Solana-Entwickler müssen sich nicht wie Ethereum-Entwickler um die Optimierung des Gas-Verbrauchs kümmern. Solana ist als Zustandsmaschine mit hohem Durchsatz und niedriger Latenz konzipiert, die als Solana Virtual Machine (SVM) bezeichnet wird. Eine zentrale Komponente der SVM ist Sealevel. Diese Laufzeit-Engine verarbeitet Transaktionen parallel. Auf Solana teilt jede Transaktion der Laufzeitumgebung mit, welche Teile des Zustands sie bei der Ausführung liest oder schreibt. Die Laufzeitumgebung verarbeitet konfliktfreie Transaktionen sowie Transaktionen, die denselben Zustand lesen, parallel. Sealevel optimiert die Ausführung von Smart Contracts, indem es die Transaktionslast auf mehrere Threads der Validator-Hardware verteilt. Während der Validator eine Transaktion auf einem Kern verarbeitet, kann er gleichzeitig eine weitere auf einem anderen Kern verarbeiten.
Die inhärente Parallelität von Solana senkt die Transaktionskosten erheblich. Solana-Transaktionen haben zwei Gebühren: eine Grundgebühr und eine Prioritätsgebühr. Die Grundgebühr ist auf 5000 Lamports pro Signatur festgelegt. Die meisten Transaktionen enthalten nur eine Signatur. Die Prioritätsgebühr ist optional und ermöglicht es Transaktionen, sich gegenüber anderen Transaktionen zu priorisieren. Der Scheduler priorisiert Transaktionen mit einer höheren Prioritätsgebühr nicht deterministisch. Die Transaktionsgebühren liegen häufig unter 0,001 USD. Die durchschnittliche Gebühr für Transaktionen ohne Abstimmung bewegt sich zwischen 0,000005 und 0,00007 SOL. Die Obergrenze ist aufgrund der jüngsten Zunahme von Prioritätsgebühren höher als üblich. Beim aktuellen SOL-Preis von ~98,96 USD entspricht das ungefähr 0,000494 bis 0,006968 USD.
Diese Gebühren sind außerdem vorhersehbar. Solana steuert die Nachfrage über lokale Gebührenmärkte. Der Blockspace ist so strukturiert, dass kein einzelner Aktivitätsschwerpunkt, etwa ein gehypter NFT-Mint, den Blockspace dominieren und die Gebühren im gesamten Netzwerk erhöhen kann. Höhere Gebühren betreffen nur Transaktionen, die auf einen bestimmten stark nachgefragten Bereich zugreifen möchten. Lokale Gebührenmärkte ermöglichen Prioritätsgebühren, ohne einen umfassenden Gas-Krieg auszulösen. Diese Lokalisierung unterscheidet sich von Gas-basierten Netzwerken wie Ethereum. Dort werden Transaktionen sequenziell verarbeitet, und eine globale Überlastung führt zu schwankenden Gebühren.
Ethereum ist eine Single-Thread-Laufzeitumgebung, die jeweils nur einen Contract verarbeitet. Moderne Multi-Core-Hardware nutzt sie derzeit nicht, weshalb die Validator-Hardware nicht vollständig ausgelastet wird. Der Wunsch, die Hardwareanforderungen für Nodes niedrig zu halten, schränkt die Transaktionsverarbeitung von Ethereum zusätzlich ein. Solanas parallele Verarbeitung kann dagegen alle verfügbaren Kerne eines Validators nutzen und dadurch mehr Transaktionen verarbeiten. Zusammen mit lokalen Gebührenmärkten macht das Solana zu einer deutlich leistungsfähigeren globalen Zustandsmaschine.
Smart-Contract-Sprachen
Die wichtigste Sprache für die Entwicklung von Smart Contracts auf Ethereum ist Solidity. Diese statisch typisierte Sprache mit geschweiften Klammern wurde für Smart Contracts entwickelt, die auf der EVM ausgeführt werden. JavaScript, C++ und Python haben Solidity stark beeinflusst. Entwickler, die mit diesen Sprachen vertraut sind, können sie daher leicht erlernen.
Yul ist eine maschinennahe Zwischensprache, die für EVM-kompatible Blockchains optimiert wurde. Yul bietet Entwicklern mehr Kontrolle über die Ausführung von Bytecode. Dadurch eignet sie sich besonders gut, um den Gas-Verbrauch zu optimieren und andere maschinennahe Vorgänge zu steuern. Entwickler können effizientere Contracts erstellen, indem sie direkt in Yul programmieren oder Yul als Kompilierungsziel verwenden.
Vyper ist eine beliebte, an Python angelehnte Sprache, bei der Einfachheit und Sicherheit im Vordergrund stehen. Sie bietet bewusst weniger Funktionen als Solidity, um die Komplexität und potenzielle Sicherheitslücken zu reduzieren. Die Designphilosophie von Vyper priorisiert vor allem Lesbarkeit und Auditierbarkeit. Dieser Ansatz hat die Entwicklung ähnlicher Sprachen wie Fe sowie von Sprachen wie Dasy inspiriert, die zu Vyper kompiliert werden.
Rust ist die Lingua franca für die Entwicklung von Smart Contracts, die auf Solana umgangssprachlich als Programme bezeichnet werden. Die schnelle und speichereffiziente Sprache bietet eine mit C++ vergleichbare Leistung. Dadurch eignet sie sich für Anwendungen in einem Netzwerk mit hohem Durchsatz und niedriger Latenz. Das umfangreiche Typsystem und das Ownership-Modell von Rust gewährleisten Speicher- und Thread-Sicherheit. Das hilft Entwicklern, zuverlässige und sichere Anwendungen zu erstellen.
Für Entwickler ohne Erfahrung in der Systemprogrammierung hat Rust zwar eine steile Lernkurve, ermöglicht dafür aber robusten und effizienten Code. Die meiste Rust-Entwicklung erfolgt mit Anchor. Dieses meinungsstarke Framework vereinfacht die Programmentwicklung, indem es Boilerplate reduziert, verschiedene standardmäßige Sicherheitsprüfungen durchführt und die (De-)Serialisierung optimiert. Dadurch sind fortgeschrittene Rust-Kenntnisse für den Einstieg weniger wichtig. Zur Einordnung: Die Anchor-Dokumentation empfiehlt, mit den ersten neun Kapiteln des Rust Book vertraut zu sein, also die Grundlagen von Rust zu kennen. Solana Playground bietet mehrere Anchor-Tutorials für den Einstieg.
Rust wird zwar bevorzugt, aber Entwickler sind nicht darauf beschränkt. Sie können C, C++ und jede Sprache verwenden, die auf das BPF-Backend von LLVM abzielt, also jede Sprache, die sich in BPF-Bytecode kompilieren lässt. Entwickler, die mit Python-ähnlichen Sprachen wie Vyper vertraut sind, können mit Seahorse Lang Programme in Python schreiben. So profitieren sie von der Benutzerfreundlichkeit von Python und erhalten dieselben Sicherheitsgarantien wie bei Rust. Mehrere hilfreiche Seahorse-Tutorials, darunter Seahorse University und Seahorse Cookbook, erleichtern dir den Einstieg in die Programmierung auf Solana.
Entwickler, die von Ethereum zu Rust migrieren, sind nicht auf Rust festgelegt. Frameworks wie Anchor und Seahorse sind aufgrund ihrer Beliebtheit und Sicherheitsgarantien zwar empfehlenswert, aber nicht immer praktikabel. Dank neuer Entwicklungen von Solang und Neon Labs können Entwickler mit deren Compiler und EVM-kompatibler Entwicklungsumgebung Solidity für die Programmentwicklung verwenden. Solidity hat auf Solana ein Zuhause. Für den Einstieg in die Programmentwicklung mit Solidity müssen wir die Besonderheiten des Programmiermodells von Solana genauer betrachten. Das Account-Modell von Solana zu verstehen ist für Entwickler bei diesem Umstieg entscheidend, da es die Grundlage für die Programmentwicklung und Interaktion im Netzwerk bildet.
Das Account-Modell verstehen
Ethereum unterteilt Accounts in zwei Hauptkategorien: extern kontrollierte Accounts (EOAs) und Contract-Accounts. EOAs sind der Standard-Accounttyp für Nutzer. Private Schlüssel kontrollieren sie. Sie können Ether-Guthaben halten, Transaktionen senden und mit Contract-Accounts interagieren. Contract-Accounts unterscheiden sich dadurch, dass der in ihnen eingebettete Smart-Contract-Code ihre Vorgänge steuert. Sie können nicht selbstständig Transaktionen initiieren und nur auf Transaktionen reagieren, die sie von EOAs oder anderen Contract-Accounts erhalten.
Solana verwendet ein einheitlicheres Account-Modell und behandelt Accounts als vielseitige Container, die Daten dauerhaft speichern. In diesem Modell kann jeder Account ein Programm sein. Dadurch verschwimmt die klassische Grenze zwischen Account und Smart Contract. Anders als bei Ethereum, wo Code und Zustand in einem einzelnen Account kombiniert sind, sind Solana-Programme zustandslos. Sie speichern also intern keinen Zustand. Stattdessen liegen alle für ihre Arbeit erforderlichen Daten in einem separaten Account und werden über eine Transaktion als Referenz übergeben. Die Übergabe von Accounts als Referenz ermöglicht eine generische Programmbereitstellung, die mit unterschiedlichen Accounts interagieren kann. Das Account-Modell von Solana trennt Code und Daten und schafft so eine effizientere, modularere Entwicklungsumgebung. Davon profitieren Nutzer, die mit mehreren Protokollen interagieren möchten, ohne Assets zwischen verschiedenen Programmen zu verschieben. Auf Solana ist alles ein Account.
Solana-Accounts lassen sich allgemein in ausführbare und nicht ausführbare Accounts unterteilen. Einfach gesagt können ausführbare Accounts Code ausführen. Nicht ausführbare Accounts dienen zur Datenspeicherung und können keinen Code ausführen, da sie keinen Code enthalten.
Ausführbare Accounts enthalten Programme. Programme können weitere Accounts besitzen, aus anderen Accounts lesen oder ihnen Guthaben gutschreiben, Daten ändern oder die von ihnen kontrollierten Accounts belasten. Ausführbare Accounts lassen sich weiter in On-Chain- und native Programme unterteilen. On-Chain-Programme sind von Nutzern geschriebener Code, der im Netzwerk bereitgestellt wird. Ihre Upgrade Authority kann sie aktualisieren. Dabei handelt es sich normalerweise um den Account, der sie bereitgestellt hat. Native Programme sind eine besondere Untergruppe ausführbarer Accounts. Sie ähneln den vorkompilierten Contracts von Ethereum, bieten aber mehr Funktionen. Diese Programme sind in den Kern von Solana integriert und stellen die Funktionen bereit, die Validatoren für ihren Betrieb benötigen. Ein Beispiel für ein natives Programm ist das System Program. Es erstellt neue Accounts, weist Account-Daten Speicher zu, ordnet Accounts Programmen zu, überträgt Lamports aus den von ihm kontrollierten Accounts und bezahlt Transaktionsgebühren. Eine vollständige Liste der nativen Programme findest du hier.
Unabhängig davon, ob sie ausführbar oder nicht ausführbar sind, besitzen alle Accounts dieselben Felder:
- Ein lamports-Feld, das das native SOL-Guthaben eines Accounts erfasst
- Ein Datenfeld für das rohe Byte-Array, das der Account speichert
- Ein Eigentümerfeld, das angibt, welches Programm diesen Account ändern darf
- Ein Signiererfeld, das bei Transaktionen angibt, ob der Account Transaktionen genehmigen kann
- Ein beschreibbares Feld, das festlegt, ob die Daten eines Accounts geändert werden dürfen. Es erleichtert die parallele Verarbeitung, indem es in Transaktionen enthaltene Accounts als schreibgeschützt oder beschreibbar kennzeichnet
- Ein ausführbares Feld, das angibt, ob ein Account ein Programm speichert
- Ein Rent-Epoch-Feld, das die nächste Epoche angibt, in der für den Account Rent fällig wird
Rent sind Speicherkosten, die Accounts auf Solana aktiv halten und dafür sorgen, dass sie im Speicher der Validatoren verbleiben. Dafür müssen Accounts ein Mindestguthaben vorhalten. Rent reduziert das Aufblähen des Zustands, indem das Netzwerk ungenutzte oder unzureichend finanzierte Accounts letztlich zurückgewinnt. Aufgrund neuerer Änderungen gibt es im Mainnet keine Accounts mehr, die Rent zahlen. Stattdessen müssen alle Accounts bei ihrer Erstellung von Rent befreit sein. Ein Account ist von Rent befreit, wenn er ein Mindestguthaben hält, das den Rent-Zahlungen für zwei Jahre entspricht. Mit Tools wie dem Helius API Playground und dem Rent-Unterbefehl der Solana CLI kannst du abschätzen, wie viel SOL ein Account für die Rent-Befreiung benötigt. Das unterscheidet sich vom System zur Ressourcenzuweisung bei Ethereum, wo Speicher bestehen bleibt, sofern er nicht ausdrücklich gelöscht wird. Solanas Ansatz bietet eine besser vorhersehbare Kostenstruktur für die Zustandsspeicherung und reduziert zugleich das Aufblähen des Zustands.
Adressen und Program Derived Addresses (PDAs)
Jeder Account wird durch seine Adresse identifiziert, einen eindeutigen öffentlichen 32-Byte-Schlüssel. Das unterscheidet sich vom Datenmodell von Ethereum, bei dem Adressen 20 Byte lang sind. Solana erzeugt Adressen mit ed25519, also einem EdDSA-Signaturverfahren, das SHA-512 und die elliptische Kurve Curve22519 verwendet. Ein Account muss ein Punkt auf der ed25519-Kurve sein, um ein gültiges Schlüsselpaar zu besitzen.
Program Derived Addresses (PDAs) sind Accounts, die mithilfe eines Bumps außerhalb der Kurve erzeugt werden. Ein Bump ist ein Wert, der die Ausgabe aus der Kurve verschiebt. PDAs benötigen drei Hauptbestandteile: die Adresse ihres übergeordneten Programms, eine Menge von Seeds und einen Bump. Die Seeds sind ein Array aus Strings mit beliebigen Werten. Die meisten Entwickler erstellen jedoch spezifische Seeds, die sich auf Zustandsvariablen im übergeordneten Programm beziehen, um Hashmap-ähnliche Datenstrukturen zu erzeugen. Eine PDA entsteht somit, indem die Programm-ID, die Seeds und der Bump mit der Hashfunktion SHA-512 gehasht werden.
PDAs liegen außerhalb der Kurve, damit nur das Programm, von dem eine PDA abgeleitet ist, in ihrem Namen signieren kann. Das optimiert den Transaktionsablauf, indem Transaktionssignaturen programmgesteuert erzeugt werden. So können vertrauenslose dApps ohne Eingriffe reibungslos funktionieren.
Mit einem Account interagieren
Eine Ethereum-Transaktion ist eine zustandsverändernde Aktion, die von einem EOA initiiert wird. Smart Contracts können Transaktionen nicht selbstständig initiieren, sondern nur darauf reagieren. Der Code des Contracts bestimmt diese Reaktionen. Die Kosten der Transaktionsausführung werden in Gas gemessen. Nutzer müssen genügend Ether bereitstellen, um diese Gas-Gebühr zu decken.
Ethereum-Transaktionen führen typischerweise einen einzelnen Vorgang aus, etwa den Aufruf einer bestimmten Smart-Contract-Funktion. Eine einzelne Transaktion kann zwar mehrere Zustandsänderungen innerhalb eines Contracts auslösen, doch alle Änderungen bleiben auf diesen einen Contract-Aufruf beschränkt.
Auf Solana besteht eine Transaktion aus einem Array von Accounts, aus denen gelesen oder in die geschrieben wird, einer oder mehreren Signaturen und einer oder mehreren Anweisungen. Eine Anweisung ist eine Direktive für den Aufruf eines einzelnen Programms. Sie ist die kleinste Einheit der Ausführungslogik und die grundlegendste operative Einheit. Anweisungen geben das ausführende Programm, alle beteiligten Accounts und die operativen Daten an. Programme interpretieren die Daten einer Anweisung und führen Vorgänge mit den angegebenen Accounts aus. Durch diese Struktur kann eine einzelne Transaktion atomar eine Reihe von Aktionen über mehrere Programme hinweg ausführen. Das bedeutet, dass entweder alle Anweisungen erfolgreich sind oder alle fehlschlagen. Der Transaktionsablauf von Solana unterscheidet sich vom Ethereum-Modell, bei dem eine Transaktion normalerweise mit einem einzelnen Smart Contract oder einer EOA-Aktion verknüpft ist.
Cross-Program Invocations (CPIs) ermöglichen es einem Programm, während derselben Transaktion ein anderes Programm aufzurufen. Pro Compute Unit werden bei einer CPI 250 Byte an Account-Daten berechnet. Bei 200.000 Einheiten entspricht das ungefähr 50 MB. CPIs ermöglichen die Verwendung programmgesteuert erzeugter Signaturen bei Aufrufen zwischen Programmen. Das ähnelt dem effizienten und atomaren Aufruf eines anderen Contracts durch einen Ethereum-Smart-Contract. Das aufrufende Programm wird jedoch angehalten, bis das aufgerufene Programm die Anweisung vollständig verarbeitet hat. Reentrancy ist auf direkte Selbstrekursion mit einer festen maximalen Tiefe von 4 beschränkt. Das verhindert Situationen, in denen ein Programm aus einem Zwischenzustand heraus ein anderes aufruft, ohne zu wissen, dass dieses später einen Rückruf auslösen könnte.
Solana-Transaktionen unterliegen aus Effizienzgründen einer Größenbegrenzung, ähnlich dem Gas-Limit von Ethereum. Der Schwerpunkt liegt jedoch auf der Datengröße. Solana-Transaktionen halten sich an die Standards der IPv6 Maximum Transmission Unit (MTU), um eine zuverlässige Datenübertragung sicherzustellen. Nach Abzug des erforderlichen Platzes für den Header stehen 1232 Byte für Paketdaten zur Verfügung. Solana führte versionierte Transaktionen ein, um mehrere Transaktionsformate zu unterstützen und Größenbeschränkungen zu überwinden. Zusätzlich zum Legacy-Format, also dem ursprünglichen Transaktionsformat, wurde Version 0 veröffentlicht, um Address Lookup Tables (ALTs) zu unterstützen. ALTs speichern Adressen on-chain in einer tabellenähnlichen Datenstruktur, in der jede Adresse über einen 1 Byte großen u8-Index indexiert wird. Das reduziert die Transaktionsgröße erheblich, da jeder Account nur noch 1 Byte statt 32 Byte benötigt.
Solang
Solang ist ein Solidity-Compiler für Solana und Polkadot. Er soll Quellcode-Kompatibilität mit Version 0.8 des Solidity-Compilers der EVM erreichen, enthält jedoch einige Anpassungen an die Architekturen von Solana und Polkadot. Ein wesentlicher Bestandteil von Solang ist LLVM, eine leistungsfähige Compiler-Infrastruktur. Dank der Flexibilität von LLVM kann Solang künftig weitere Programmiersprachen unterstützen und deren Implementierung und Kompilierung vereinfachen. Damit verfolgt Solang sein Ziel, Entwicklern den Wechsel zu Solana oder Polkadot zu erleichtern und die Einsatzmöglichkeiten von Solidity zu erweitern. Solang wird kontinuierlich weiterentwickelt. Der Fokus liegt auf besserer Kompatibilität, Effizienz und Benutzerfreundlichkeit. Ethereum-Entwickler, die ihre Fähigkeiten Cross-Chain einsetzen möchten, sollten Solang und seine Einschränkungen verstehen.
Installation
Du kannst Solang auf verschiedene Arten installieren. Auf einem Mac kannst du Solang über einen privaten Tap mit Brew herunterladen:
brew install hyperledger/solang/solangEine weitere Möglichkeit ist die Installation über Solang-Container. Das ist ideal, wenn du Docker bevorzugst, da neue Images automatisch in diesen Containern bereitgestellt werden. Es gibt ein v.0.3.3-Tag und ein latest-Tag:
docker pull ghcr.io/hyperledger/solang:latestEine der einfacheren Möglichkeiten, Solang zu installieren und zu verwenden, führt über Ancor. Stelle zunächst sicher, dass Rust und Node.js auf deinem System installiert sind. Unter Windows musst du außerdem das Windows-Subsystem für Linux einrichten. Jetzt müssen wir die Tool-Suite von Solana installieren. Unter Mac und Linux funktioniert das mit folgendem Befehl:
sh -c "$(curl -sSfL https://release.solana.com/v1.17.13/install)"Wenn du eine andere Softwareversion bevorzugst, ersetze „v1.17.13“ durch das passende Release-Tag. Alternativ kannst du einen der folgenden symbolischen Kanalnamen verwenden: stable, beta oder edge. Abhängig von deinem System musst du eventuell deine PATH-Umgebungsvariable aktualisieren. Wenn diese Meldung erscheint, kopiere den darunter empfohlenen Befehl und führe ihn aus, um PATH zu aktualisieren. Mit solana --version kannst du prüfen, ob die gewünschte Version von solana installiert ist.
Öffne unter Windows die Eingabeaufforderung als Administrator. Kopiere den folgenden Befehl und führe ihn aus, um das Solana-Installationsprogramm in ein temporäres Verzeichnis herunterzuladen:
cmd /c "curl https://release.solana.com/v1.17.13/solana-install-init-x86_64-pc-windows-msvc.exe --output C:\solana-install-tmp\solana-install-init.exe --create-dirs"Kopiere anschließend den folgenden Befehl und führe ihn aus, um die neueste Version von Solana zu installieren: C:\solana-install-tmp\solana-install-init.exe v1.17.13. Drücke nach Abschluss der Installation die Eingabetaste.
Schließe die Eingabeaufforderung und öffne eine neue Instanz als regulärer Benutzer. Führe solana –-version aus, um zu prüfen, ob die gewünschte Version von solana installiert ist.
Installiere als Nächstes Anchor.
Wir empfehlen, Anchor mit dem Anchor Version Manager (avm) zu installieren. Das geht über cargo mit folgendem Befehl:
cargo install -git https://github.com/coral-xyz/anchor avm --locked --force.Installiere und verwende anschließend die neueste Version:
avm install latest
avm use latest
# Verify the installation
avm –versionMit Anchor Version 0.28 können Entwickler direkt mit Solang bauen. Mit dem Befehl anchor init project_name —solidity kannst du ein neues Solang-Projekt erstellen. Dadurch entstehen ein neues Solang-Programm und eine Testdatei, die zeigt, wie der Client mit dem Programm interagiert.
Wenn du Visual Studio Code verwendest, solltest du die Solang-Erweiterung für das Syntax-Highlighting installieren. Deaktiviere alle anderen aktiven Solidity-Erweiterungen, damit die Solang-Erweiterung korrekt funktioniert.
Neues Projekt erstellen
Erstelle mit dem Befehl anchor-init project_name –solidity ein neues Projekt. Dadurch entsteht ein neues Verzeichnis mit dem Namen deines Projekts. Das Solidity-Flag weist Anchor an, Solang zu verwenden. Im Verzeichnis ./solidity des Projekts findest du ein Startprogramm. Der Contract sieht wie folgt aus:
@program_id("F1ipperKF9EfD821ZbbYjS319LXYiBmjhzkkf5a26rC")
contract test {
bool private value = true;
@payer(payer)
constructor() {
print("Hello, World!");
}
/// A message that can be called on instantiated contracts.
/// This one flips the value of the stored `bool` from `true`
/// to `false` and vice versa.
function flip() public {
value = !value;
}
/// Simply returns the current value of our `bool`.
function get() public view returns (bool) {
return value;
}
}Dieses Programm besitzt constructor, um das Programm zu erstellen, die Zustandsvariable value mit true zu initialisieren und „Hello, World!“ in die Programmlogs zu schreiben. Die Funktion flip aktualisiert beim Aufruf die Zustandsvariable. Die Funktion get gibt den aktuellen Wert der Zustandsvariable zurück. Das sieht wie ein normaler Solidity-Smart-Contract aus, allerdings mit einigen Besonderheiten. Der wichtigste Unterschied ist die Verwendung von Annotationen.
Annotationen
Annotationen dienen zur Verwaltung von Accounts. Beachte die Annotation @program_id(“...”). Sie gibt die On-Chain-Adresse des Programms an, sofern diese bereits bekannt ist. Wenn du einen Contract über einen externen Aufruf ansprechen möchtest, muss das Programm entweder die Notation @program_id besitzen oder mit dem Argument {program_id: … } aufgerufen werden:
@program_id(“...”);
contract Foo {
function hello() public pure {
print(“Hello”);
}
}
contract Foo2 {
function bye() public pure {
print(“Bye”);
}
}
contract Bar {
function new_foo() external {
Foo.new();
}
}
contract Bar2 {
function new_foo(address new_foo_id) external {
Foo2.new{program_id: new_foo_id}();
}
}Als wir ein neues Projekt erstellt haben, enthielt der bereitgestellte Beispiel-Contract die Annotation @payer über dem Konstruktor. Diese Annotation definiert den Account, der für die Initialisierung des Daten-Accounts des Programms bezahlt. Die Syntax @payer(payer) deklariert einen Account namens payer, der bei jedem Aufruf des Konstruktors erforderlich ist.
Wenn ein Contract instanziiert wird, benötigt er einen Programm-Account für den ausführbaren Code und einen Daten-Account zum Speichern der Zustandsvariablen. Der Daten-Account kann durch clientseitigen Code erstellt und anschließend an die Transaktion übergeben werden, die den Konstruktor aufruft. Alternativ kann der Konstruktor den Daten-Account erstellen. Mindestens die Annotation @payer muss angegeben werden. Wenn der Daten-Account eine PDA sein soll, müssen ein Seed und ein Bump angegeben werden. Die Annotation @seed legt einen Seed zum Ableiten der PDA fest. Dabei kann es sich um ein String-Literal oder einen Hex-String im Format hex”1234” handeln. Wenn die Seed-Annotation vor einem Argument steht, muss sie auf ein Argument des Typs bytes, address oder auf ein Byte-Array fester Länge verweisen. Die Annotation @bump gibt den Wert an, mit dem eine Off-Curve-Adresse erzeugt wird. Er muss aus einem einzelnen Byte des Typs bytes1 bestehen. Mit der optionalen Annotation @space kannst du die Größe des Daten-Accounts angeben. Sie ist ein uint64-Ausdruck, der eine Konstante sein oder eines der Konstruktorargumente verwenden kann. Laut Solang-Dokumentation sollte @space mindestens der Größe entsprechen, die beim Ausführen des Befehls solang -v angegeben wird:
$ solang compile --target solana -v examples/solana/flipper.sol
...
info: contract flipper uses at least 17 bytes account data
…Wenn ein Programm keinen Konstruktor besitzt, können diese Annotationen mit einem leeren Konstruktor kombiniert werden. Die Solang-Dokumentation enthält das folgende Beispiel:
@program_id("Foo5mMfYo5RhRcWa4NZ2bwFn4Kdhe8rNK5jchxsKrivA")
contract Foo {
@space(500 + 12)
@seed("Foo")
@payer(payer)
constructor(@seed bytes seed_val, @bump bytes1 bump_val) {
// ...
}
}Funktionsannotationen deklarieren die erforderlichen Accounts für externe Funktionen:
@account(foo)deklariert den Accountfooals schreibgeschützten Account@mutableAccount(bar)deklariert den Accountbarals veränderbaren Account@signer(fizz)deklariert den Accountfizzals schreibgeschützten Signierer@mutableSigner(buzz)deklariert den Accountbuzzals veränderbaren Signierer
Auf Accounts, die im Konstruktor mit der Annotation @payer deklariert wurden, kannst du innerhalb des Konstruktors zugreifen. Mit Funktionsannotationen deklarierte Accounts sind im Vektor tx.accounts verfügbar. Beispielsweise verwendest du tx.accounts.ichigo, um auf den mit @account(ichigo) deklarierten Account zuzugreifen. Dies gibt die integrierte AccountInfo-Struktur zurück. Diese Struktur entspricht dem Aufbau, den wir im Abschnitt „Das Account-Modell verstehen“ beschrieben haben. Die Bezeichnungen unterscheiden sich geringfügig:
key: die Adresse oder der öffentliche Schlüssel des Accounts. Der Typ istaddresslamports: das Lamport-Guthaben des Accounts. Der Typ istuint64data: die Daten des Accounts. Der Typ istbytesowner: der Eigentümer des Accounts. Der Typ istaddressrent_epoch: die nächste Epoche, in der die Miete des Accounts fällig wird. Der Typ istuint64is_signer: gibt an, ob der Account die Transaktion signiert hat. Der Typ istboolis_writable: gibt an, ob der Account in dieser Transaktion beschreibbar ist. Der Typ istboolexecutable: gibt an, ob der Account ein Programm ist. Der Typ istbool
Einschränkungen
Die wichtigsten Inkompatibilitäten zwischen Solang und der herkömmlichen Ethereum-Entwicklung sind:
msg.senderist auf Solana nicht verfügbar. Mit dem Account-Modell kann ein Rust-Contract auf verschiedene Daten-Accounts zugreifen. Welcher davon wäre dann der Aufrufer? In vielen Fällen lässt sich kein einzelner Account als Aufrufer bestimmen. Außerdem besitzt die Runtime keinen Mechanismus zum Abrufen von Aufrufer-Accounts- Es gibt keine Funktion
ecrecover(), aber eine FunktionsignatureVerify()zum Prüfen von ed25519-Signaturen. - Try-Catch-Anweisungen funktionieren nicht. Wenn ein externer Aufruf oder die Erstellung eines Contracts fehlschlägt, beendet die Runtime die Ausführung und setzt die gesamte Transaktion zurück.
- Fehlerdefinitionen und Reverts mit Fehlermeldungen funktionieren noch nicht
- Das Übertragen nativer Werte mit einem Funktionsaufruf funktioniert nicht.
- Viele integrierte Yul-Funktionen sind nicht verfügbar. Solang unterstützt die meisten integrierten Funktionen. Speicher- und Chain-Operationen sind jedoch nicht implementiert.
- Das ERC-20-Format wird derzeit nicht unterstützt. SPL-Token werden gemäß dem Token Program definiert. Das Token Program ist die native Methode von Solana, um Token zu erstellen, zu prägen, zu übertragen und zu verbrennen. Die Datei spl_token.sol sollte in deinen Quellbaum kopiert und dort importiert werden, wo du die Bibliothek
SplTokenbenötigst
Außerdem sind die Register der SVM 64 Bit breit. Daher sind 64-Bit-Ganzzahlen wie uint64 und int64 gegenüber 256-Bit-Ganzzahlen vorzuziehen. Eine Operation mit Typen, die breiter als 64 Bit sind, etwa uint256 oder int256, wird in mehrere Operationen aufgeteilt. Das macht sie langsamer und verbraucht mehr Compute Units.
Adressliterale müssen mit der Syntax address"36VtvSbE6jVGGQytYWSaDPG7uZphaxEjpJHUUpuUbq4D" angegeben werden. Die Hex-Syntax von Ethereum, zum Beispiel 0xE0f5206BBD039e7b0592d8918820024e2a7437b9, wird nicht unterstützt. Alle Guthaben und Werte auf Solana sind 64 Bit breit. Daher verwenden die integrierten Adressfunktionen .balance(), .transfer() und .send() 64-Bit-Ganzzahlen.
Solang bietet EVM-Entwicklern einen interessanten Weg in das Solana-Ökosystem, hat aber mehrere Einschränkungen, die du sorgfältig abwägen solltest. Der Wechsel zum Account-basierten Modell von Solana ist nicht nur syntaktischer Natur. Er verändert die Smart-Contract-Logik grundlegend. Bestimmte Funktionen, Programmiermuster und EVM-spezifische Features sind mit Solang nicht verfügbar. Entwickler können einen Ethereum-Smart-Contract nicht einfach nach Solang portieren und erwarten, dass er ohne erhebliche Anpassungen funktioniert. Fehlende Features wie korrekte Fehlerdefinitionen und Reverts mit Fehlermeldungen können schwerwiegende Folgen haben. Solang entwickelt sich jedoch ständig weiter. Jedes Update soll die Erfahrung für Solidity-Entwickler auf Solana verbessern. Solang bietet mehrere klare Vorteile, die dazu beitragen.
Vorteile
Trotz dieser Einschränkungen verbessern zahlreiche integrierte Funktionen und Designentscheidungen die Entwicklererfahrung. In Solang entwickelte Contracts können beispielsweise mit Anchor-Programmen interagieren. Dafür kannst du aus der IDL eines Anchor-Programms eine Solidity-Schnittstelle generieren. IDL steht für „Interface Description Language“. Im Wesentlichen handelt es sich um eine JSON-Datei mit allen Spezifikationen eines Programms. Sie enthält alles, was du für die Interaktion mit einem Anchor-Programm wissen musst. Anchor generiert bei der Entwicklung eines Programms mit seinem Framework automatisch eine IDL. Das ähnelt stark den ABIs auf Ethereum. Verwende den folgenden Befehl, um aus einer IDL eine Solidity-Schnittstelle zu generieren: solang idl [-output directory] [IDL file]. Anschließend kannst du die Datei mit der Syntax import “...”; importieren.
Solang stellt die Solana-Bibliothek bereit. Diese Reihe von Bibliotheken ermöglicht Solidity-Contracts die Interaktion mit Solana-spezifischen Anweisungen. Für das Prägen, Verbrennen und Übertragen von Token bietet Solang die SPL-Token-Bibliothek. Sie kann als Entsprechung zu ERC-20 und ERC-721 betrachtet werden. Solang stellt außerdem die System-Instructions-Bibliothek bereit, mit der Entwickler mit dem System Program von Solana interagieren können.
Solang enthält außerdem integrierte Funktionen, die du mit solana importieren kannst. Dazu gehören die Strukturen AccountMeta und AccountInfo. Mit der Struktur AccountMeta legst du fest, welche Accounts bei einem externen Aufruf, also einer CPI, an den Aufgerufenen übergeben werden. Die Struktur AccountMeta hat folgenden Aufbau:
pubkey: die Adresse oder der öffentliche Schlüssel des Accounts. Der Typ istaddressis_writable: gibt an, ob der Aufgerufene in diesen Account schreiben darf. Der Typ istboolis_signer: gibt an, ob der Aufgerufene davon ausgehen darf, dass dieser Account die Transaktion signiert hat. Der Typ istbool
Wenn das Argument accounts bei einem externen Aufruf fehlt, generiert der Solang-Compiler automatisch ein AccountMeta-Array. Das funktioniert nur, wenn die Funktion als extern deklariert ist. Andernfalls musst du das AccountMeta-Array manuell gemäß der in der IDL angegebenen Account-Reihenfolge erstellen. Wenn ein bestimmter Aufruf keine Accounts benötigt, übergib einen leeren Vektor: {accounts: []}. Die Solang-Dokumentation enthält ein gutes Beispiel für den Aufbau des Arrays AccountMetas:
function build_this() external {
// When calling a constructor from an external function, the data account for the contract
// 'BeingBuilt' should be passed as the 'BeingBuilt_dataAccount' in the client code.
BeingBuilt.new("my_seed");
}
function build_that(address data_account, address payer_account) public {
AccountMeta[3] metas = [
AccountMeta({
pubkey: data_account,
is_signer: true,
is_writable: true
}),
AccountMeta({
pubkey: payer_account,
is_signer: true,
is_writable: true
}),
AccountMeta({
pubkey: address"11111111111111111111111111111111",
is_writable: false,
is_signer: false
})
];
BeingBuilt.new{accounts: metas}("my_seed");
// No accounts are needed in this call, so we pass an empty vector.
BeingBuilt.say_this{accounts: []}("It's summertime!");
}Solang besitzt außerdem integrierte Funktionen für:
- Berechnung des Mindestguthabens, das zum Erstellen eines bestimmten Accounts erforderlich ist
- Erstellung einer PDA für eine Programmadresse anhand der angegebenen Seeds und des Bumps
- Ermittlung einer PDA für eine Programmadresse anhand der angegebenen Seeds und des Bumps
Solang schließt die Lücke zwischen Solana und Ethereum. Der Compiler bietet ein umfangreiches Toolset, das EVM-Entwicklern den Wechsel erleichtert. Trotz seiner Einschränkungen bietet Solang mehrere Features für eine bessere Entwicklererfahrung. Dazu gehören die Interaktion mit Anchor-Programmen, der Zugriff auf Solana-spezifische Bibliotheken und integrierte Funktionen. Vertraute Konzepte wie IDLs und Token-Standards erleichtern den Einstieg zusätzlich. Dass du dir keine Gedanken über Gas machen oder dafür optimieren musst, ist ebenfalls ein willkommener Vorteil. Solang ist ein wichtiger Schritt hin zur Interoperabilität zwischen Solana und Ethereum. Für EVM-Entwickler, die in die hochperformante Welt von Solana expandieren möchten, ist Solang ein mögliches Tool.
Neon EVM
Solang ist nicht die einzige Option für Solidity-Entwickler, die auf Solana entwickeln möchten. Neon EVM bezeichnet sich selbst als die weltweit erste parallelisierbare EVM. Sie bietet eine vollständig kompatible Ethereum-Umgebung auf Solana. Das ist eine synergetische Lösung für alle, die Ethereum-dApps entwicklerfreundlich auf Solana skalieren möchten. Entwickler können ihre dApps ohne Neukonfiguration der Smart Contracts bereitstellen. Sie verwenden weiterhin ihre bevorzugten Sprachen und Tools.
Architektur
Neon EVM besteht aus drei Hauptkomponenten: dem Neon EVM-Programm, Neon Proxy und Neon DAO.
Neon EVM ist ein Solana-Programm, das Ethereum-ähnliche Transaktionen akzeptiert und sie gemäß den Regeln der EVM auf Solana verarbeitet. Diese an Neon EVM gerichteten Ethereum-ähnlichen Transaktionen werden als Neon Transactions bezeichnet. Sie bilden eine Teilmenge der JSON RPC-Methoden gemäß der Ethereum JSON-RPC API.
Neon Proxy ermöglicht Ethereum-Entwicklern, ihre dApps mit minimalen Änderungen zu Neon zu portieren. Er verpackt EVM-Transaktionen in Solana-Transaktionen und dient Neon Operators als containerisierte Lösung. Diese Betreiber führen Neon Proxy-Server aus, akzeptieren Zahlungen in NEON und leisten innerhalb des Solana-Ökosystems Zahlungen in SOL. NEON ist sowohl ein Utility- als auch ein Governance-Token: Neon Operators erheben ihn, um die für die Transaktionsausführung anfallenden Gasgebühren zu bezahlen, und Eigentümer können an Neon DAO teilnehmen.
Neon DAO ist ein Community-gesteuertes Governance-Modell, das Inhaber von NEON-Token an Entscheidungen für Neon EVM beteiligt. Es umfasst Benutzer, Betreiber, Mitwirkende sowie Core- und Anwendungsentwickler, die gemeinsam über Governance-Regeln und die Weiterentwicklung des Protokolls beraten. Die DAO arbeitet über verschiedene dezentrale Versammlungen, deren Schwerpunkte auf dem Ökosystem, der Entwicklung und der Sicherheit liegen. Jede Versammlung ermöglicht gemeinsame Entscheidungen und prüft Vorschläge für ihren jeweiligen Bereich. Die auf das Ökosystem ausgerichtete Versammlung überwacht dessen nachhaltiges Wachstum und verwaltet Mittel für Förderungen und Initiativen. Die auf Entwicklung ausgerichtete Versammlung kümmert sich um technische Upgrades des Neon-Programms und Notfalleingriffe. Die auf Sicherheit ausgerichtete Versammlung schützt die Treasury von Neon und das Neon-Programm vor potenziellen Bedrohungen.
EVM-Kompatibilität
Neon EVM ermöglicht EVM-Interaktionen auf Solana durch:
- Implementierung der meisten JSON-RPC API-Methoden von Ethereum
- Verwendung eines speziellen Proxys zur Verarbeitung von Ethereum-Aufrufen
- Anpassung an die Unterschiede und Einschränkungen der Solana-Architektur
Die Interaktion mit Neon EVM ähnelt der mit jeder anderen EVM. Entwickler können vertraute RPC API-Methoden an Neon Proxy senden und erhalten so eine nahtlose Entwicklererfahrung. Zu den wichtigsten Features gehören:
- Kompatibilität mit Solidity- und Vyper-Smart-Contracts sowie mit gängigen Ethereum-Entwicklungstools wie Metamask, Foundry und Remix
- Unveränderte Unterstützung der meisten Ethereum-Opcodes
- Annahme von Ethereum-Transaktionsanfragen des Typs 0 bzw. Legacy-Transaktionen. EIP-1559-Transaktionen werden derzeit nicht unterstützt
Damit Neon EVM korrekt auf Solana funktioniert, sind natürlich bestimmte Anpassungen nötig. Zu den wichtigsten Unterschieden gehören:
- Neon EVM unterstützt alle auf evm.code definierten vorkompilierten Contracts. Solidity-Contracts mit den folgenden Aufrufen werden jedoch nicht ausgeführt:
bigModExp,bn256Add,bn256ScalarMultundbn256Pairing. Neon EVM muss Solana-Systemaufrufe implementieren, um diese Contracts künftig zu unterstützen - Die meisten Opcodes werden unverändert unterstützt. Die Opcodes
COINBASE,PREVRANDAO (FKA DIFFICULTY),GASLIMIT,BASEFEEundGASjedoch nicht. Sie werden als Varianten-Opcodes bezeichnet und für den Einsatz in Neon EVM angepasst. - Gasverbrauch und Gebührenberechnung unterscheiden sich von Ethereum. Durch Solana als Settlement-Layer fallen die Kosten in der Regel niedriger aus
- Die Solidity-Methoden
transfer()undsend()sind in Neon EVM aufgrund der abweichenden Gasberechnung nicht vor Reentrancy geschützt - Das Account-Modell von Solana beeinflusst den Smart-Contract-Speicher. Für ausführbare und nicht ausführbare Accounts gelten andere Speicherfunktionen und Zugriffsrechte
- Neon EVM verwendet versionierte Transaktionen. Dadurch ist die maximale Anzahl der in einer einzelnen Transaktion verwendeten Accounts auf 64 begrenzt
- Neon EVM verwendet den Berkley Packet Filter (BPF) von Solana mit einem Heap-Speicherlimit von 256 KB. Das begrenzt die Größe von Contract-Aufrufen und erfordert Optimierungsstrategien, um die Speichernutzung effektiv zu verwalten
- Zeitbasierte Funktionen wie
block.numberundblock.timestampverhalten sich anders. Entwicklern wird dringend davon abgeraten, sie bei der Entwicklung auf Neon EVM zu verwenden
Neon EVM bietet zwar eine vertraute, kompatible Umgebung, doch EVM-Entwickler müssen die zentralen Unterschiede kennen und berücksichtigen, um erfolgreich zu Solana zu migrieren und darauf zu entwickeln.
Verbindung mit einem Neon RPC
Über Chainlist können Entwickler ganz einfach eine Verbindung mit einem Neon RPC herstellen. Du kannst dich dort entweder mit dem Mainnet oder dem Devnet von Neon EVM verbinden. Klicke im Mainnet- oder Devnet-Dialog auf Wallet verbinden und anschließend auf Genehmigen, sobald sich deine Wallet öffnet.
Bevor Benutzer Transaktionen an Neon EVM senden, sollten sie den optimalen Betreiber auswählen. Klappe die Kartendetails auf, um die verfügbaren RPC-Endpunkte für jedes Netzwerk anzuzeigen:
Wenn du einen anderen Operator als den bei der Wallet-Verbindung vorgegebenen Standard auswählst, musst du die Verbindung manuell herstellen. Die Dokumentation von Neon EVM enthält ausführliche Anleitungen zum Verbinden mit einem Proxy über Foundry, Hardhat, Remix und Truffle. Im Abschnitt zur Bereitstellung zeigen wir, wie du die Verbindung mit Foundry herstellst.
Nach dem Verbindungsaufbau können Entwickler über den Neon Faucet NEON oder andere ERC-20-Test-Token beziehen. Über den Endpunkt request_neon lassen sich Token auch programmgesteuert anfordern:
curl -i -X POST \
-d '{"wallet": "Your wallet", "amount": 1}' \
'http://localhost:3333/request_neon'Dieser Befehl sendet eine POST-Anfrage, um Token an der angegebenen Wallet-Adresse zu empfangen.
Transaktionslebenszyklus und Gasgebühren
Eine Transaktion aus einer Ethereum-dApp wird über Neon EVM in drei Hauptschritten auf Solana ausgeführt:
- Ein Benutzer initiiert eine signierte Ethereum-ähnliche Transaktion, die an einen Neon RPC-Endpunkt gerichtet ist
- Die Transaktion wird über die Ethereum API an Neon Proxy übergeben. Der Proxy schätzt das für die Ausführung erforderliche Gas, startet die Übertragung, indem er die Ethereum-ähnliche Transaktion in eine Solana-Transaktion verpackt, und sendet die verpackte Transaktion an Neon EVM. Daraus entstehen ein Solana-Beleg und ein entsprechender Neon EVM-Beleg der Transaktion. Der Neon-Smart-Contract entpackt die Transaktion, prüft die Signatur des Benutzers und lädt den EVM-Zustand aus dem Solana-Speicher. Die Transaktion wird innerhalb des BPF von Solana ausgeführt
- Solana und Neon EVM aktualisieren ihre Zustände, um die Transaktionsanfrage abzuschließen
Das ist der vollständige Lebenszyklus einer Transaktion in Neon EVM, von der Initiierung bis zur Ausführung. Auf NeonScan können Entwickler die neuesten Transaktionen und Blöcke einsehen sowie Accounts, Token, Blöcke oder Transaktions-Hashes abfragen.
Entwickler können auch gaslose Transaktionen senden. Diese Funktion unterstützt Benutzer, die nicht genügend NEON-Token besitzen, um ihre ersten Transaktionsgebühren zu decken. Entwickler können unter info@neonevm.org ein Starterpaket mit gaslosen Transaktionen anfordern. Der vom Entwickler ausgewählte Proxy Operator verarbeitet diese Transaktionen weiterhin, Neon übernimmt jedoch die Transaktionskosten. Pro neuem Neon-Account werden normalerweise mindestens drei gaslose Transaktionen angeboten.
Gaslose Transaktionen laufen wie folgt ab:
- Ein Endbenutzer initiiert über eine dApp eine Transaktion
- Die dApp fragt den aktuellen Gaspreis beim ausgewählten Proxy Operator ab. Wenn der Account berechtigt ist, markiert der Proxy Operator den Neon-Account für eine bestimmte Anzahl gasloser Transaktionen
- Für diese Transaktionen zeigt die dApp Gaskosten von null an
- Der Endbenutzer signiert die Transaktion ohne Gasgebühr
- Der Proxy Operator führt die Transaktion aus. Die Neon Foundation bezahlt die Gasgebühr in SOL
Die Dokumentation von Neon EVM enthält den folgenden Auszug, der zeigt, wie du eine gaslose Transaktion anforderst:
try {
// Get gasless transaction if user account is eligible
const rawGasPrice = await axios.post(rpcApiUrl, {
method: 'neon_gasPrice',
params: [{ from: address }],
jsonrpc: "2.0",
id: new Date().getTime()
})
tx.gasPrice = rawGasPrice.data?.result;
} catch (e) {
//Else, get standard GAS price
setError('Can\'t retrieve gas price for transaction')
const rawGasPrice = await web3.eth.getGasPrice();
tx.gasPrice = web3.utils.toHex(rawGasPrice);
} finally {
setTx(tx)
}NeonPass
NeonPass ist ein Tool zum Übertragen von Token zwischen Solana und Neon EVM. Es ermöglicht nahtlose Asset-Transfers zwischen den Associated Token Accounts von Solana und den ERC-20-Token-Accounts von Neon EVM. NeonPass verwendet den Schnittstellen-Contract und den spezialisierten Account-Speicher von Neon EVM. Token der Solana Program Library (SPL) werden im Factory-Contract von Neon EVM in eine ERC-20-Schnittstelle verpackt. Dadurch können SPLs in ERC-20-Token-Accounts gespeichert werden, die mit Solidity-dApps kompatibel sind. NeonPass ermöglicht die bidirektionale Übertragung von Token zwischen Solana- und Neon EVM-Accounts. Anders als herkömmliche Bridges, die Assets sperren und neue prägen, verschiebt es Token direkt zwischen den beiden Account-Typen. Das ermöglicht einen nahtlosen Transfer von Solana- und Neon EVM-Token.
Bereitstellung
Entwickler können mit Hardhat, Foundry, Truffle und Remix auf Neon EVM bereitstellen. Da Solang am einfachsten über Anchor verwendet wird, erfolgen alle Tests in TypeScript. Für alle Solidity-Maxis können wir Solidity-dApps nun aber endlich über Foundry auf Solana testen und bereitstellen.
Stelle zunächst sicher, dass du eine EVM-kompatible Wallet mit dem Neon EVM Devnet verbunden hast. Klone anschließend das Foundry-Beispielprojekt von Neon und wechsle in dessen Verzeichnis:
git clone https://github.com/neonlabsorg/neon-tutorials
cd neon-tutorials/foundryInstalliere anschließend Foundryup, das Installationsprogramm für die Foundry-Toolchain. Führe dann foundryup aus, um die neuesten nächtlichen vorkompilierten Binärdateien zu installieren, also force, cast, anvil und chisel:
curl -L https://foundry.paradigm.xyz | bash
foundryupInstalliere die erforderlichen Bibliotheken:
forge install foundry-rs/forge-std --no-commit
forge install openzeppelin/openzeppelin-contracts --no-commitRufe jetzt den privaten Schlüssel deines Wallet-Accounts ab. In Metamask kannst du deinen privaten Schlüssel beispielsweise anzeigen, indem du auf das Hamburger-Menü klickst und zu Account Details > Show Private Key navigierst. Du wirst aufgefordert, dein Passwort einzugeben. Klicke auf Bestätigen, um auf den privaten Schlüssel deines Accounts zuzugreifen. Gib diesen Schlüssel niemals weiter und ergreife die nötigen Maßnahmen, um ihn zu schützen.
Erstelle anschließend eine .env-Datei mit den folgenden Variablen:
RPC_URL_DEVNET=https://devnet.neonevm.org
CHAIN_ID_DEVNET=245022926
RPC_URL_MAINNET=https://neon-proxy-mainnet.solana.p2p.org
CHAIN_ID_MAINNET=245022934
PRIVATE_KEY=
VERIFIER_URL_BLOCKSCOUT=https://neon-devnet.blockscout.com/apiErsetze <YOUR_PRIVATE_KEY> durch deinen privaten Schlüssel und führe source .env aus.
Wechsle zum Kompilieren der Projekt-Contracts in das Verzeichnis src und führe forge build aus. Die Konsole sollte melden, dass der Compiler-Lauf erfolgreich war. Du kannst die Contracts außerdem mit dem Befehl forge test testen. Führe den folgenden Befehl aus, um den Contract des Projekts bereitzustellen:
forge create --rpc-url $RPC_URL_DEVNET --private-key $PRIVATE_KEY src/TestERC20/TestERC20.sol:TestERC20 --constructor-args "Test ERC20 Token" "TERC20" --legacyDie Ausgabe sollte ungefähr so aussehen:
[⠰] Compiling...
No files changed, compilation skipped
Deployer: 0x4455E84Eaa56a01676365D4f86348B311969a4f4
Deployed to: 0x5537599aa2F97Dd60a66342522a465A7f2e40Ff9
Transaction hash: 0x6de9dab8a526cbac33008056d185b93dff725605efb791bf116b6bece4f0c486Führe den folgenden Befehl aus, um deinen Contract zu verifizieren:
forge verify-contract --chain-id $CHAIN_ID_DEVNET src/TestERC20/TestERC20.sol:TestERC20 --verifier-url $VERIFIER_URL_BLOCKSCOUT --verifier blockscoutErsetze <contract_address> durch die Adresse deines Smart Contracts. Du solltest eine OK-Antwort mit einer URL erhalten, die zur Adresse des Contracts auf BlockScout, dem Devnet-Explorer von Neon, führt. Du kannst deine .env-Datei auch so konfigurieren, dass sie NeonScan statt BlockScout verwendet. NeonScan unterstützt ebenfalls das Devnet.
Vorteile und Einschränkungen
Entwickler, die eine ähnliche Erfahrung wie bei Ethereum suchen, sollten Neon EVM wählen. Die EVM-kompatible Umgebung sendet Ethereum-ähnliche Transaktionen und verwendet vertraute Tools. Features wie NeonPass, die Unterstützung der meisten EVM-Opcodes und gaslose Transaktionen erleichtern den Wechsel zu Solana erheblich. Neon EVM ist jedoch nicht perfekt. Es gibt bestimmte Einschränkungen. Dazu gehören Änderungen an der Smart-Contract-Logik zur Anpassung an die Infrastruktur von Solana, die Grenzen des Berkeley Packet Filter (BFP) und der Account-Modelle von Solana sowie Einschränkungen bei Opcodes und vorkompilierten Contracts. Du musst diese Besonderheiten verstehen und berücksichtigen, um aus einer EVM-kompatiblen Umgebung erfolgreich auf Solana bereitzustellen.
Frühere Migrationen
Damit ein großes Ethereum-Protokoll auf einer Nicht-EVM-Chain bereitgestellt werden kann, müssen mehrere komplexe Aufgaben bewältigt werden. Dazu gehören die Suche nach Entwicklern ohne Solidity-Schwerpunkt, die die Codebasis von Grund auf neu erstellen, die Auswahl vertrauenswürdiger Auditpartner, ein erneutes Audit der neuen Codebasis und die Anpassung der Governance-Verträge, um DAO-Entscheidungen durchzusetzen. Diese Aufgaben können Millionen von Dollar kosten und monatelange Arbeit erfordern. Für die meisten ist das nicht machbar. Dennoch ist es schon gelungen.
Helium ist ein LoRaWAN-Netzwerk, das eine dezentrale drahtlose Infrastruktur für Geräte im Internet der Dinge (IoT) schaffen will. Dafür nutzt es Hotspots: kleine, energieeffiziente Geräte, die Miniatur-Mobilfunkmasten ähneln und sich über große Entfernungen mit anderen Hotspots verbinden. Helium basierte ursprünglich auf einer eigenen Layer-1-Blockchain (L1). Mit HIP 70 schlug das Entwicklerteam jedoch den Wechsel zu Solana vor. Dadurch sollte Helium eine höhere Verfügbarkeit, bessere Komponierbarkeit und eine schnellere User Experience erreichen, ohne Abstriche bei Sicherheit und niedrigen Nutzungskosten zu machen. Die Community stimmte mit überwältigender Mehrheit für den Vorschlag. Im April 2023 migrierte Helium zu Solana. Heliums COO Scott Sigel beschrieb die Migration als ereignislos – weder beim Netzwerk noch bei Heliums Infrastruktur traten Probleme auf. Für Entwickler war es ein Traum. Das Team dokumentierte außerdem den gesamten Migrationsprozess in einer Reihe von Anleitungen. Heliums Migration war ein großer Erfolg und brachte der Community erhebliche Vorteile.
Diese Migration ist kein Einzelfall. The Render Network, die weltweit erste dezentrale GPU-Rendering-Plattform, verlagerte seine Kerninfrastruktur im November 2023 erfolgreich von Ethereum zu Solana. Die Community stimmte RNP-002 und damit der Migration zu Solana zu. Render-Gründer Jules Urbach bezeichnete die Migration als Wendepunkt. Er erklärte: „Solanas unglaubliche Transaktionsgeschwindigkeit, niedrige Kosten und konsequente Ausrichtung auf eine webskalierbare Architektur machen es zur perfekten Wahl für The Render Network, während wir weiter an einer skalierbaren und dezentralen Metaverse-Infrastruktur arbeiten.“
Renders Migration hatte keine nennenswerten negativen Auswirkungen auf die Nutzer. Mit Renders Upgrade Assistant können sie Guthaben von Ethereum zu Solana übertragen. Dazu verbinden sie ihre Ethereum-Wallet, geben die gewünschte Menge an RNDR ein und warten, bis ihre Token an die angegebene Solana-Wallet übertragen wurden.
Maker ist ein Ethereum-Projekt par excellence. Mit der Maker Platform will das Projekt das Potenzial dezentraler Finanzsysteme freisetzen. Die inklusive Plattform soll Menschen wirtschaftlich stärken und gleichberechtigten Zugang zum globalen Finanzmarkt schaffen. Sie besteht aus MakerDAO zur Verwaltung des Maker-Projekts und dem Maker-Protokoll für DAI, „die weltweit erste unvoreingenommene Währung und der führende dezentrale Stablecoin“. Rune Christensen, der Gründer von Maker, schrieb auf X über die Nutzung eines Forks der Solana-Codebasis zur Entwicklung einer Maker-Appchain:
Migrationen sind grundsätzlich komplex. Trotz der finanziellen, reputationsbezogenen und zeitlichen Kosten einer Migration der gesamten Projektinfrastruktur von Ethereum zu Solana entscheiden sich Projekte für Solana. Mit Tools wie Solang und Neon EVM müssen Migrationen jedoch nicht zwangsläufig kompliziert sein. Wie bei Helium kann eine Migration ereignislos verlaufen. Und wie bei The Render Network kann sie die Guthaben der Nutzer kaum oder gar nicht beeinträchtigen. Solana ist die leistungsfähigste Blockchain auf dem Markt und für Web-Skalierung konzipiert. Hier solltest du entwickeln. Immer mehr Projekte erkennen das.
Fazit
Solidity ist die Lingua franca der Smart-Contract-Entwicklung. Seit seiner Einführung dominiert die EVM als Smart-Contract-Umgebung. Sie hat jedoch Schwächen. Webskalierbare Anwendungen für Endnutzer benötigen ein Netzwerk mit hohem Durchsatz und niedriger Latenz. Nur so können sie zuverlässig arbeiten. Die Single-Thread-Umgebung von Ethereum mit ihren schwankenden Gas-Kosten kann ein Decentralized Physical Infrastructure Network (DePIN) mit hohem Durchsatz wie Helium nicht unterstützen.
Als Antwort auf diese Herausforderungen bietet Solana eine leistungsstarke Alternative. Die Vorteile von Solana nutzt du am besten, indem du tatsächlich auf Solana entwickelst. Dank neuer Entwicklungen können interessierte EVM-Entwickler mit Tools wie Solang und Neon EVM migrieren und dabei vertraute Werkzeuge und Sprachen verwenden. Dieser Artikel bietet einen umfassenden Überblick über die Architektur von Solana und den Vergleich mit Ethereum. Außerdem zeigt er, wie EVM-Entwickler mit der Entwicklung auf Solana beginnen können. Solana ist die leistungsfähigste Blockchain auf dem Markt. Das Netzwerk gewinnt an Dynamik und Aufmerksamkeit und zieht renommierte Anwendungen für Endnutzer an. Warum darauf warten, dass Ethereum skaliert, wenn du schon heute die Vorteile einer schnellen, skalierbaren Blockchain nutzen kannst?
Wenn du bis hierhin gelesen hast: Danke, Anon! Trag unten unbedingt deine E-Mail-Adresse ein, damit du keine Neuigkeiten zu Solana verpasst. Willst du tiefer einsteigen? Tritt unserem Discord bei und beginne noch heute, die Zukunft auf der leistungsfähigsten Blockchain zu entwickeln.
Weitere Ressourcen
- Solana für den Unternehmenseinsatz bewerten: Ein umfassender Leitfaden
- Neon EVM
- Solang-Dokumentation für Solana
- Das Rust-Handbuch
- Das Solana-Programmiermodell: Eine Einführung in die Entwicklung auf Solana
- Tower BFT: Solanas leistungsstarke Implementierung von PBFT
- Was ist die SVM – die Solana Virtual Machine?
Ähnliche Artikel
Helius abonnieren
Bleib bei der Solana-Entwicklung auf dem Laufenden und erhalte Updates, wenn wir neue Beiträge veröffentlichen


