Poseidon: Solana-Programme mit TypeScript entwickeln

Hintergrund

Gegen Ende 2023 trat die Solana Foundation mit einer ambitionierten Herausforderung an das Team von Turbin3 heran: „Könnt ihr ein Framework entwickeln, mit dem Entwickler Solana-Programme in TypeScript erstellen können?“ Die erste Reaktion war natürlich die Frage: „Warum?“

TypeScript ist eine statisch typisierte Obermenge von JavaScript. Sie hilft Entwicklern, Fehler früher zu erkennen und besser wartbaren Code zu schreiben. Als De-facto-Standard der modernen Webentwicklung haben TypeScript und JavaScript eine der weltweit größten Entwickler-Communitys hervorgebracht. Die Programmentwicklung mit TypeScript bietet eine große Chance, mehr neue Solana-Entwickler zu gewinnen und die Einstiegshürden für die Entwicklung auf der Blockchain zu senken.

Die Entwicklung von Solana-Programmen zu meistern ist im Vergleich zu vielen anderen Blockchains anspruchsvoll. Neue Entwickler müssen gleichzeitig zwei Hürden bewältigen: das Account-Modell von Solana verstehen und Rust lernen. Das kann eine steile Lernkurve bedeuten. Wir bei Turbin3 wissen das besser als jeder andere: 15 % aller neuen Solana-Entwickler durchlaufen unsere Programme.

Mit einem TypeScript-Framework können Entwickler diese Herausforderungen voneinander trennen. Sie nutzen eine bereits vertraute Sprache und stellen ihre ersten Programme schneller im Testnet bereit. Ein TypeScript-basiertes Framework für die Entwicklung von On-Chain-Programmen ermöglicht es erstmals, vollständige Solana-Full-Stack-Anwendungen nahtlos in einer einzigen Sprache zu entwickeln.

Die Lösung: Poseidon

Das Projekt begann als grundlegende Typbibliothek und Transpiler-Konzept. Nach ersten Prototypen und ausführlichem Feedback von Solana- und TypeScript-Experten entwickelte es sich jedoch schnell zu etwas weitaus Robusterem. Nach Monaten des Entwickelns, Testens und Troubleshootings sowie wertvollen Beiträgen von Branchenexperten erreichte Poseidon Anfang dieses Jahres auf der Breakpoint 2024 einen entscheidenden Meilenstein. Dort präsentierten wir unsere Arbeit einem interessierten Entwicklerpublikum.

In einer Live-Präsentation demonstrierte Shrinath, unser leitender Poseidon-Entwickler, wie man ein Solana-Programm in TypeScript schreibt. Mit einem einzigen Build-Befehl transpiliert Poseidon den TypeScript-Code in vollständige Anchor-Syntax – direkt vor den Augen des Publikums. Im Raum war die Begeisterung spürbar, und überall wurde geflüstert: „Kann das wirklich funktionieren?“

Seitdem ist das Open-Source-Repository von Poseidon schnell gewachsen. Angetrieben wird es durch Beiträge unserer wachsenden Poseidon Army auf X und Discord. Community-Mitglieder haben Issues bearbeitet, Pull Requests eingereicht und gemeinsam neue Packages entwickelt. So wird Poseidon täglich ausgereifter. Zu den Verbesserungen gehören eine erweiterte CLI, Unterstützung für Funktionen des Token-Programms und bessere Fehlermeldungen. Poseidon steht zwar noch am Anfang, doch sein Potenzial ist unbestreitbar.

Aus technischer Sicht betrachten wir die Entwicklung von Poseidon in vier Phasen. Nach unseren ersten Gesprächen, Brainstormings und Architekturentwürfen mussten wir einige wichtige Entscheidungen treffen. Besonders relevant waren:

• Annahmen zu den benötigten Bibliotheken treffen
• Accounts im Instruction-Body durch verkettete Methoden ableiten
• Prozedurale Makros verwenden (für viele Entwickler ein neues Konzept)

Anschließend arbeiteten wir konzentriert an der Entwicklungs- und Iterationsphase bis zur Präsentation auf der Breakpoint. Dieser eindrucksvolle Moment öffnete die Schleusen für die aktuelle Phase: Wir haben das Framework frühen Anwendern übergeben, damit sie damit experimentieren, Neues entdecken und es verbessern können.

Zum Ende des Jahres 2024 fördern wir das Wachstum des Frameworks weiter. Wir konzentrieren uns auf Verbesserungen der Kernfunktionen, binden die Community ein, um die Unterstützung auszubauen, und ermitteln, welche SPL-Funktionen und welche Unterstützung für Anchor-Bibliotheken benötigt werden. So können sich die führenden Entwickler auf zentrale Verbesserungen konzentrieren.

Mit Blick auf 2025 beschleunigen wir die Entwicklung. Dafür starten wir gegen Ende des ersten Quartals unsere erste Turbin3 Poseidon Cohort (Ankündigung folgt). Diese Initiative wird das Framework voranbringen und sich auf die Erstellung öffentlicher Packages, Tutorials und weiterer Lernressourcen konzentrieren. Das Ziel ist klar: Poseidon soll zum maßgeblichen Tool werden, um die Entwicklung von Solana-Programmen mit TypeScript zu beschleunigen.

Wichtigste Funktionen

Poseidon bietet mehrere herausragende Funktionen:

• Einfachere Entwicklung: Eine TypeScript-basierte Schnittstelle verkürzt die Lernkurve für Webentwickler. So können sie sich auf die Anwendungslogik konzentrieren, statt mit Rust zu kämpfen
• Höhere Produktivität: Mit vertrauten Tools und Workflows können Entwickler effizienter arbeiten und den Entwicklungsprozess beschleunigen
• Mehr Sicherheit und Leistung: Das Framework stellt sicher, dass der transpilierte Rust-Code die strengen Sicherheits- und Leistungsstandards von Solana erfüllt und die Integrität von On-Chain-Programmen wahrt
• Nahtlose Integration: Poseidon integriert sich nahtlos in das Solana-Ökosystem, sodass Entwickler vorhandene Tools und Bibliotheken nutzen können

Systemarchitektur

Die Architektur von Poseidon besteht aus mehreren zentralen Komponenten:

• TypeScript-basierte Programmierschnittstelle: Diese Ebene bietet Entwicklern eine vertraute Syntax und vertraute Tools zum Schreiben von Solana-Programmen
• Transpilierungs-Engine: Diese Engine wandelt TypeScript-Code in entsprechenden Rust-Code um und nutzt dabei das Typsystem und die Sprachfunktionen von TypeScript
• Anchor-Codegenerierung: Der transpilierte Rust-Code wird weiterverarbeitet, um gültige Anchor-Programme zu erzeugen, die kompiliert und im Solana-Netzwerk bereitgestellt werden können
• Account-Verwaltung: Poseidon vereinfacht die Verwaltung von Accounts und ihren zugehörigen Daten. Dadurch wird die Interaktion mit der Solana-Blockchain leichter

Anwendungsfälle

Poseidon wurde entwickelt, damit Entwickler das Account-Modell von Solana schneller verstehen. Es verkürzt die Zeit erheblich, die neue Entwickler benötigen, um ihre ersten Programme im Testnet bereitzustellen. Aufgrund der strengen Sicherheitsanforderungen von Blockchain-Anwendungen eignet sich Poseidon derzeit nicht für die Entwicklung produktionsreifer Mainnet-Anwendungen. Angehende Solana-Protokollentwickler müssen letztlich Anchor und Rust lernen, um die zugrunde liegende Architektur von Solana besser zu verstehen.

Mit dem Framework lassen sich zahlreiche dezentrale Anwendungen erkunden und experimentell entwickeln, darunter:

• Dezentrale Finanzen (DeFi): Entwickle innovative Finanzanwendungen wie Kreditprotokolle, dezentrale Börsen und Yield-Farming-Plattformen
• Nicht fungible Token (NFTs): Erstelle und verwalte digitale Assets auf der Solana-Blockchain
• Gaming: Entwickle Blockchain-basierte Spiele und virtuelle Welten
• Lieferkettenmanagement: Verfolge und verifiziere die Herkunft von Produkten und Materialien

Wir konzentrierten uns zunächst auf grundlegende Programme, die fast jeder Blockchain-Anwendung zugrunde liegen: Counter, Vault und Escrow. Diese zentralen Bausteine bilden die Grundlage unzähliger Protokolle und sind daher der perfekte Ausgangspunkt.

Poseidon-Beispielprogramm

Sehen wir uns den Code genauer an. Dazu zerlegen wir ein mit Poseidon in TypeScript entwickeltes Vault-Beispielprogramm in seine einzelnen Bestandteile. Den vollständigen Code für dieses und weitere Programme findest du im Poseidon-GitHub-Repository.

Importe und Programmdeklaration

Das Programm wird als TypeScript-Klasse mit einem statischen PROGRAM_ID definiert, das die Programm-ID angibt. Das Package @solanaturbine/poseidon stellt die erforderlichen Typen zum Definieren von Instructions bereit, darunter Rust-Typen (u8, u64, i8, i128, boolean, string), SPL-Typen (Pubkey, AssociatedTokenAccount, Mint, TokenAccount, TokenProgram) und Anchor-Account-Typen (Signer, UncheckedAccount, SystemAccount).

import { Account, Pubkey, Result, Signer, SystemAccount, SystemProgram, UncheckedAccount, u64, u8 } from "@solanaturbine/poseidon";

export default class VaultProgram {
    static PROGRAM_ID = new Pubkey("11111111111111111111111111111111");

Instructions

Normalerweise definieren wir Methoden innerhalb der Programmklasse, um Instructions mit Poseidon festzulegen. Der Kontext jeder Instruction ergibt sich implizit aus den Methodenparametern. Um einen Account mit @solanaturbine/poseidon als Program Derived Address (PDA) zu definieren, geben wir mit der Methode derive den Seed als ersten Parameter innerhalb eines Arrays an.

    initialize(
        owner: Signer,
        state: Vault,
        auth: UncheckedAccount,
        vault: SystemAccount
    ): Result {

        auth.derive(['auth', state.key])
        state.derive(['state', owner.key]).init(owner)
        vault.derive(['vault', auth.key])

        // assign an argument of type Pubkey by calling the key property
        state.owner = owner.key;

        // to store bumps in the custom_Acc(state), we can simply call getBump
        state.stateBump = state.getBump()
        state.authBump = auth.getBump()
        state.vaultBump = vault.getBump()
    }

    deposit(
        owner: Signer,
        state: Vault,
        auth: UncheckedAccount,
        vault: SystemAccount,
        amount: u64
    ) {
        state.deriveWithBump(['state', owner.key], state.stateBump)
        auth.deriveWithBump(['auth', state.key], state.authBump)
        vault.deriveWithBump(['vault', auth.key], state.vaultBump)

        SystemProgram.transfer(
            owner, // from
            vault, // to
            amount // amount to be sent
        )
    }

    withdraw(
        owner: Signer,
        state: Vault,
        auth: UncheckedAccount,
        vault: SystemAccount,
        amount: u64
    ) {
        state.deriveWithBump(['state', owner.key], state.stateBump)
        auth.deriveWithBump(['auth', state.key], state.authBump)
        vault.deriveWithBump(['vault', auth.key], state.vaultBump)

        SystemProgram.transfer(
            vault,
            owner,
            amount,
            ['vault', state.key, state.authBump]
        )
    }
}

Account-Status

Benutzerdefinierte Status-Accounts werden als Interface definiert, das Account erweitert. Die Felder des benutzerdefinierten Status-Accounts lassen sich mit Typen aus dem Package @solanaturbine/Poseidon definieren.

export interface Vault extends Account {
    owner: Pubkey
    stateBump: u8
    authBump: u8
    vaultBump: u8
}

Die Wirkung von Poseidon

Poseidon kann die Blockchain-Entwicklungslandschaft auf folgende Weise beeinflussen:

• Solana-Entwickler-Community vergrößern: Mehr Entwickler für das Solana-Ökosystem gewinnen
• Entwicklung beschleunigen: Zeit und Aufwand für die Entwicklung von Solana-Projekten reduzieren
• Entwicklererfahrung verbessern: Eine intuitivere und effizientere Entwicklung ermöglichen

Zukünftige Entwicklung

Künftig soll Poseidon seine Funktionen in folgenden Bereichen weiter ausbauen:

• Mehr Sprachen unterstützen: Zusätzliche Sprachen wie JavaScript und Python unterstützen
• Leistung verbessern: Den Transpilierungsprozess und den generierten Rust-Code optimieren
• Sicherheit erhöhen: Das Framework und den generierten Code gründlich auf Schwachstellen testen

Fazit

Poseidon ist ein großer Fortschritt, um die Entwicklung von Solana-Programmen einem breiteren Publikum zugänglich zu machen. Es schließt die Lücke zwischen Webentwicklung und Blockchain-Programmierung und ermöglicht Entwicklern, innovative und wirkungsvolle Anwendungen auf der Solana-Blockchain zu erstellen. Während sich der Blockchain-Bereich weiterentwickelt, kann Poseidon zu einem unverzichtbaren Tool für angehende Solana-Entwickler werden.

Weitere Ressourcen

• Kite: das moderne Solana-TypeScript-Framework
• Bildungsprogramme von Turbin3
• Poseidon-GitHub-Repository
• Poseidon-Beispielprogramme
• NPM-Package @solanaturbine/poseidon

‍