Présentation de Kite : le framework TypeScript moderne pour Solana
Sommaire
Aujourd’hui, nous sommes ravis d’annoncer Kite, le framework TypeScript moderne pour le navigateur et Node.js. Kite s’appuie sur la puissance de Solana web3.js version 2 tout en simplifiant considérablement les tâches courantes.
Pourquoi Kite ?
Kite exploite la rapidité et l’élégance de Solana web3.js version 2, tout en vous permettant d’effectuer les tâches Solana quotidiennes avec une seule fonction.
Comme Kite s’appuie sur web3.js version 2 pour les opérations complexes, toutes les fonctionnalités de web3.js version 2 restent disponibles. Si vous n’avez plus besoin de Kite, vous pouvez facilement le supprimer et utiliser directement web3.js version 2.
Kite est une mise à jour pour web3.js v2 de @solana-developers/helpers, la bibliothèque de haut niveau la plus populaire pour web3.js version 1, réalisée par son auteur d’origine.
Le package Kite comprend des versions actualisées de la plupart des utilitaires d’origine, notamment des contributions de Helius, de la Solana Foundation, d’Anza, de Turbin3, d’Unboxed Software et de StarAtlas.
Les fonctions de @solana-developers/helpers qui ne sont pas encore disponibles dans Kite seront bientôt ajoutées.
Kite fonctionne à la fois dans le navigateur et dans node.js, avec des dépendances minimales.
Que puis-je faire avec Kite ?
Kite inclut des fonctions permettant d’effectuer les opérations suivantes :
Portefeuilles
- Créer un nouveau portefeuille — avec des adresses personnalisées, un solde en SOL prêt à être dépensé et/ou une sauvegarde dans un fichier.
- Charger un portefeuille depuis un fichier — au format Anza id.json standard.
- Charger un portefeuille depuis une variable d’environnement — au format habituel de « tableau de nombres » utilisé par la plupart des outils Solana.
SOL
- Recevoir des SOL par airdrop lorsque le solde est faible — un moyen pratique d’obtenir des SOL lorsque c’est nécessaire, sans solliciter inutilement les faucets devnet/testnet.
- Obtenir le solde en SOL d’un compte - obtenir un solde en SOL.
- Transférer des SOL entre des portefeuilles.
Tokens
- Créer un nouveau token — avec des métadonnées de token.
- Obtenir l’adresse du compte de token — pour trouver l’adresse d’un portefeuille associée à un token donné.
- Obtenir les informations du mint d’un token — pour consulter les détails d’un mint.
- Émettre des tokens sur un compte — pour permettre à l’autorité de mint d’utiliser un mint de token et de créer de nouveaux tokens sur le compte d’une personne.
- Transférer des tokens entre des comptes — déterminer les comptes de token nécessaires pour l’expéditeur et le destinataire, créer si nécessaire le compte de token du destinataire et transférer les tokens entre les comptes !
Transactions
- Signer, envoyer et confirmer une transaction — en une seule étape. Récupérez les instructions d’une transaction, créez la transaction, obtenez un blockhash récent, signez le message qu’elle contient, puis envoyez-la.
- Envoyer et confirmer une transaction — si vous avez déjà créé une transaction
- Vérifier si une transaction est confirmée.
- Obtenir les logs d’une transaction — obtenir les logs d’une transaction.
Explorer
- Obtenir un lien Solana Explorer — une seule étape avec toutes les informations nécessaires pour afficher la transaction, le bloc ou l’adresse à l’aide de votre RPC.
Comparaison entre Kite et Solana web3.js 2 :
Voici un exemple rapide de création d’un token
Avec Kite
N’oubliez pas que Kite est simplement un framework reposant sur web3.js v2. Il utilise donc les mêmes types et les mêmes fonctionnalités sous-jacentes de web3.js v2.
import { connect } from "@helius-dev/kite";
const connection = connect();
const mintAddress = await connection.makeTokenMint(
mintAuthority,
6,
"My Token",
"MTKN",
"https://example.com/metadata.json",
{
description: "A sample token",
website: "https://example.com",
},
);
console.log(connection.getExplorerLink(mintAddress));Avec Solana web3.js v2
...sans Kite !
import {
airdropFactory,
appendTransactionMessageInstructions,
createSolanaRpc,
createSolanaRpcSubscriptions,
createTransactionMessage,
generateKeyPairSigner,
getSignatureFromTransaction,
lamports,
pipe,
sendAndConfirmTransactionFactory,
setTransactionMessageFeePayerSigner,
setTransactionMessageLifetimeUsingBlockhash,
signTransactionMessageWithSigners,
some,
} from "@solana/web3.js";
import { getCreateAccountInstruction } from "@solana-program/system";
import {
getInitializeMintInstruction,
getMintSize,
TOKEN_2022_PROGRAM_ADDRESS,
extension,
getInitializeMetadataPointerInstruction,
getInitializeTokenMetadataInstruction,
tokenMetadataField,
getUpdateTokenMetadataFieldInstruction,
} from "@solana-program/token-2022";
const rpc = createSolanaRpc("http://127.0.0.1:8899");
const rpcSubscriptions = createSolanaRpcSubscriptions("ws://127.0.0.1:8900");
const feePayer = await generateKeyPairSigner();
console.log(feePayer.address);
const mint = await generateKeyPairSigner();
await airdropFactory({ rpc, rpcSubscriptions })({
recipientAddress: feePayer.address,
lamports: lamports(1_000_000_000n),
commitment: "confirmed",
});
const balance = await rpc.getBalance(feePayer.address).send();
console.log("balance:", balance.value);
const metadataPointerExtension = extension("MetadataPointer", {
authority: some(feePayer.address),
metadataAddress: some(mint.address),
});
const tokenMetadataExtension = extension("TokenMetadata", {
updateAuthority: some(feePayer.address),
mint: mint.address,
name: "OPOS",
symbol: "OPOS",
uri: "https://raw.githubusercontent.com/solana-developers/opos-asset/main/assets/DeveloperPortal/metadata.json",
additionalMetadata: new Map<string, string>([["description", "Only Possible On Solana"]]),
});
const spaceWithoutMetadata = BigInt(getMintSize([metadataPointerExtension]));
const spaceWithMetadata = BigInt(getMintSize([metadataPointerExtension, tokenMetadataExtension]));
const rent = await rpc.getMinimumBalanceForRentExemption(spaceWithMetadata).send();
const createAccountInstruction = getCreateAccountInstruction({
payer: feePayer,
newAccount: mint,
lamports: rent,
space: spaceWithoutMetadata,
programAddress: TOKEN_2022_PROGRAM_ADDRESS,
});
const initializeMetadataPointerInstruction = getInitializeMetadataPointerInstruction({
mint: mint.address,
authority: feePayer.address,
metadataAddress: mint.address,
});
const initializeMintInstruction = getInitializeMintInstruction({
mint: mint.address,
decimals: 2,
mintAuthority: feePayer.address,
});
const initializeTokenMetadataInstruction = getInitializeTokenMetadataInstruction({
metadata: mint.address,
updateAuthority: feePayer.address,
mint: mint.address,
mintAuthority: feePayer,
name: tokenMetadataExtension.name,
symbol: tokenMetadataExtension.symbol,
uri: tokenMetadataExtension.uri,
});
const updateTokenMetadataInstruction = getUpdateTokenMetadataFieldInstruction({
metadata: mint.address,
updateAuthority: feePayer,
field: tokenMetadataField("Key", ["description"]),
value: "Only Possible On Solana",
});
const instructions = [
createAccountInstruction,
initializeMetadataPointerInstruction,
initializeMintInstruction,
initializeTokenMetadataInstruction,
updateTokenMetadataInstruction,
];
const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
const transactionMessage = pipe(
createTransactionMessage({ version: 0 }),
(message) => setTransactionMessageFeePayerSigner(feePayer, message),
(message) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, message),
(message) => appendTransactionMessageInstructions(instructions, message),
);
const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
const transactionSignature = getSignatureFromTransaction(signedTransaction);
await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(signedTransaction, {
commitment: "confirmed",
skipPreflight: true,
});
console.log("Transaction Signature:", `https://explorer.solana.com/tx/${transactionSignature}?cluster=custom`);
Comme vous pouvez le constater, sans Kite, il faudrait créer un message de transaction avec cinq instructions et les options correspondantes, signer le message de transaction, puis l’envoyer au RPC. Avec Kite, vous exécutez makeTokenMint et récupérez l’adresse du nouveau mint.
Comparaison entre Kite et Poseidon
Kite est une bibliothèque entièrement côté client destinée aux navigateurs et à node.js. Découvrez Poseidon si vous souhaitez créer des applications on-chain (par exemple, des smart contracts) avec TypeScript.
Contribuer
Bien que Kite soit encore récent, nous nous engageons à en faire un framework robuste qui rend le développement sur Solana plus accessible à tous.
En simplifiant les tâches courantes et en réduisant le code répétitif, nous pouvons aider davantage de développeurs à créer des projets exceptionnels sur Solana.
Voici comment vous pouvez nous aider :
- Signaler des problèmes
- Consultez nos consignes de contribution et soumettez des pull requests
Essayez Kite dès aujourd’hui
Prêt à simplifier votre développement sur Solana ?
Commencez avec Kite :
npm i @helius-dev/kiteConsultez notre dépôt GitHub pour accéder à la documentation complète et aux exemples.
Accélérons ensemble le développement sur Solana ! 🪁
Articles associés
Abonnez-vous à Helius
Suivez les dernières actualités du développement sur Solana et recevez une notification à chaque publication