So entwickelst du Solana-Apps mit Gill

Was ist Gill?

Gill ist eine moderne TypeScript-Bibliothek zur Entwicklung von Solana-Anwendungen in jeder JavaScript-basierten Umgebung – vom Browser über den Server bis hin zu Mobilgeräten.

Die Gill-Bibliothek richtet sich an Solana-Entwickler aller Erfahrungsstufen, von Einsteigern bis zu Profis. Da High-Level-Abstraktionen und Low-Level-Primitive im selben Paket enthalten sind, können Entwickler bei Bedarf unkompliziert auf erweiterte Funktionen zugreifen – auch wenn die Abstraktionen sie nicht unterstützen. 

Das Beste daran? 

Gill ist vollständig tree-shakable. Dein Bundler entfernt daher automatisch alle Primitive und Abstraktionen, die deine Codebasis nicht verwendet.

Gill soll vor allem die Entwicklererfahrung verbessern. Dafür vereinfacht die Bibliothek gängige Aufgaben bei der Solana-Entwicklung und entfernt Boilerplate-Code, ohne den Zugriff auf Low-Level-Funktionen einzuschränken. Entwickler sollten nicht zwischen High-Level-Abstraktionen und Low-Level-Primitiven wählen müssen. Sie sollten jederzeit unkompliziert die passende Ebene nutzen können.

Gill installieren

Du kannst Gill in jedem JavaScript- oder TypeScript-basierten Projekt installieren, einschließlich NodeJS/Bun, Browsern, React Native und nahezu jeder anderen JavaScript-Umgebung.

npm install gill

Die Gill-Bibliothek bietet umfassende TypeScript-Unterstützung und sollte in den meisten Anwendungen direkt funktionieren. Je nach Konfiguration deines Projekts können jedoch Anpassungen nötig sein, damit Gill optimal funktioniert. Weitere Informationen findest du in der Dokumentation zur TypeScript-Unterstützung in Gill.

Gill vs. @solana/kit

Die Gill-Bibliothek baut direkt auf @solana/kit auf. Diese neuen Low-Level-JavaScript-Primitive hat Anza als leistungsfähigere Alternative zum alten @solana/web3.js entwickelt.

Kit enthält ausschließlich diese Low-Level-Primitive. Entwickler müssen daher alles manuell erstellen. Das führt zu aufgeblähten Anwendungen mit viel Boilerplate-Code.

Hier kommt Gill ins Spiel.

Gill bietet sowohl dieselben Low-Level-Primitive wie Kit als auch leicht meinungsstarke Abstraktionen für gängige Aufgaben – alles über eine einzige kompatible Schnittstelle. Da Gill die Entwicklung umfassend vereinfacht, können Entwickler mehr Zeit in die Geschäftslogik ihrer Anwendung investieren und müssen sich weniger mit ausführlichem Boilerplate-Code beschäftigen.

Codebeispiele: Gill vs. Kit

Die folgenden Codeausschnitte zeigen, wie du deinen Code vereinfachen kannst, ohne Funktionen einzubüßen – und möglicherweise sogar mit zusätzlichen Funktionen. Nahezu jede Anwendung muss zwei Aufgaben erledigen: eine Verbindung zur Blockchain herstellen und Transaktionen erstellen.

So stellst du mit @solana/kit eine Verbindung zur Blockchain her:

import {
  devnet,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  sendAndConfirmTransactionFactory,
} from "@solana/kit";

const rpc = createSolanaRpc(devnet("https://api.devnet.solana.com"));

const rpcSubscriptions = createSolanaRpcSubscriptions(
  devnet("wss://api.devnet.solana.com"),
);

const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({
  rpc,
  rpcSubscriptions,
});

Dieselbe Logik lässt sich mit der Funktion createSolanaClient von Gill einfacher umsetzen:

import { createSolanaClient } from "gill";

const { rpc, rpcSubscriptions, sendAndConfirmTransaction } = createSolanaClient({
  urlOrMoniker: "devnet",
});

Jetzt kannst du mit dem Objekt rpc, das du in den obigen Beispielen mit einer der beiden Bibliotheken erstellt hast, einfache RPC-Anfragen senden:

// get the latest blockhash from your RPC provider
const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

So erstellst du in @solana/kit eine einfache Transaktion, die eine Memo-Anweisung und grundlegende Optimierungen durch Compute-Budget-Anweisungen enthält:

import {
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  appendTransactionMessageInstructions,
  setTransactionMessageLifetimeUsingBlockhash,
} from "@solana/kit";
import { getAddMemoInstruction } from "@solana-program/memo";
import {
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
} from "@solana-program/compute-budget";

const transaction = pipe(
  createTransactionMessage({ version: "legacy" }),
  (tx) => setTransactionMessageFeePayerSigner(signer, tx),
  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
  (tx) =>
    appendTransactionMessageInstructions(
      [
        getAddMemoInstruction({
          memo: "gm world!",
        }),
        getSetComputeUnitLimitInstruction({ units: 5000 }),
        getSetComputeUnitPriceInstruction({ microLamports: 1000 }),
      ],
      tx,
    ),
);

Mit gill lässt sich dieselbe Logik deutlich vereinfachen:

import { createTransaction } from "gill";
import { getAddMemoInstruction } from "gill/programs";

const transaction = createTransaction({
  version: "legacy",
  feePayer: signer,
  instructions: [
    getAddMemoInstruction({
      memo: "gm world!",
    }),
  ],
  latestBlockhash,
  computeUnitLimit: 5000,
  computeUnitPrice: 1000,
});

Einen ausführlicheren Vergleich der beiden Bibliotheken findest du in der Gill-Dokumentation zu Gill vs. @solana/kit.

Was umfasst die Migration von Kit zu Gill?

Bei Anwendungen, die die Bibliothek @solana/kit verwenden, ist die Migration zum Paket gill sehr unkompliziert:

1. Installiere gill
2. Ersetze alle Importe von @solana/kit durch gill
3. Deinstalliere @solana/kit

Da Gill die gängigsten Clients der Solana Program Library (SPL) direkt enthält, kannst du auch deren Paketimporte durch Gill ersetzen. Gill enthält die folgenden SPL-Clients, die direkt über den Importpfad gill/programs verfügbar sind:

• @solana-program/system
• @solana-program/memo
• @solana-program/compute-budget
• @solana-program/address-lookup-table
• @solana-program/token-2022 (siehe den Hinweis unten zu Clients für Token-Programme)

So verwendest du für diese SPL-Programm-Clients ausschließlich das Paket gill:

1. Ersetze die oben aufgeführten Paketimporte von @solana-program/* durch gill/programs
2. Deinstalliere die oben aufgeführten @solana-program/*-Pakete.

Sobald du deine Importe aktualisiert hast, kann deine Anwendung die „Gill-Core“-Bibliothek sofort verwenden. Mit den verfügbaren gill-Abstraktionen kannst du den ausführlichen Kit-Boilerplate-Code – etwa zum Erstellen von Blockchain-Verbindungen und Transaktionen – jetzt problemlos umgestalten.

Welche Komponenten enthält Gill?

Die Gill-Bibliothek lässt sich in einige zentrale Komponenten unterteilen:

• Kernfunktionen (auch „Gill Core“)
• Hilfsfunktionen für bestimmte Server-Laufzeitumgebungen (z. B. NodeJS und Bun)
• Programm-Clients
• Transaktions-Builder
• Debug-Modus

Node.js-Hilfsfunktionen

Das Paket gill enthält mehrere Dienstprogramme für JavaScript-Server-Laufzeitumgebungen. Sie sind zwar im Paket gill enthalten, nutzen zur Verbesserung des Tree-Shakings jedoch einen separaten Importpfad. Mit diesen Dienstprogrammen kannst du unter anderem Schlüsselpaare unkompliziert aus Dateien oder ENV-Variablen laden und darin speichern.

import { ... } from "gill/node"

So lädst du unkompliziert eine Schlüsselpaardatei aus deinem lokalen Dateisystem, etwa das Schlüsselpaar der Solana CLI:

import { loadKeypairSignerFromFile } from "gill/node";

// default file path: ~/.config/solana/id.json
const signer = await loadKeypairSignerFromFile();
console.log("address:", signer.address);

Du kannst auch ein Base58-codiertes Schlüsselpaar aus einer ENV-Variablen laden:

import { loadKeypairSignerFromEnvironmentBase58 } from "gill/node";

// loads signer from base58 keypair stored at `process.env[variableName]`
const signer = await loadKeypairSignerFromEnvironmentBase58(variableName);
console.log("address:", signer.address);

Transaktions-Builder

Gill enthält verschiedene „Transaktions-Builder“, mit denen du signierbereite Transaktionen für gängige Aufgaben einfach zusammenstellen kannst. Das vereinfacht Transaktionen, die häufig mit mehreren Programmen gleichzeitig interagieren.

Da jeder Transaktions-Builder auf eine einzelne Aufgabe ausgerichtet ist, kann er verschiedene Arten von Boilerplate-Code abstrahieren und zugleich beim Erstellen einer optimierten Transaktion helfen.

Gill bietet unter anderem folgende Transaktions-Builder:

• buildCreateTokenTransaction – einen Token mit Metadaten erstellen
• buildMintTokensTransaction – Token für eine Ziel-Wallet prägen
• buildTransferTokensTransaction – Token an eine Ziel-Wallet übertragen

Zu jedem Transaktions-Builder gehört ein „Anweisungs-Builder“, der Entwicklern mehr Flexibilität bei diesen Gill-Abstraktionen bietet.

Debug-Modus

In Gill kannst du den „Debug-Modus“ aktivieren. Er protokolliert automatisch zusätzliche Informationen, die dir bei der Fehlerbehebung für deine Transaktionen helfen.

Der Debug-Modus ist standardmäßig deaktiviert, um zusätzliche Protokolle deiner Anwendung zu minimieren. Dank der flexiblen Steuerung kannst du ihn an den gängigsten Ausführungsorten deines Codes aktivieren: direkt im Code, in NodeJS-Backends, in serverlosen Funktionen und sogar in der Konsole des Webbrowsers.

Um den Debug-Modus zu aktivieren, setze eine der folgenden Optionen auf true oder 1:

• process.env.GILL_DEBUG
• global.__GILL_DEBUG__
• window.__GILL_DEBUG__ (z. B. in der Konsole deines Webbrowsers)
• oder lege manuell eine beliebige Debug-Protokollstufe fest (siehe Dokumentation)

Weitere Informationen findest du in der Gill-Dokumentation zum Debug-Modus.

Ergänzende Entwicklertools für die Arbeit mit Gill

@gillsdk/react

Direkt in der Gill-Bibliothek befindet sich ein weiteres Paket: @gillsdk/react. Es enthält React-Hooks, die die Entwicklererfahrung bei React-basierten Frontend-Anwendungen deutlich verbessern sollen. Außerdem baut es auf TanStack Query auf, einer beliebten Reaktivitätsbibliothek. Bestehende Anwendungen können es daher leichter nutzen.

Das Paket @gillsdk/react steckt noch in den Kinderschuhen und wird aktiv weiterentwickelt. Derzeit bietet es mehrere nützliche React-Hooks für Solana-Anwendungen:

• useAccount – Account-Informationen für eine Adresse abrufen
• useBalance – Account-Guthaben abrufen (in Lamports)
• useLatestBlockhash – neuesten Blockhash abrufen
• useSignatureStatuses – Signaturstatus abrufen
• useProgramAccounts – Programm-Accounts (GPA) abrufen
• useTokenMint – decodierten Mint-Account eines Tokens abrufen
• useTokenAccount – Token-Account für einen bestimmten Mint und Eigentümer (oder ATA) abrufen

Codama

Codama ist ein Tool, mit dem Entwickler aus der IDL eines Solana-Programms Clientbibliotheken wie JavaScript oder Rust für andere Anwendungen generieren können. Codama reduziert die gesamte Komplexität beim Erstellen von Solana-Anweisungen auf eine IDL, eine Konfigurationsdatei und den Import einer Funktion.

Gill und Codama lassen sich über die Gill-Funktion createCodamaConfig unkompliziert integrieren. Der Gill-Maintainer arbeitet zudem aktiv daran, die Integration zwischen Gill<>Codama weiter zu verbessern – einschließlich direkter Unterstützung in der Codama CLI!

Standardmäßig verwenden von Codama generierte TypeScript-Programm-Clients @solana/kit. Du kannst dies jedoch unkompliziert in der Codama-Konfigurationsdatei deines Solana-Programms ändern. Mit der Funktion createCodamaConfig ist der Wechsel zu gill in deiner Codama-Konfiguration ganz einfach.

Das folgende Beispiel einer codama.js-Datei generiert einen TypeScript-Client für ein Solana-Programm, der gill verwendet:

import { createCodamaConfig } from "gill";

export default createCodamaConfig({
  idl: "program/idl.json",
  clientJs: "clients/js/src/generated",
});

Eine vollständige Anleitung zum Generieren von Solana-Programm-Clients mit Codama findest du in der Gill-Dokumentation.

Die Zukunft von Gill

Die Zukunft der Gill-Bibliothek sieht vielversprechend aus, und es gibt noch viel zu tun. Die offizielle Website der Gill-Dokumentation ist gerade gestartet, und die Bibliothek nähert sich 20.000 Downloads pro Monat.

Weitere Informationen zu den aktuellen Plänen für Gill findest du auf der GitHub-Projects-Seite. Derzeit umfasst die engere Auswahl:

• Direkte Unterstützung der Solana-Pay-Spezifikation
• Native Integration der API-Spezifikation für den Digital Assets Standard (DAS)
• Verbesserte Unterstützung für Token, die auf Token Extensions basieren
• Verbesserte Unterstützung für Address Lookup Tables
• Umfassendere Dokumentation

Das in der Gill-Bibliothek enthaltene Paket @gillsdk/react steckt mit neun verschiedenen React-Hooks noch in den Kinderschuhen. Es wird weiter ausgebaut, damit Entwickler ihren React-basierten Anwendungen unkompliziert Reaktivität hinzufügen können. Dazu gehören die Unterstützung aller gängigen Solana-RPC-Methoden und eine engere Integration mit wallet-ui.

Fun Fact: Es gibt Pläne, Gill direkt in das Anchor-Framework zu integrieren. So könnten Entwickler die Optimierungen und Verbesserungen der Entwicklererfahrung von Gill noch einfacher in ihren Anwendungen nutzen. Wer weiß, vielleicht wird Gill in Anchor v2 zum Standard. :shhh:

So trägst du zu Gill bei

Die Gill-Bibliothek ist Open Source (MIT-Lizenz), und Beiträge sind willkommen! Wenn du zur Bibliothek beitragen möchtest, sieh dir die offenen Issues an und überlege, ob du einen davon selbst bearbeiten willst.

Wenn du eine neue Funktion oder Verbesserung für die Bibliothek vorschlagen möchtest, öffne bitte zuerst einen Issue. So kannst du mit den Maintainern darüber sprechen, bevor du Code für einen PR schreibst.

Weitere Ressourcen

Weitere Informationen und Ressourcen zu Gill findest du unter den folgenden Links:

• @gillsdk/react-Paket auf npm
• Tweet-Thread des Gill-Entwicklers – @nickfrosty
• Solana-Entwicklung mit JavaScript: So verwendest du Gill
• Offizieller X-Account von Gill
• Video: Solana-JavaScript-Tutorial: Einstieg in die web3-Entwicklung mit Gill
• Playlist: Solana-JavaScript mit Gill