7 minutes de lecture
Aperçu
Le 10 octobre 2022 (époque 358), Solana a ajouté la prise en charge de nouveaux types de versions de transactions grâce à un concept appelé «transactions versionnées ». Suite à cette modification, le runtime Solana prend désormais en charge deux types de transactions : « legacy » (transactions plus anciennes) et « 0 » (transactions incluant des tables de recherche d'adresses). Les transactions versionnées vous permettront d'utiliser dès aujourd'hui les tables de recherche d'adresses et pourraient offrir des fonctionnalités supplémentaires à l'avenir.
Dans ce guide, vous allez créer et exécuter une transaction de version 0 (V0).
Si vous avez besoin d'aide pour vous assurer que vos applications côté client existantes prennent en charge les transactions versionnées, consultez notre guide : Comment mettre à jour votre client Solana pour prendre en charge les transactions versionnées.
Ce dont vous aurez besoin
- Node.js (version 16.15 ou supérieure) installé
- Expérience avec TypeScript et ts-node installé
- Expérience dans l'exécution de transactions Solana de base (Guide : Comment envoyer des transactions sur Solana à l'aide de JavaScript)
Configurer votre projet
Créez un nouveau répertoire de projet dans votre terminal à l'aide de la commande suivante :
mkdir solana-versioned-tx
cd solana-versioned-tx
Créez un fichier pour votre application, app.ts:
echo > app.ts
Initialisez votre projet avec l'option « yes » pour utiliser les valeurs par défaut de votre nouveau paquet :
yarn init --yes
#or
npm init --yes
Créez un fichier tsconfig.json en activant l'importation .json :
tsc -init --resolveJsonModule true
Installer la dépendance Solana Web3
Pour cet exercice, nous devrons ajouter la bibliothèque Solana Web3. Dans votre terminal, tapez :
yarn add @solana/web3.js@1
#or
npm install @solana/web3.js@1
C'est parti.
Configurer votre application
Importer les dépendances nécessaires
Ouvrez le fichier app.ts et collez les importations suivantes à la ligne 1 pour récupérer quelques méthodes et classes essentielles de la bibliothèque Solana Web3 :
import { Connection, Keypair, LAMPORTS_PER_SOL, SystemProgram, TransactionInstruction, TransactionMessage, VersionedTransaction } from '@solana/web3.js';
Créer un portefeuille et recevoir des SOL par airdrop
La première étape consiste à créer un compte avec un portefeuille et à l'approvisionner. Nous allons utiliser l'outil pratique ci-dessous pour générer automatiquement un nouveau portefeuille et y recevoir 1 SOL par airdrop. (Vous pouvez également le faire avec le Keypair.generate() et requestAirdrop() fonctions si vous préférez une approche plus manuelle).
Remarque : l'envoi trop fréquent de demandes d'airdrop peut déclencher une erreur 429 (Too Many Requests).
Une fois que vous aurez généré votre paire de clés, vous remarquerez deux nouvelles constantes : secret et PORTEFEUILLE_DE_SIGNATURE, une paire de clés. La secret est un tableau de 32 octets utilisé pour générer les clés publique et privée. Le PORTEFEUILLE_DE_SIGNATURE Il s'agit d'une instance de Keypair utilisée pour signer les transactions (nous avons distribué gratuitement des SOL du réseau de développement pour couvrir les frais de gaz). N'oubliez pas de l'ajouter à votre code sous vos autres constantes si ce n'est pas déjà fait.
Sous vos importations, collez votre nouveau secret, puis ajoutez :
const secret = [0,...,0]; // 👈 Remplacez par votre secret
const SIGNER_WALLET = Keypair.fromSecretKey(new Uint8Array(secret));
const PORTEFEUILLE_DE_DESTINATION = Keypair.générer();
Nous avons défini deux portefeuilles : PORTEFEUILLE_DE_SIGNATURE enverra SOL à notre DESTINATION_PORTEFEUILLE. Nous avons également ajouté une constante, ADRESSE_DE_TABLE_DE_RECHERCHE, que nous mettrons à jour ultérieurement pour y faire figurer l'identifiant de compte sur la blockchain de notre table de correspondance.
Configurer votre point de terminaison Quicknode
Pour développer sur Solana, vous aurez besoin d'un point de terminaison API pour vous connecter au réseau. Vous pouvez bien sûr utiliser des nœuds publics ou déployer et gérer votre propre infrastructure ; toutefois, si vous souhaitez bénéficier de temps de réponse 8 fois plus rapides, vous pouvez nous confier cette tâche fastidieuse.
Découvrez pourquoi plus de 50 % des projets sur Solana choisissent Quicknode et créez un compte ici. Nous allons utiliser un nœud du Devnet de Solana.
Copiez le lien du fournisseur HTTP :
Dans le fichier app.ts, sous vos instructions d'importation, déclarez votre RPC et établissez votre connexion à Solana :
const QUICKNODE_RPC = 'https://example.solana-devnet.quiknode.pro/0123456/';
const SOLANA_CONNECTION = new Connection(QUICKNODE_RPC);
Votre environnement devrait ressembler à ceci :
Bon, c'est parti, on se met au travail !
Créer une transaction de version 0
Les transactions de version 0 nous obligent à utiliser une nouvelle classe, `VersionedTransaction`, qui nécessite de lui passer un `VersionedMessage` en paramètre. Un `VersionedMessage` accepte soit un `Message`, soit un `MessageV0`. Bien qu’ils soient très similaires, `MessageV0` permet l’utilisation de tables de recherche d’adresses !
Commençons par créer une nouvelle instruction de transfert (TransactionInstruction) qui envoie 0,1 SOL de notre SIGNER_WALLET vers notre DESTINATION_WALLET. Étant donné que notre message de transaction va nécessiter un tableau d'instructions de transaction, n'hésitez pas à regrouper l'instruction dans un tableau :
const instructions: TransactionInstruction[] = [
SystemProgram.transfer({
fromPubkey: SIGNER_WALLET.publicKey,
toPubkey: DESTINATION_WALLET.publicKey,
lamports: 0.01 * LAMPORTS_PER_SOL,
}),
];
Créons maintenant une nouvelle fonction, ` createAndSendV0Tx`, qui acceptera notre tableau `TransactionInstruction`:
async function createAndSendV0Tx(txInstructions: TransactionInstruction[]) {
}
Définissons un confirmer la transaction fonction que nous appellerons dans notre createAndSendV0Tx fonction. Ajoutez le code suivant à votre app.ts fichier :
async function confirmTransaction(
connection: Connection,
signature: TransactionSignature,
desiredConfirmationStatus: TransactionConfirmationStatus = 'confirmed',
timeout: number = 30000,
pollInterval: number = 1000,
searchTransactionHistory: boolean = false
): Promise<SignatureStatus> {
const start = Date.now();
while (Date.now() - start < timeout) {
const { value: statuses } = await connection.getSignatureStatuses([signature], { searchTransactionHistory });
if (!statuses || statuses.length === 0) {
throw new Error('Failed to get signature status');
}
const status = statuses[0];
if (status === null) {
// If status is null, the transaction is not yet known
await new Promise(resolve => setTimeout(resolve, pollInterval));
continue;
}
if (status.err) {
throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
}
if (status.confirmationStatus && status.confirmationStatus === desiredConfirmationStatus) {
return status;
}
if (status.confirmationStatus === 'finalized') {
return status;
}
await new Promise(resolve => setTimeout(resolve, pollInterval));
}
throw new Error(`Transaction confirmation timeout after ${timeout}ms`);
}
Cette fonction se contentera d'interroger le réseau Solana pour connaître l'état de la transaction jusqu'à ce que celle-ci soit confirmée ou que le délai d'expiration soit atteint. Nous avons défini des valeurs par défaut pour le délai d'expiration et l'intervalle d'interrogation, mais vous pouvez les modifier selon vos besoins.
Assemblons notre fonction. Ajoutez ces 5 étapes dans le corps de votre fonction ` createAndSendV0Tx `.
Étape 1 : Récupérer le dernier hachage de bloc sur le réseau à l'aide de la fonction getLatestBlockhash:
// Étape 1 - Récupérer le dernier hachage de bloc
let latestBlockhash = await SOLANA_CONNECTION.getLatestBlockhash('confirmed');
console.log(" ✅ - Hash du dernier bloc récupéré. Dernière hauteur valide :", latestBlockhash.lastValidBlockHeight);
Remarque : nous transmettons le paramètre « confirmed » afin de réduire le risque que le hachage provienne d'une branche abandonnée.
Étape 2 : À l'aide de notre paramètre `txInstructions` et de `latestBlockhash`, nous pouvons créer un nouveau `MessageV0` en construisant un nouveau `Message` et en exécutant la méthode `.compileToV0Message()`:
// Step 2 - Generate Transaction Message
const messageV0 = new TransactionMessage({
payerKey: SIGNER_WALLET.publicKey,
recentBlockhash: latestBlockhash.blockhash,
instructions: txInstructions
}).compileToV0Message();
console.log(" ✅ - Compiled Transaction Message");
const transaction = new VersionedTransaction(messageV0);
Nous transmettons ensuite notre message à une nouvelle instance de ` VersionedTransaction`. Félicitations ! Vous venez de créer une transaction versionnée !
Étape 3 : Signer la transaction avec un ensemble de signataires. Dans ce cas précis, il s'agit uniquement de notre SIGNER_WALLET.
// Étape 3 - Signez votre transaction avec les `Signers` requis
transaction.sign([PORTEFEUILLE_DU_SIGNATAIRE]);
console.log(" ✅ - Transaction signée");
REMARQUE : lors de l'envoi d'une VersionedTransaction au cluster, celle-ci doit être signée AVANT d'appeler la méthode sendAndConfirmTransaction. Source : edge.docs.solana.com.
Étape 4 : Envoyez la transaction au cluster à l'aide de la fonction `sendTransaction`, qui renverra une signature/un identifiant de transaction :
// Step 4 - Send our v0 transaction to the cluster
const txid = await SOLANA_CONNECTION.sendTransaction(transaction, { maxRetries: 5 });
console.log(" ✅ - Transaction sent to network");
Remarque : nous transmettons le paramètre « maxRetries » afin de permettre au RPC de réessayer d'envoyer la transaction au leader si nécessaire.
Étape 5 : Enfin, attendez que le cluster confirme que la transaction a été effectuée avec succès :
// Step 5 - Confirm Transaction
const confirmation = await confirmTransaction(SOLANA_CONNECTION, txid);
if (confirmation.err) { throw new Error(" ❌ - Transaction not confirmed.") }
console.log('🎉 Transaction Succesfully Confirmed!', '\n', `https://explorer.solana.com/tx/${txid}?cluster=devnet`);
En cas de réussite, nous enregistrons l'URL de l'explorateur correspondant à la transaction réussie.
Super ! On est prêts à l'essayer !
Exécutez votre code
Pour exécuter notre fonction, appelez ` createAndSendV0Tx ` à la fin du fichier, en lui transmettant les instructions en tant qu'argument :
createAndSendV0Tx(instructions);
Notre code final est disponible sur GitHub, ici.
Ensuite, dans votre terminal, tapez la commande suivante :
ts-node app.ts
Tu vois quelque chose comme ça ?
Bravo ! Si vous souhaitez comparer votre code au nôtre, vous le trouverez sur GitHub, ici.
Prochaines étapes
Maintenant que vous savez créer et exécuter des transactions versionnées, il est temps de découvrir tout ce que les transactions V0 ont à offrir. Consultez notre guide « Comment utiliser les tables de recherche sur Solana » (à venir) pour en savoir plus sur la nouvelle fonctionnalité de tables de recherche de Solana et sur leur utilisation.
Si vous êtes bloqué, si vous avez des questions ou si vous souhaitez simplement discuter de notre domaine, n'hésitez pas à nous envoyer un message sur Discord ou Twitter!
Nous ❤️ les commentaires !
Si vous avez des commentaires ou des questions concernant ce guide, n 'hésitez pas à nous en faire part. Nous serions ravis d'avoir votre avis.