Écrire sur le réseau

Dans la section précédente, vous avez appris à lire des données depuis le réseau Solana en récupérant des comptes. L'écriture de données sur le réseau Solana nécessite une transaction. Une transaction contient une ou plusieurs instructions, et chaque instruction invoque un programme.

Les programmes définissent la logique métier de chaque instruction. Lorsque vous envoyez une transaction, le runtime Solana exécute les instructions de la transaction dans l'ordre. Les transactions sont atomiques. Soit toutes les instructions de la transaction réussissent, soit la transaction entière échoue.

Les exemples de cette section montrent comment :

Transférer des SOL entre des comptes
Créer un nouveau mint de token

Transférer des SOL

L'exemple ci-dessous transfère des SOL d'un compte à un autre. Seul le programme désigné comme propriétaire d'un compte peut modifier les données de ce compte ou déduire des lamports de son solde. Les comptes de portefeuille appartiennent au System Program, donc transférer des SOL entre des comptes de portefeuille nécessite une instruction qui invoque le transfer du System Program. Le compte source doit également signer la transaction.

Transfer SOL

import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import { solanaRpc, rpcAirdrop } from "@solana/kit-plugin-rpc";
import { generatedPayer, airdropPayer } from "@solana/kit-plugin-signer";
import { getTransferSolInstruction } from "@solana-program/system";

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

const receiver = await generateKeyPairSigner();

const transferInstruction = getTransferSolInstruction({
  source: client.payer,
  destination: receiver.address,
  amount: lamports(10_000_000n)
});

const result = await client.sendTransaction([transferInstruction]);

console.log("Transaction Signature:", result.context.signature);

const { value: senderBalance } = await client.rpc
  .getBalance(client.payer.address)
  .send();
const { value: receiverBalance } = await client.rpc
  .getBalance(receiver.address)
  .send();

console.log("Sender Balance:", senderBalance);
console.log("Receiver Balance:", receiverBalance);

Console

Click to execute the code.

Transfer SOL

import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import { solanaRpc, rpcAirdrop } from "@solana/kit-plugin-rpc";
import { generatedPayer, airdropPayer } from "@solana/kit-plugin-signer";
import { getTransferSolInstruction } from "@solana-program/system";

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

const receiver = await generateKeyPairSigner();

const transferInstruction = getTransferSolInstruction({
  source: client.payer,
  destination: receiver.address,
  amount: lamports(10_000_000n)
});

const result = await client.sendTransaction([transferInstruction]);

console.log("Transaction Signature:", result.context.signature);

const { value: senderBalance } = await client.rpc
  .getBalance(client.payer.address)
  .send();
const { value: receiverBalance } = await client.rpc
  .getBalance(receiver.address)
  .send();

console.log("Sender Balance:", senderBalance);
console.log("Receiver Balance:", receiverBalance);

Console

Click to execute the code.

Créez un client Kit pour le validator de test local. Ce fragment ajoute un signataire payeur, se connecte au point de terminaison RPC local, active les airdrops et approvisionne le payeur en SOL de test pour le transfert.

Client setup

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

Générez un signataire pour le destinataire. L'expéditeur est client.payer, qui a été créé par generatedPayer() et approvisionné par airdropPayer().

Receiver signer

const receiver = await generateKeyPairSigner();

L'assistant getTransferSolInstruction() crée une instruction System Program. L'instruction transfère des SOL du signataire source vers l'adresse destination pour le montant spécifié de amount lamports.

Transfer instruction

const transferInstruction = getTransferSolInstruction({
  source: client.payer,
  destination: receiver.address,
  amount: lamports(10_000_000n)
});

Appelez client.sendTransaction() avec un tableau d'instructions. Le client Kit transforme les instructions en une seule transaction, signe avec les signataires associés aux instructions, envoie la transaction et attend la confirmation.

Send transaction

const result = await client.sendTransaction([transferInstruction]);

console.log("Transaction Signature:", result.context.signature);

Une fois la transaction confirmée, récupérez les deux soldes en utilisant client.rpc.

Fetch balances

const { value: senderBalance } = await client.rpc
  .getBalance(client.payer.address)
  .send();
const { value: receiverBalance } = await client.rpc
  .getBalance(receiver.address)
  .send();

Client setup

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

Générez un signataire pour le destinataire. L'expéditeur est client.payer, qui a été créé par generatedPayer() et approvisionné par airdropPayer().

Receiver signer

const receiver = await generateKeyPairSigner();

Transfer instruction

const transferInstruction = getTransferSolInstruction({
  source: client.payer,
  destination: receiver.address,
  amount: lamports(10_000_000n)
});

Send transaction

const result = await client.sendTransaction([transferInstruction]);

console.log("Transaction Signature:", result.context.signature);

Une fois la transaction confirmée, récupérez les deux soldes en utilisant client.rpc.

Fetch balances

const { value: senderBalance } = await client.rpc
  .getBalance(client.payer.address)
  .send();
const { value: receiverBalance } = await client.rpc
  .getBalance(receiver.address)
  .send();

Transfer SOL

import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import { solanaRpc, rpcAirdrop } from "@solana/kit-plugin-rpc";
import { generatedPayer, airdropPayer } from "@solana/kit-plugin-signer";
import { getTransferSolInstruction } from "@solana-program/system";

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

Créer un token

L'exemple ci-dessous crée un nouveau mint de token en utilisant le Token Extensions Program. Un mint account est le compte qui définit les paramètres globaux d'un token, tels que les décimales, l'offre, l'autorité de mint et l'autorité de gel.

La création d'un mint account nécessite deux instructions :

Invoquer le System Program pour créer un nouveau compte appartenant au Token Extensions Program.
Invoquer le Token Extensions Program pour initialiser ce compte en tant que mint.

Create mint account

import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import { solanaRpc, rpcAirdrop } from "@solana/kit-plugin-rpc";
import { generatedPayer, airdropPayer } from "@solana/kit-plugin-signer";
import { getCreateAccountInstruction } from "@solana-program/system";
import {
  fetchMint,
  getInitializeMintInstruction,
  getMintSize,
  TOKEN_2022_PROGRAM_ADDRESS
} from "@solana-program/token-2022";

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

const mint = await generateKeyPairSigner();

const space = BigInt(getMintSize());

const rent = await client.rpc.getMinimumBalanceForRentExemption(space).send();

const createAccountInstruction = getCreateAccountInstruction({
  payer: client.payer,
  newAccount: mint,
  space,
  lamports: rent,
  programAddress: TOKEN_2022_PROGRAM_ADDRESS
});

const initializeMintInstruction = getInitializeMintInstruction({
  mint: mint.address,
  decimals: 2,
  mintAuthority: client.payer.address,
  freezeAuthority: client.payer.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

const result = await client.sendTransaction([
  createAccountInstruction,
  initializeMintInstruction
]);

console.log("Mint Address:", mint.address);
console.log("Transaction Signature:", result.context.signature);

const mintAccount = await fetchMint(client.rpc, mint.address);
console.log("Mint Account:", mintAccount);

Console

Click to execute the code.

Create mint account

import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import { solanaRpc, rpcAirdrop } from "@solana/kit-plugin-rpc";
import { generatedPayer, airdropPayer } from "@solana/kit-plugin-signer";
import { getCreateAccountInstruction } from "@solana-program/system";
import {
  fetchMint,
  getInitializeMintInstruction,
  getMintSize,
  TOKEN_2022_PROGRAM_ADDRESS
} from "@solana-program/token-2022";

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

const mint = await generateKeyPairSigner();

const space = BigInt(getMintSize());

const rent = await client.rpc.getMinimumBalanceForRentExemption(space).send();

const createAccountInstruction = getCreateAccountInstruction({
  payer: client.payer,
  newAccount: mint,
  space,
  lamports: rent,
  programAddress: TOKEN_2022_PROGRAM_ADDRESS
});

const initializeMintInstruction = getInitializeMintInstruction({
  mint: mint.address,
  decimals: 2,
  mintAuthority: client.payer.address,
  freezeAuthority: client.payer.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

const result = await client.sendTransaction([
  createAccountInstruction,
  initializeMintInstruction
]);

console.log("Mint Address:", mint.address);
console.log("Transaction Signature:", result.context.signature);

const mintAccount = await fetchMint(client.rpc, mint.address);
console.log("Mint Account:", mintAccount);

Console

Click to execute the code.

Créez et alimentez un client Kit, puis générez un signataire à utiliser comme adresse du nouveau mint account. Le payeur du client finance la création du compte et règle les frais de transaction.

Client and mint setup

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

const mint = await generateKeyPairSigner();

Calculez la taille du mint account en octets, puis effectuez une requête RPC pour calculer les lamports nécessaires au stockage de ces données dans le compte. Ce solde requis est appelé rent.

Mint account size and rent

const space = BigInt(getMintSize());

const rent = await client.rpc.getMinimumBalanceForRentExemption(space).send();

La première instruction invoque le System Program. L'instruction utilise le payer pour alimenter un newAccount, alloue l'espace space du mint account, transfère les lamports exempts de rent, et attribue la propriété au programAddress.

Create account instruction

const createAccountInstruction = getCreateAccountInstruction({
  payer: client.payer,
  newAccount: mint,
  space,
  lamports: rent,
  programAddress: TOKEN_2022_PROGRAM_ADDRESS
});

La seconde instruction invoque le Token Extensions Program. L'instruction initialise l'adresse mint avec une valeur decimals, une mintAuthority, une freezeAuthority, et spécifie le tokenProgram qui détient le mint account.

Initialize mint instruction

const initializeMintInstruction = getInitializeMintInstruction({
  mint: mint.address,
  decimals: 2,
  mintAuthority: client.payer.address,
  freezeAuthority: client.payer.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

Envoyez les deux instructions en une seule transaction. L'instruction de création de compte doit précéder l'instruction d'initialisation du mint car le mint account doit exister avant que le Token Extensions Program puisse y écrire les données du mint.

Send transaction

const result = await client.sendTransaction([
  createAccountInstruction,
  initializeMintInstruction
]);

Une fois la transaction confirmée, récupérez le mint account.

Fetch mint account

const mintAccount = await fetchMint(client.rpc, mint.address);
console.log("Mint Account:", mintAccount);

Client and mint setup

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

const mint = await generateKeyPairSigner();

Calculez la taille du mint account en octets, puis effectuez une requête RPC pour calculer les lamports nécessaires au stockage de ces données dans le compte. Ce solde requis est appelé rent.

Mint account size and rent

const space = BigInt(getMintSize());

const rent = await client.rpc.getMinimumBalanceForRentExemption(space).send();

Create account instruction

const createAccountInstruction = getCreateAccountInstruction({
  payer: client.payer,
  newAccount: mint,
  space,
  lamports: rent,
  programAddress: TOKEN_2022_PROGRAM_ADDRESS
});

Initialize mint instruction

const initializeMintInstruction = getInitializeMintInstruction({
  mint: mint.address,
  decimals: 2,
  mintAuthority: client.payer.address,
  freezeAuthority: client.payer.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

Send transaction

const result = await client.sendTransaction([
  createAccountInstruction,
  initializeMintInstruction
]);

Une fois la transaction confirmée, récupérez le mint account.

Fetch mint account

const mintAccount = await fetchMint(client.rpc, mint.address);
console.log("Mint Account:", mintAccount);

Create mint account

import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import { solanaRpc, rpcAirdrop } from "@solana/kit-plugin-rpc";
import { generatedPayer, airdropPayer } from "@solana/kit-plugin-signer";
import { getCreateAccountInstruction } from "@solana-program/system";
import {
  fetchMint,
  getInitializeMintInstruction,
  getMintSize,
  TOKEN_2022_PROGRAM_ADDRESS
} from "@solana-program/token-2022";

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

const mint = await generateKeyPairSigner();

Ces exemples utilisent generatedPayer() pour créer un keypair jetable à des fins de test local. Les applications en production ne doivent jamais stocker des clés privées brutes dans le code — déléguez la signature à un backend de gestion des clés. Voir Signature en production.

Écrire sur le réseau

Transférer des SOL

Créer un token

Table des matières