Schreiben ins Netzwerk

Im vorherigen Abschnitt haben Sie gelernt, wie Sie Daten aus dem Solana-Netzwerk lesen indem Sie Konten abrufen. Das Schreiben von Daten in das Solana-Netzwerk erfordert eine Transaktion. Eine Transaktion enthält eine oder mehrere Anweisungen, und jede Anweisung ruft ein Programm auf.

Programme definieren die Geschäftslogik für jede Anweisung. Wenn Sie eine transaktion senden, führt die Solana-Laufzeitumgebung die Anweisungen der Transaktion der Reihe nach aus. Transaktionen sind atomar. Entweder gelingt jede Anweisung in der Transaktion, oder die gesamte Transaktion schlägt fehl.

Die Beispiele in diesem Abschnitt zeigen, wie man:

SOL zwischen Konten überträgt
Einen neuen Token-Mint erstellt

SOL übertragen

Das folgende Beispiel überträgt SOL von einem Konto auf ein anderes. Nur das Programm, das als Eigentümer eines Kontos festgelegt ist, kann die Daten des Kontos ändern oder lamports von dessen Guthaben abziehen. Wallet-Konten gehören dem System Program, daher erfordert die Übertragung von SOL zwischen Wallet-Konten eine Anweisung, die das System Program aufruft transfer Anweisung. Das Quellkonto muss die Transaktion ebenfalls signieren.

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.

Erstelle einen Kit-Client für den lokalen Test-validator. Dieses Snippet fügt einen Zahler-Signer hinzu, stellt eine Verbindung zum lokalen RPC-Endpunkt her, aktiviert Airdrops und stattet den Zahler mit Test-SOL für die Übertragung aus.

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)));

Generiere einen Signer für den Empfänger. Der Sender ist client.payer, der von generatedPayer() erstellt und von airdropPayer() finanziert wurde.

Receiver signer

const receiver = await generateKeyPairSigner();

Der getTransferSolInstruction()-Helfer erstellt eine System Program- Anweisung. Die Anweisung überträgt SOL vom source-Signer an die destination-Adresse für den angegebenen amount an lamports.

Transfer instruction

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

Rufe client.sendTransaction() mit einem Array von Anweisungen auf. Der Kit-Client wandelt die Anweisungen in eine Transaktion um, signiert mit den an die Anweisungen angehängten Signern, sendet die Transaktion und wartet auf die Bestätigung.

Send transaction

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

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

Nachdem die Transaktion bestätigt wurde, rufen Sie beide Salden mit client.rpc ab.

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)));

Generiere einen Signer für den Empfänger. Der Sender ist client.payer, der von generatedPayer() erstellt und von airdropPayer() finanziert wurde.

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);

Nachdem die Transaktion bestätigt wurde, rufen Sie beide Salden mit client.rpc ab.

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)));

Ein Token erstellen

Das folgende Beispiel erstellt eine neue Token-Prägung mithilfe des Token Extensions Program. Ein mint account ist das Konten, das die globalen Einstellungen eines Tokens definiert, wie z. B. Dezimalstellen, Angebot, Prägeberechtigung und Einfrierungsberechtigung.

Das Erstellen eines mint account erfordert zwei Anweisungen:

Rufen Sie das System Program auf, um ein neues Konten zu erstellen, das dem Token Extensions Program gehört.
Rufen Sie das Token Extensions Program auf, um dieses Konten als Prägung zu initialisieren.

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.

Erstelle und finanziere einen Kit-Client, und generiere dann einen Signer als Adresse des neuen mint account. Der Client-Zahler finanziert die Kontoerstellung und bezahlt die Transaktionsgebühr.

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();

Berechne die Größe des mint account in Bytes und stelle dann eine RPC-Anfrage, um die lamports zu berechnen, die zum Speichern dieser Daten im Konten erforderlich sind. Dieses erforderliche Guthaben wird als rent bezeichnet.

Mint account size and rent

const space = BigInt(getMintSize());

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

Die erste Anweisung ruft das System Program auf. Die Anweisung verwendet den payer, um ein newAccount zu finanzieren, weist dem mint account space zu, überträgt die rent-befreiten lamports und übergibt die Eigentümerschaft an das programAddress.

Create account instruction

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

Die zweite Anweisung ruft das Token Extensions Program auf. Die Anweisung initialisiert die mint-Adresse mit einem decimals-Wert, einer mintAuthority, einer freezeAuthority und gibt das tokenProgram an, dem das mint account gehört.

Initialize mint instruction

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

Senden Sie beide Anweisungen in einer einzigen Transaktion. Die Anweisung zur Kontoerstellung muss vor der Anweisung zur Initialisierung des mint account kommen, da das mint account existieren muss, bevor das Token Extensions Program Mint-Daten in das Konten schreiben kann.

Send transaction

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

Nachdem die Transaktion bestätigt wurde, rufen Sie das mint account ab.

Fetch mint account

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

Erstelle und finanziere einen Kit-Client, und generiere dann einen Signer als Adresse des neuen mint account. Der Client-Zahler finanziert die Kontoerstellung und bezahlt die Transaktionsgebühr.

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();

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
]);

Nachdem die Transaktion bestätigt wurde, rufen Sie das mint account ab.

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();

Schreiben ins Netzwerk

SOL übertragen

Ein Token erstellen

Inhaltsverzeichnis