
Das Solana-Programmiermodell: Eine Einführung in die Entwicklung auf Solana
Inhaltsverzeichnis
- Worum geht es in diesem Artikel?
- Was sind Solana-Cluster?
- Was sind Accounts?
- Struktur von Accounts
- Rent
- Adressen auf Solana
- Wie unterscheiden sich Accounts auf Solana von Accounts auf Ethereum?
- Was sind Solana-Programme?
- Was sind Transaktionen?
- Anweisungen
- Was sind versionierte Transaktionen?
- Struktur einer versionierten Transaktion
- Integration des Programmiermodells in Solanas Transaktionsablauf
- Fazit
- Zusätzliche Ressourcen / weiterführende Literatur
Worum geht es in diesem Artikel?
Solanas Ansatz für dezentrales Computing basiert auf einem einfachen Prinzip: Alles wird in einem eigenen Speicherbereich abgelegt, der als Account bezeichnet wird. Solana funktioniert als globaler Key-Value-Store, in dem öffentliche Schlüssel als eindeutige Kennungen für die zugehörigen Accounts dienen. Accounts bilden das Rückgrat von Solana, weil sie den Zustand speichern. Sie enthalten alles, von Programmen bis zu Token-Guthaben. Transaktionen aktualisieren Accounts und bilden Zustandsänderungen ab.
In diesem Artikel untersuchen wir die komplexe Architektur von Solana. Zunächst geben wir einen Überblick über Cluster und das Konzept des Zustands. Danach behandeln wir die Rolle von Accounts und Programmen als grundlegende Komponenten von Solana. Anschließend zeigen wir, wie Transaktionen dynamische Interaktionen zwischen Accounts und Programmen ermöglichen.
Am Ende dieses Artikels verstehst du das Programmiermodell von Solana umfassend. Du kennst die Architektur von Clustern, die zentrale Rolle von Accounts bei der Datenspeicherung und den Prozess, mit dem Transaktionen Account-Daten aktualisieren. Außerdem lernst du Solana-spezifische Funktionen wie das Rent-System und versionierte Transaktionen kennen.
Was sind Solana-Cluster?
Im Zentrum der Solana-Architektur stehen Cluster – Gruppen von Validatoren, die gemeinsam Transaktionen verarbeiten und ein einheitliches Ledger verwalten. Solana besitzt mehrere separate Cluster, die jeweils einem bestimmten Zweck dienen:
- Localhost: ein lokaler Entwicklungscluster am Standardport 8899. Das Solana Command-line Interface (CLI) enthält einen integrierten Test-Validator, den du an deine individuellen Entwicklungsanforderungen anpassen kannst, ohne Airdrops zu benötigen oder Rate-Limits ausgesetzt zu sein
- Devnet: eine Sandbox-Umgebung ohne reale Konsequenzen zum Testen und Experimentieren auf Solana
- Testnet: eine Testumgebung, in der die Core-Contributors von Solana neue Updates und Funktionen prüfen, bevor sie das Mainnet erreichen. Entwickler nutzen sie außerdem für Performance-Tests
- Mainnet Beta: der aktive, erlaubnisfreie Cluster, in dem reale Transaktionen stattfinden. Dies ist das „echte“ Solana, auf dem Nutzer, Entwickler, Token-Inhaber und Validatoren täglich interagieren
Jeder Cluster arbeitet unabhängig und weiß nichts von den anderen Clustern. Transaktionen, die an den falschen Cluster gesendet werden, lehnt das System ab. So bleibt die Integrität jeder Betriebsumgebung gewahrt.
Stell dir Cluster als einen monolithischen Heap aus Daten vor. In der Informatik bezeichnet ein Heap einen Speicherbereich, in dem Daten dynamisch gespeichert und verändert werden können. Beachte jedoch, dass Cluster nicht buchstäblich eine Heap-Datenstruktur verwenden. Diese Analogie hilft dabei, Cluster als verschiedene Speicherbereiche zu verstehen, die sich bei Bedarf zuweisen und wieder freigeben lassen. Cluster als dynamischen Heap zu verstehen, ist entscheidend dafür, wie Daten im Netzwerk verwaltet, abgerufen und geschützt werden.
Du kannst dir diesen monolithischen Daten-Heap auch als eine Art digitales Lagerhaus vorstellen. Die Daten entsprechen Kisten in Regalen. Jede Kiste hat eine eindeutige Beschriftung und bestimmte Regeln dafür, wie sie bewegt und ihr Inhalt verändert werden darf. So entsteht ein sicheres, geordnetes System, in dem nur autorisierte Bewegungen oder Änderungen erlaubt sind.
Smart Contracts, die auf Solana als Programme bezeichnet werden, erhalten einen eigenen Bereich des Lagerhauses beziehungsweise Heaps, den sie verwalten können. Ein Programm kann zwar jeden Bereich dieses Lagerhauses lesen, benötigt aber bestimmte Berechtigungen, um den Inhalt eines fremden Bereichs zu verändern. Universell erlaubt ist nur die Übertragung von Lamports, Solanas nativer Kryptowährung, an jeden beliebigen Bereich im Lagerhaus.
Der gesamte Zustand befindet sich in diesem Heap, einschließlich der Programme. Jeder Bereich gehört einem Programm, das ihn entsprechend verwaltet. Programme gehören beispielsweise dem BPFLoader, einem Programm, das Onchain-Programme lädt, bereitstellt und aktualisiert. Diese Speicherbereiche, also die Kisten unseres digitalen Lagerhauses, nennen wir Accounts.
Was sind Accounts?
Alles auf Solana ist ein Account. Stell dir Accounts als Container vor, die Daten dauerhaft speichern, ähnlich wie Dateien auf einem Computer. Sie sind die Bausteine des Solana-Programmiermodells und speichern den Zustand, etwa das Guthaben eines Accounts, Eigentumsinformationen, ob der Account ein Programm enthält, und Rent-Informationen.
Auf Solana gibt es drei Arten von Accounts:
- Accounts, die Daten speichern
- Accounts, die ausführbare Programme speichern
- Accounts, die native Programme speichern
Diese Account-Arten lassen sich anhand ihrer Fähigkeiten weiter unterteilen:
- Ausführbare Accounts – Accounts, die Code ausführen können
- Nicht ausführbare Accounts – Accounts zur Datenspeicherung, die keinen Code ausführen können, weil sie keinen Code enthalten
Die Abbildung oben zeigt einige Beispiele für ausführbare und nicht ausführbare Accounts. Bei den ausführbaren Accounts ist Bubblegum ein Beispiel für einen Programm-Account. Dieses Programm von Metaplex erstellt und verwaltet komprimierte NFTs. Das Vote Program ist ein Beispiel für einen nativen Programm-Account. Es erstellt und verwaltet Accounts, die den Abstimmungsstatus und die Rewards von Validatoren erfassen. Den Unterschied zwischen Programm-Accounts und nativen Programm-Accounts behandeln wir im Abschnitt Was sind Programme?. Für den Moment genügt es zu wissen, dass Solana verschiedene Arten ausführbarer Accounts besitzt.
Darüber hinaus lässt sich jeder nicht ausführbare Account als Daten-Account kategorisieren. Beispiele für Daten-Accounts sind:
- Ein Associated Token Account – ein Account, der Informationen über einen bestimmten Token, sein Guthaben und seinen Eigentümer enthält, zum Beispiel: Alice besitzt 10 USDC
- Ein System-Account – ein Account, der vom System Program erstellt wurde und ihm gehört
- Ein Stake-Account – ein Account, mit dem Token an Validatoren delegiert werden, um potenziell Rewards zu verdienen
Struktur von Accounts
Accounts sind gemäß dem Struct AccountInfo aufgebaut:
pub struct AccountInfo<'a> {
pub key: &'a Pubkey,
pub lamports: Rc>,
pub data: Rc>,
pub owner: &'a Pubkey,
pub rent_epoch: Epoch,
pub is_signer: bool,
pub is_writable: bool,
pub executable: bool,
}Accounts werden durch ihre Adresse (key) identifiziert. Dabei handelt es sich um einen eindeutigen öffentlichen Schlüssel mit 32 Byte.
Das Feld lamports enthält die Anzahl der Lamports, die diesem Account gehören. Ein Lamport entspricht einem Milliardstel SOL, dem nativen Token von Solana.
data bezeichnet das rohe Daten-Byte-Array, das dieser Account speichert. Es kann alles enthalten, von den Metadaten eines digitalen Assets bis zu Token-Guthaben, und lässt sich von Programmen verändern.
Das Feld owner enthält den Eigentümer dieses Accounts, dargestellt durch die Adresse eines Programm-Accounts. Für das Eigentum an Accounts gelten einige Regeln:
- Nur der Eigentümer eines Accounts kann dessen Daten verändern und Lamports abheben
- Jeder kann Lamports auf einen Account einzahlen
- Der Eigentümer eines Accounts kann das Eigentum auf einen neuen Eigentümer übertragen, sofern die Daten des Accounts auf null zurückgesetzt wurden
Das Feld is_signer ist ein boolescher Wert. Er gibt an, ob der Eigentümer des betreffenden Accounts eine Transaktion signiert hat. Anders ausgedrückt teilt er den an der Transaktion beteiligten Programmen mit, ob der Account ein Signer ist. Ein Signer besitzt den zum öffentlichen Schlüssel gehörenden privaten Schlüssel und ist berechtigt, die vorgeschlagene Transaktion zu genehmigen.
Das Feld is_writable ist ein boolescher Wert, der angibt, ob die Daten des Accounts verändert werden dürfen. Solana erlaubt Transaktionen, Accounts als schreibgeschützt anzugeben, um die parallele Verarbeitung zu ermöglichen. Die Runtime erlaubt verschiedenen Programmen, gleichzeitig auf schreibgeschützte Accounts zuzugreifen. Potenzielle Schreibkonflikte bei beschreibbaren Accounts löst sie über die Reihenfolge der Transaktionsverarbeitung. Dadurch werden nur konfliktfreie Transaktionen parallel verarbeitet.
Das Feld executable ist ein boolescher Wert, der angibt, ob ein Account Anweisungen verarbeiten kann. Ja, das bedeutet tatsächlich, dass Programme in Accounts gespeichert werden. Darauf gehen wir im nächsten Abschnitt näher ein. Zunächst müssen wir jedoch das Konzept der Rent behandeln.
Das Feld rent_epoch gibt die nächste Epoche an, in der für diesen Account Rent fällig wird. Eine Epoche ist die Anzahl der Slots, für die ein Leader-Zeitplan gilt. Anders als herkömmliche Dateien in einem Betriebssystem haben Accounts auf Solana eine Lebensdauer, die durch eine Menge an Lamports ausgedrückt wird. Die Idee, dass der Fortbestand eines Accounts von seinem Lamport-Guthaben abhängt, führt uns zum Konzept der Rent.
Rent
Rent sind Speicherkosten, die anfallen, um Accounts auf Solana aktiv und im Speicher der Validatoren zu halten. Die Rent wird anhand von Epochen berechnet. Eine Epoche ist eine durch Slots definierte Zeiteinheit, in der ein Leader-Zeitplan gilt. So funktioniert Rent:
- Einzug der Rent – Rent wird einmal pro Epoche eingezogen. Sie kann auch eingezogen werden, wenn eine Transaktion auf einen Account verweist
- Verteilung der Rent – Ein Teil der eingezogenen Rent wird verbrannt, also dauerhaft aus dem Umlauf entfernt. Der Rest wird nach jedem Slot an Vote-Accounts verteilt
- Zahlung der Rent – Besitzt ein Account nicht genügend Lamports, um die Rent zu bezahlen, werden seine Daten entfernt und der Account wird in einem als Garbage Collection bezeichneten Prozess freigegeben
- Rent-Befreiung – Accounts können von der Rent befreit werden, wenn sie ein Mindestguthaben halten, das den Rent-Zahlungen für zwei Jahre entspricht. Alle neuen Accounts müssen diesen von ihrer Größe abhängigen Schwellenwert erfüllen
- Rückgewinnung der Rent – Nutzer können einen Account schließen, um seine verbleibenden Lamports zurückzuerhalten. So können sie die in einem Account gespeicherte Rent zurückholen
Die Rent für eine bestimmte Account-Größe lässt sich über den RPC-Endpunkt getMinimumBalanceForRentExemption schätzen. Der Helius API Playground vereinfacht dies, indem er die Datenlänge eines Accounts als usize akzeptiert. Auch der Solana-rent-CLI-Unterbefehl kann die Mindestmenge an SOL schätzen, die ein Account für die Rent-Befreiung benötigt. Zum Zeitpunkt der Erstellung dieses Artikels gibt der Befehl solana rent 20000 beispielsweise Rent-exempt minimum: 0.14009088 SOL zurück.
Adressen auf Solana
Auf Solana gibt es tatsächlich zwei „Arten“ von Adressen. Solana verwendet zur Adresserstellung ed25519, ein EdDSA-Signaturschema mit SHA-512 (SHA-2) und der elliptischen Kurve Curve22519. Daraus entstehen öffentliche Schlüssel mit 32 Byte, die als primäres Adressformat dienen. Sie können direkt verwendet werden, da sie nicht gehasht werden.
Damit eine Adresse gültig ist, muss sie ein Punkt auf der ed25519-Kurve sein. Allerdings müssen nicht alle Adressen von dieser Kurve abgeleitet werden. Program Derived Addresses (PDAs) werden außerhalb der Kurve erzeugt. Daher besitzen sie keinen zugehörigen privaten Schlüssel und können nicht zum Signieren verwendet werden. PDAs werden über das System Program erstellt und kommen zum Einsatz, wenn Programme Accounts verwalten müssen. Dieser kurze Exkurs soll dich als Leser lediglich auf die verschiedenen Adresstypen auf Solana aufmerksam machen. PDAs behandeln wir in einem zukünftigen Artikel.
Wie unterscheiden sich Accounts auf Solana von Accounts auf Ethereum?
Ethereum besitzt zwei primäre Account-Typen: Externally Owned Accounts (EOAs) und Contract-Accounts. Private Schlüssel kontrollieren EOAs, während der Contract-Code Contract-Accounts steuert. Contract-Accounts können nicht selbstständig Transaktionen initiieren.
Sowohl EOAs als auch Contract-Accounts folgen derselben Account-Struktur:
- Guthaben – Jeder Account besitzt ein in Ether gemessenes Guthaben
- Nonce – Bei EOAs entspricht sie der Anzahl der vom Account gesendeten Transaktionen. Bei Contracts entspricht sie der Anzahl der vom Account erstellten Contracts
- Storage Root – ein 256-Bit-Hash des Wurzelknotens eines Merkle Patricia Trie, der den Speicherinhalt des Accounts codiert
- CodeHash – der Hash des Codes der Ethereum Virtual Machine (EVM) für den Contract. Er ist unveränderlich. Der Code ändert sich nach der Erstellung also nicht mehr, der Zustand dagegen schon. Beachte, dass es Ausnahmen für Upgrades von Contracts auf Ethereum gibt, etwa durch Proxy-Patterns. Diese liegen jedoch außerhalb des Rahmens dieses Artikels. Bei EOAs ist dies der Hash eines leeren Strings, weil EOAs keinen Code enthalten
Solana verwendet ein einheitlicheres Account-Modell, in dem jeder Account potenziell ein Programm sein kann. Die Trennung von Code und Daten schafft eine effizientere und flexiblere Umgebung. Solana-Programme sind zustandslos und interagieren ohne redundante Deployments mit verschiedenen Daten-Accounts. Das ist besonders vorteilhaft für Anwendungen im Bereich der dezentralen Finanzen (DeFi), bei denen Nutzer mit mehreren Protokollen interagieren möchten, ohne Assets zwischen verschiedenen Programmen zu verschieben. Im Gegensatz dazu kombiniert das Programmiermodell von Ethereum Code und Zustand in einer einzigen Entität. Dadurch werden Interaktionen komplexer und aufgrund der Gas-Anforderungen für Zustandsänderungen potenziell teurer.
Früher mussten Solana-Accounts Rent bezahlen und dafür ein Mindestguthaben halten, um aktiv zu bleiben. So konnte das Netzwerk ungenutzte oder unzureichend finanzierte Accounts schließlich zurückgewinnen und State Bloat reduzieren. Nach neueren Updates gibt es im Mainnet keine Rent zahlenden Accounts mehr. Accounts müssen von der Rent befreit sein. Ethereum verwendet dagegen Gas, um die Ressourcenzuweisung zu verwalten. In diesem Modell bleibt Contract-Speicher unbegrenzt bestehen, sofern er nicht ausdrücklich gelöscht wird. Solanas Ansatz bietet eine besser vorhersehbare Kostenstruktur für die Zustandsspeicherung. Die Kosten auf Ethereum können dagegen schwanken und bei hoher Netzwerkauslastung unerschwinglich werden.
Im folgenden Abschnitt untersuchen wir, wie Solana seine Programmlogik vom Zustand trennt. Im Vergleich zum Programmiermodell von Ethereum siehst du, wie dieser modulare Ansatz effizientere Onchain-Abläufe ermöglicht und Entwicklern zugleich eine transparente, vorhersehbare Kostenstruktur bietet.
Was sind Solana-Programme?
Programme sind ausführbare Accounts, die dem BPF Loader gehören. Die Solana Runtime, die für die Verarbeitung von Transaktionen und Programmlogik ausgelegt ist, führt sie aus.
Ein charakteristisches Merkmal des Solana-Programmiermodells ist die Trennung von Code und Daten. Programme sind zustandslos und speichern intern keinen Zustand. Stattdessen befinden sich alle Daten, die sie verarbeiten, in separaten Accounts. Transaktionen übergeben diese Accounts als Referenzen an die Programme. Durch dieses Design kann ein einziges generisches Deployment eines Programms mit verschiedenen Accounts interagieren.
Programme auf Solana können:
- Weitere Accounts besitzen
- Andere Accounts lesen oder ihnen Guthaben gutschreiben
- Daten verändern oder die ihnen gehörenden Accounts belasten
Es gibt zwei Arten von Programmen:
- Onchain-Programme – von Nutzern geschriebene Programme, die auf Solana bereitgestellt werden. Ihre Upgrade Authority, normalerweise der Account, der das Programm bereitgestellt hat, kann sie aktualisieren
- Native Programme – Programme, die in den Kern von Solana integriert sind. Sie stellen die grundlegenden Funktionen bereit, die Validatoren für ihren Betrieb benötigen. Native Programme können nur über netzwerkweite Softwareupdates aktualisiert werden. Gängige Beispiele sind das System Program, das BPF Loader Program und das Vote Program.
Nutzer und andere Programme können sowohl Onchain- als auch native Programme aufrufen. Der wichtigste Unterschied liegt in ihren Upgrade-Mechanismen: Onchain-Programme können von ihrer Upgrade Authority aktualisiert werden, native Programme dagegen nur im Rahmen von Cluster-Updates.
Solana Labs kuratiert eine ausgewählte Gruppe von Onchain-Programmen, die als Solana Program Library bekannt ist. Diese Bibliothek ermöglicht verschiedene Onchain-Aktionen, darunter die Vergabe von Token-Krediten und die Erstellung von Stake-Pools. Das Associated Token Account Program definiert beispielsweise einen Standard und einen Mechanismus, um das Wallet eines Nutzers mit dessen jeweiligen Token-Accounts zu verknüpfen. Außerdem ist die SPL dynamisch. Programme wie Token-2022 bauen auf den Funktionen des Token Program auf und erweitern sie.
Programme auf Solana werden in der Regel mit Rust und Anchor entwickelt. Dieses opinionated Framework vereinfacht die Erstellung von Programmen, indem es Boilerplate reduziert sowie Serialisierung und Deserialisierung optimiert. Rust wird zwar bevorzugt, ist aber nicht zwingend erforderlich. Auch C, C++ und jede Sprache, die das BPF-Backend von LLVM als Ziel unterstützt, können verwendet werden. Dabei handelt es sich um eine Komponente von LLVM, mit der Programme in BPF-Bytecode kompiliert werden können. Aktuelle Entwicklungen von Solang und Neon Labs ermöglichen Entwicklern außerdem, Solidity für die Programmentwicklung einzusetzen.
Programme werden normalerweise auf Localhost und Devnet entwickelt und getestet, bevor sie auf Testnet oder Mainnet Beta bereitgestellt werden. Entwickler können ihr Programm mit dem Befehl solana program deploy <path to program> über die Solana CLI bereitstellen. Nachdem das Programm in ein ELF Shared Object mit dem BPF-Bytecode kompiliert wurde, wird es in den vorgesehenen Solana-Cluster hochgeladen. Bereitgestellte Programme befinden sich in Accounts, die als executable markiert sind. Die Adresse des Accounts dient dabei als program_id.
Ursprünglich wurden Programme auf Solana mit Accounts bereitgestellt, die doppelt so groß wie das Programm waren. Solanas Update 1.16 führt Unterstützung für größenveränderliche Accounts ein, um Entwicklern mehr Flexibilität bei der Ressourcenzuweisung zu bieten. Entwickler können ihr Programm nun mit einem kleineren Account bereitstellen und dessen Größe später erweitern.
Wie oben erwähnt, gelten Programme als zustandslos, weil alle Daten, mit denen sie interagieren, in separaten Accounts gespeichert und als Referenzen übergeben werden. Jedes Programm besitzt einen einzigen Entry Point, an dem die Verarbeitung von Anweisungen stattfindet. Er nimmt eine program_id, ein Array von Accounts und die Anweisungsdaten als Byte-Array entgegen. Die Solana Runtime führt Programme aus, sobald eine Transaktion sie aufruft.
Was sind Transaktionen?
Transaktionen bilden das Rückgrat der Onchain-Aktivität. Über sie werden Programme aufgerufen und Zustandsänderungen ausgeführt. Eine Transaktion auf Solana ist ein Bündel von Anweisungen. Diese teilen Validatoren mit, welche Aktionen sie auf welchen Accounts ausführen sollen und ob sie dafür die erforderlichen Berechtigungen besitzen.
Eine Transaktion besteht aus drei Hauptteilen:
- Ein Array von Accounts, aus denen gelesen oder in die geschrieben wird
- Eine oder mehrere Anweisungen
- Eine oder mehrere Signaturen
Transaktionen auf Solana folgen dem Transaction-Struct. Dieses stellt die Informationen bereit, die das Netzwerk zum Verarbeiten und Validieren von Aktionen benötigt. Es ist wie folgt definiert:
pub struct Transaction {
pub signatures: Vec,
pub message: Message,
}Das Feld signatures enthält eine Gruppe von Signaturen, die der serialisierten Message entsprechen. Jede Signatur ist einem Account-Schlüssel aus der Liste account_keys der Message zugeordnet, beginnend mit dem Gebührenzahler. Der Gebührenzahler ist der Account, der die bei der Verarbeitung einer Transaktion anfallenden Transaktionsgebühren übernimmt. Normalerweise ist dies der Account, der die Transaktion initiiert. Die Anzahl der erforderlichen Signaturen entspricht num_required_signatures, das im Feld MessageHeader der Nachricht definiert ist.
Die message selbst ist ein Struct vom Typ Message. Es ist wie folgt definiert:
pub struct Message {
pub header: MessageHeader,
pub account_keys: Vec,
pub recent_blockhash: Hash,
pub instructions: Vec,
}Die header der Nachricht enthält drei vorzeichenlose 8-Bit-Ganzzahlen: die Anzahl der erforderlichen Signaturen, also num_required_signatures, die Anzahl der schreibgeschützten Signer und die Anzahl der schreibgeschützten Nicht-Signer.
Das Feld account_keys führt alle an der Transaktion beteiligten Account-Adressen auf. Accounts mit angefordertem Lese- und Schreibzugriff stehen zuerst, gefolgt von schreibgeschützten Accounts.
recent_blockhash ist ein aktueller Blockhash mit einem 32 Byte großen SHA-256-Hash. Er gibt an, wann ein Client das Ledger zuletzt beobachtet hat, und legt die Lebensdauer aktueller Transaktionen fest. Validatoren lehnen Transaktionen mit einem alten Blockhash ab. Ein aktueller Blockhash verhindert außerdem doppelte Transaktionen, da jede Transaktion abgelehnt wird, die vollständig mit einer vorherigen übereinstimmt. Muss eine Transaktion aus irgendeinem Grund lange vor ihrer Übermittlung an das Netzwerk signiert werden, kann statt eines aktuellen Blockhashs eine dauerhafte Transaktions-Nonce verwendet werden. So bleibt die Transaktion eindeutig.
Das Feld instructions enthält einen oder mehrere CompiledInstruction-Structs. Jeder davon gibt eine bestimmte Aktion vor, die die Validatoren des Netzwerks ausführen sollen.
Anweisungen
Eine Anweisung ist eine Direktive für einen einzelnen Aufruf eines Solana-Programms. Sie ist die kleinste Einheit der Ausführungslogik eines Programms und die grundlegendste operative Einheit auf Solana. Programme interpretieren die von einer Anweisung übergebenen Daten und verarbeiten die angegebenen Accounts. Der Struct Instruction ist wie folgt definiert:
pub struct Instruction {
pub program_id: Pubkey,
pub accounts: Vec,
pub data: Vec,
}Das Feld program_id gibt den öffentlichen Schlüssel des auszuführenden Programms an. Dies ist die Adresse des Programms, das die Anweisung verarbeitet. Der durch diesen öffentlichen Schlüssel angegebene Eigentümer des Programm-Accounts legt fest, welcher Loader das Programm initialisiert und ausführt. Nach dem Deployment markiert der Loader Onchain-Programme im Solana Bytecode Format (SBF) als ausführbar. Die Solana Runtime lehnt alle Transaktionen ab, die versuchen, nicht als ausführbar markierte Accounts aufzurufen.
Das Feld accounts führt die Accounts auf, aus denen die Anweisung lesen oder in die sie schreiben kann. Diese Accounts müssen als AccountMeta-Werte bereitgestellt werden. Jeder Account, dessen Daten die Anweisung verändern kann, muss als beschreibbar angegeben werden. Andernfalls schlägt die Transaktion fehl. Programme können nämlich nicht in Accounts schreiben, die ihnen nicht gehören oder für die sie nicht die erforderlichen Berechtigungen besitzen. Das gilt auch für Änderungen an den Lamports eines Accounts: Werden Lamports von einem Account abgezogen, der dem Programm nicht gehört, schlägt die Transaktion fehl. Lamports zu einem beliebigen Account hinzuzufügen, ist dagegen erlaubt. Das Feld accounts kann auch Accounts angeben, die das Programm weder liest noch beschreibt. Dies beeinflusst die Planung der Programmausführung durch die Runtime. Ansonsten werden diese Accounts ignoriert.
data ist ein universell einsetzbarer Vektor vorzeichenloser 8-Bit-Ganzzahlen, der als Eingabe an das Programm übergeben wird. Dieses Feld ist entscheidend, weil es die codierten Anweisungen enthält, die das Programm ausführt.
Solana macht keine Vorgaben für das Format der Anweisungsdaten. Es bietet jedoch integrierte Unterstützung für die Serialisierung über bincode und borsh (Binary Object Representation Serializer for Hashing). Bei der Serialisierung werden komplexe Datenstrukturen in eine flache Bytefolge umgewandelt, die übertragen oder gespeichert werden kann. Bei der Wahl der Datencodierung sollte der Aufwand für die Decodierung berücksichtigt werden, da sie vollständig Onchain erfolgt. Die Borsh-Serialisierung wird oft gegenüber bincode bevorzugt, weil sie eine stabile Spezifikation und eine JavaScript-Implementierung besitzt und allgemein effizienter ist.
Programme verwenden Hilfsfunktionen, um die Erstellung unterstützter Anweisungen zu vereinfachen. Das System Program stellt beispielsweise eine Hilfsfunktion zum Erstellen der Anweisung SystemInstruction::Assign bereit:
pub fn assign(pubkey: &Pubkey, owner: &Pubkey) -> Instruction {
let account_metas = vec![AccountMeta::new(*pubkey, true)];
Instruction::new(
system_program::id(),
&SystemInstruction::Assign { owner: *owner },
account_metas,
)
}Diese Funktion erstellt eine Anweisung, die bei ihrer Verarbeitung den Eigentümer des angegebenen Accounts auf den bereitgestellten neuen Eigentümer ändert.
Eine einzelne Transaktion kann mehrere Anweisungen enthalten. Sie werden in der aufgeführten Reihenfolge nacheinander und atomar ausgeführt. Das bedeutet, dass entweder alle Anweisungen erfolgreich sind oder keine. Deshalb kann die Reihenfolge der Anweisungen entscheidend sein. Programme müssen so abgesichert werden, dass sie jede mögliche Abfolge von Anweisungen sicher verarbeiten und potenzielle Exploits verhindern.
Bei der Deinitialisierung kann ein Programm beispielsweise versuchen, einen Account zu deinitialisieren, indem es dessen Lamport-Guthaben auf null setzt. Dabei geht es davon aus, dass die Solana Runtime den Account löscht. Diese Annahme gilt zwischen Transaktionen, jedoch nicht zwischen Anweisungen oder Cross-Program Invocations. Cross-Program Invocations behandeln wir in einem zukünftigen Artikel. Das Programm sollte die Daten des Accounts ausdrücklich auf null setzen, um sich gegen diese potenzielle Schwachstelle im Deinitialisierungsprozess abzusichern. Andernfalls könnte ein Angreifer die vermeintliche Löschung mit einer nachfolgenden Anweisung ausnutzen, indem er den Account beispielsweise wiederverwendet, bevor die Transaktion abgeschlossen ist.
Was sind versionierte Transaktionen?
Transaktionen auf Solana verwenden die Standards von IPv6 für die Maximum Transmission Unit (MTU), um eine schnelle und zuverlässige Datenübertragung innerhalb eines Clusters zu gewährleisten. Der Netzwerk-Stack von Solana verwendet eine konservative MTU-Größe von 1280 Byte. Nach Abzug des Platzes für Header bleiben 1232 Byte für Paketdaten. Deshalb sind Solana-Transaktionen auf diese Größe begrenzt.
Diese Größenbeschränkung ermöglicht verschiedene Netzwerkoptimierungen, begrenzt aber auch die Komplexität der Aktionen, die eine einzelne Transaktion ausführen kann. Da jede Account-Adresse 32 Byte Speicher belegt, kann eine Transaktion ohne Anweisungen bis zu 35 Accounts enthalten. Diese Einschränkung erschwert Anwendungsfälle, die mehr als 35 signaturfreie Accounts in einer einzigen Transaktion erfordern.
Um dieses Problem zu lösen, wurde ein neues Transaktionsformat eingeführt, das mehrere Versionen von Transaktionsformaten unterstützt. Die Solana Runtime unterstützt derzeit zwei Transaktionsversionen:
legacy– das ursprüngliche Transaktionsformat0(Version 0) – das neueste Transaktionsformat mit Unterstützung für Address Lookup Tables
Version 0 wurde zur Unterstützung von Address Lookup Tables (ALTs) veröffentlicht. Im Wesentlichen speichern sie Account-Adressen Onchain in einer tabellenähnlichen Datenstruktur. Diese Tabellen sind separate Accounts, die Account-Adressen speichern. Transaktionen können über einen 1 Byte großen u8-Index auf sie verweisen. Dadurch sinkt die Größe einer Transaktion erheblich, weil jeder enthaltene Account nur 1 Byte statt 32 Byte benötigt. ALTs sind besonders nützlich für komplexe Aktionen mit vielen Accounts, wie sie bei DeFi-Anwendungen üblich sind.
Dieses Diagramm wurde aus dem Abschnitt zu versionierten Transaktionen im Solana Cookbook übernommen
Der Begriff „versionierte Transaktionen“ bezeichnet die Art und Weise, wie Solana sowohl das Legacy- als auch das Version-0-Transaktionsformat unterstützt. Dieser Ansatz gewährleistet Komponierbarkeit und ermöglicht zugleich Verbesserungen der Runtime.
Struktur einer versionierten Transaktion
Eine VersionedTransaction ist wie folgt definiert:
pub struct VersionedTransaction {
pub signatures: Vec,
pub message: VersionedMessage,
}Das Feld signatures ist eine Liste mit Signaturen der Signer einer Transaktion. Sie authentifizieren die Transaktion und schützen ihre Integrität. Die message enthält den eigentlichen Inhalt der Transaktion. Dieser wird vom Typ VersionedMessage gekapselt, einem schlanken Enum-Wrapper, der sowohl Legacy- als auch Version-0-Nachrichten verarbeitet:
pub enum VersionedMessage {
Legacy(Message),
V0(Message),
}Die Nachrichtenversion wird beim Serialisieren durch das erste Bit bestimmt. Ist das erste Bit gesetzt, bestimmen die verbleibenden 7 Bits, welche Version der Message serialisiert wird, beginnend mit Version 0. Ist das erste Bit nicht gesetzt, werden alle Bytes zum Codieren des Legacy-Formats Message verwendet. Der Grund dafür ist, dass zwei identisch benannte Message-Structs existieren, die jedoch in unterschiedliche Module aufgeteilt sind: legacy und v0.
Eine Message stellt das komprimierte interne Format einer Transaktion dar. Es wird für die Netzwerkübertragung und die Verarbeitung durch die Runtime verwendet. Es umfasst eine lineare Liste aller Accounts, die von den Anweisungen der Transaktion verwendet werden, eine MessageHeader mit Details zur Struktur des Account-Arrays, einen aktuellen Blockhash und eine kompakte Codierung der Anweisungen der Nachricht. So ist der v0-Struct Message aufgebaut:
pub struct Message {
pub header: MessageHeader,
pub account_keys: Vec,
pub recent_blockhash: Hash,
pub instructions: Vec,
pub address_table_lookups: Vec,
}Der Unterschied zwischen einer Legacy-Nachricht und einer v0-Nachricht besteht im Feld address_table_lookups.
Integration des Programmiermodells in Solanas Transaktionsablauf
Das Programmiermodell von Solana ist eng mit seinen Account- und Transaktionssystemen verknüpft. So greifen die Konzepte ineinander:
- Accounts als Zustand – Accounts auf Solana dienen Programmen als Zustandscontainer. Im Programmiermodell geht es darum, die in diesen Containern gespeicherten Daten als Reaktion auf Anweisungen zu verändern
- Anweisungen – Programme definieren die Logik zur Verarbeitung der Anweisungen innerhalb einer Transaktion. Diese Anweisungen sind die ausführbaren Komponenten, die mit Account-Daten interagieren
- Serialisierung und Verarbeitung – Beim Serialisieren einer Transaktion bestimmen die Anweisungen des Programms die Änderungen an den Account-Zuständen. Der Serialisierungsprozess folgt dem Design des Programms, unabhängig davon, ob es das Legacy- oder das Version-0-Transaktionsformat verwendet
- Atomarität – Das Programmiermodell von Solana gewährleistet die atomare Verarbeitung von Anweisungen. Programme müssen so entwickelt werden, dass sie gleichzeitige Transaktionen sicher und effizient verarbeiten
- Skalierbarkeit – Das Programmiermodell von Solana unterstützt Skalierbarkeit durch Funktionen wie Address Lookup Tables (ALTs). Diese Tabellen reduzieren die Größe einer Transaktion und erhöhen die Anzahl der Accounts, auf die eine Transaktion verweisen kann
Beim Programmiermodell von Solana geht es nicht nur darum, Code zu schreiben. Du musst auch verstehen, wie dieser Code im größeren Ökosystem interagiert. Accounts sind für dieses Modell unverzichtbar, weil Daten über sie im Netzwerk gespeichert und verändert werden. Transaktionen ermöglichen Onchain-Aktivität, indem sie Validatoren mitteilen, welche Daten erstellt, aktualisiert oder gelöscht werden müssen. Entwickler müssen diese Aspekte umfassend verstehen, um Anwendungen zu entwickeln, die für Performance und das Zusammenspiel innerhalb des Solana-Ökosystems optimiert sind.
Fazit
Glückwunsch! In diesem Artikel haben wir uns durch die komplexe Systemarchitektur von Solana gearbeitet und Cluster als monolithische Daten-Heaps betrachtet. Wir haben gesehen, wie dieser Heap in separate Speicherbereiche unterteilt ist, die als Accounts bezeichnet werden und das Rückgrat des Solana-Programmiermodells bilden. Accounts speichern alles, von den Token der Nutzer bis zu den Programmen, die das Verhalten des Netzwerks definieren. Transaktionen verändern all diese Daten.
Für Entwickler ist es entscheidend, Solanas Ansatz für dezentrales Computing zu verstehen. Du musst die Feinheiten von Accounts, Programmen und Transaktionen kennen, um Anwendungen zu entwickeln, die Solanas Möglichkeiten vollständig ausschöpfen. Dabei geht es um ein System, in dem der Code vom Zustand entkoppelt ist. Das Ergebnis sind zustandslose Programme, die über Accounts mit Daten interagieren und ein beispielloses Maß an Komponierbarkeit und Aktualisierbarkeit bieten.
Auch für Investoren und gelegentliche Nutzer ist es wichtig zu verstehen, wie das Design von Solana ein robustes, flexibles und effizientes Ökosystem schafft. So lässt sich die Zukunftsfähigkeit der Plattform und ihre Fähigkeit beurteilen, innovative Anwendungen zu ermöglichen, die nur auf Solana realisierbar sind.
Wenn du bis hierher gelesen hast, anon: Danke! Bereit, tiefer einzusteigen? Tritt noch heute unserem Discord bei und beginne mit der Programmierung auf Solana.
Zusätzliche Ressourcen / weiterführende Literatur
Ähnliche Artikel
Helius abonnieren
Bleib bei der Solana-Entwicklung auf dem Laufenden und erhalte Updates, wenn wir neue Beiträge veröffentlichen


