Solana Kontomodell

Auf Solana werden alle Daten in sogenannten "Accounts" (Konten) gespeichert. Man kann sich Daten auf Solana als öffentliche Datenbank mit einer einzigen "Accounts"-Tabelle vorstellen, wobei jeder Eintrag in dieser Tabelle ein "Account" ist. Jedes Solana-Konto teilt denselben grundlegenden Account-Typ.

Accounts

Kernpunkte

• Accounts können bis zu 10MiB an Daten speichern, die entweder ausführbaren Programmcode oder Programmzustand enthalten.
• Accounts erfordern eine rent-Einlage in lamports (SOL), die proportional zur Menge der gespeicherten Daten ist, und Sie können sie vollständig zurückerhalten, wenn Sie das Konto schließen.
• Jedes Konto hat einen Programm- owner. Nur das Programm, das ein Konto besitzt, kann dessen Daten ändern oder sein Lamport-Guthaben abziehen. Aber jeder kann das Guthaben erhöhen.
• Sysvar-Accounts sind spezielle Konten, die den Netzwerk-Cluster-Status speichern.
• Programm-Accounts speichern den ausführbaren Code von Smart Contracts.
• Daten-Accounts werden von Programmen erstellt, um Programmzustände zu speichern und zu verwalten.

Account

Jedes Konto auf Solana hat eine eindeutige 32-Byte-Adresse, die oft als base58 kodierte Zeichenfolge dargestellt wird (z.B. vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg).

Die Beziehung zwischen dem Konto und seiner Adresse funktioniert wie ein Schlüssel-Wert- Paar, wobei die Adresse der Schlüssel ist, um die entsprechenden On-Chain-Daten des Kontos zu lokalisieren. Die Kontoadresse fungiert als "eindeutige ID" für jeden Eintrag in der "Accounts"-Tabelle.

Kontoadresse

Die meisten Solana-Konten verwenden einen Ed25519 öffentlichen Schlüssel als ihre Adresse.

import { generateKeyPairSigner } from "@solana/kit";

// Kit does not enable extractable private keys
const keypairSigner = await generateKeyPairSigner();
console.log(keypairSigner);

import { generateKeyPairSigner } from "@solana/kit";

// Kit does not enable extractable private keys
const keypairSigner = await generateKeyPairSigner();
console.log(keypairSigner);

Während öffentliche Schlüssel häufig als Kontoadressen verwendet werden, unterstützt Solana auch eine Funktion namens Program Derived Addresses (PDAs). PDAs sind spezielle Adressen, die Sie deterministisch aus einer Programm-ID und optionalen Eingaben (seeds) ableiten können.

import { Address, getProgramDerivedAddress } from "@solana/kit";

const programAddress = "11111111111111111111111111111111" as Address;

const seeds = ["helloWorld"];
const [pda, bump] = await getProgramDerivedAddress({
  programAddress,
  seeds
});

console.log(`PDA: ${pda}`);
console.log(`Bump: ${bump}`);

import { Address, getProgramDerivedAddress } from "@solana/kit";

const programAddress = "11111111111111111111111111111111" as Address;

const seeds = ["helloWorld"];
const [pda, bump] = await getProgramDerivedAddress({
  programAddress,
  seeds
});

console.log(`PDA: ${pda}`);
console.log(`Bump: ${bump}`);

Kontotyp

Konten haben eine maximale Größe von 10MiB und jedes Konto auf Solana teilt denselben Basis- Account Typ.

Kontotyp

Jedes Konto auf Solana hat die folgenden Felder:

• data: Ein Byte-Array, das beliebige Daten für ein Konto speichert. Für nicht-ausführbare Konten speichert dies oft Zustände, die gelesen werden sollen. Für Programmkonten (Smart Contracts) enthält dies den ausführbaren Programmcode. Das Datenfeld wird häufig als "Kontodaten" bezeichnet.
• executable: Dieses Flag zeigt an, ob ein Konto ein Programm ist.
• lamports: Das Kontoguthaben in lamports, der kleinsten Einheit von SOL (1 SOL = 1 Milliarde lamports).
• owner: Die Programm-ID (öffentlicher Schlüssel) des Programms, dem dieses Konto gehört. Nur das Besitzerprogramm kann die Kontodaten ändern oder das lamports-Guthaben abziehen.
• rent_epoch: Ein Legacy-Feld aus der Zeit, als Solana einen Mechanismus hatte, der regelmäßig lamports von Konten abzog. Obwohl dieses Feld noch im Account-Typ existiert, wird es nicht mehr verwendet, seit die rent-Erhebung eingestellt wurde.

pub struct Account {
    /// lamports in the account
    pub lamports: u64,
    /// data held in this account
    #[cfg_attr(feature = "serde", serde(with = "serde_bytes"))]
    pub data: Vec<u8>,
    /// the program that owns this account. If executable, the program that loads this account.
    pub owner: Pubkey,
    /// this account's data contains a loaded program (and is now read-only)
    pub executable: bool,
    /// the epoch at which this account will next owe rent
    pub rent_epoch: Epoch,
}

import {
  airdropFactory,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  generateKeyPairSigner,
  lamports
} from "@solana/kit";

// Create a connection to Solana cluster
const rpc = createSolanaRpc("http://localhost:8899");
const rpcSubscriptions = createSolanaRpcSubscriptions("ws://localhost:8900");

// Generate a new keypair
const keypair = await generateKeyPairSigner();
console.log(`Public Key: ${keypair.address}`);

// Funding an address with SOL automatically creates an account
const signature = await airdropFactory({ rpc, rpcSubscriptions })({
  recipientAddress: keypair.address,
  lamports: lamports(1_000_000_000n),
  commitment: "confirmed"
});

const accountInfo = await rpc.getAccountInfo(keypair.address).send();
console.log(accountInfo);

import {
  airdropFactory,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  generateKeyPairSigner,
  lamports
} from "@solana/kit";

// Create a connection to Solana cluster
const rpc = createSolanaRpc("http://localhost:8899");
const rpcSubscriptions = createSolanaRpcSubscriptions("ws://localhost:8900");

// Generate a new keypair
const keypair = await generateKeyPairSigner();
console.log(`Public Key: ${keypair.address}`);

// Funding an address with SOL automatically creates an account
const signature = await airdropFactory({ rpc, rpcSubscriptions })({
  recipientAddress: keypair.address,
  lamports: lamports(1_000_000_000n),
  commitment: "confirmed"
});

const accountInfo = await rpc.getAccountInfo(keypair.address).send();
console.log(accountInfo);

Rent

Um Daten on-chain zu speichern, müssen Konten auch ein lamport (SOL) Guthaben halten, das proportional zur Menge der im Konto gespeicherten Daten (in Bytes) ist. Dieses Guthaben wird als "rent" bezeichnet, funktioniert aber eher wie eine Kaution, da Sie den vollen Betrag zurückerhalten können, wenn Sie ein Konto schließen. Die Berechnung finden Sie hier unter Verwendung dieser Konstanten.

Der Begriff "rent" stammt aus einem veralteten Mechanismus, der regelmäßig lamports von Konten abzog, die unter die Rent-Schwelle fielen. Dieser Mechanismus ist nicht mehr aktiv.

Programm-Eigentümer

Bei Solana werden "Smart Contracts" als Programme bezeichnet. Programm- Eigentümerschaft ist ein wesentlicher Bestandteil des Solana-Kontomodells. Jedes Konto hat ein bestimmtes Programm als Eigentümer. Nur das Eigentümerprogramm kann:

• Das dataFeld des Kontos ändern
• Lamports vom Kontoguthaben abziehen

System-Programm

Standardmäßig gehören alle neuen Konten dem System-Programm. Das System-Programm erfüllt einige wichtige Funktionen:

• Erstellung neuer Konten: Nur das System-Programm kann neue Konten erstellen.
• Speicherplatzzuweisung: Legt die Byte-Kapazität für das Datenfeld jedes Kontos fest.
• Übertragung / Zuweisung von Programm-Eigentümerschaft: Sobald das System-Programm ein Konto erstellt hat, kann es den festgelegten Programm-Eigentümer einem anderen Programmkonto zuweisen. So übernehmen benutzerdefinierte Programme die Eigentümerschaft neuer Konten, die vom System-Programm erstellt wurden.

Alle "Wallet"-Konten auf Solana sind einfach Konten, die dem System-Programm gehören. Das Lamport-Guthaben in diesen Konten zeigt die Menge an SOL, die der Wallet gehört. Nur Konten, die dem System-Programm gehören, können Transaktionsgebühren bezahlen.

Systemkonto

Sysvar-Konten

Sysvar-Konten sind spezielle Konten an vordefinierten Adressen, die Zugriff auf Cluster-Statusdaten bieten. Diese Konten werden dynamisch mit Daten über den Netzwerk-Cluster aktualisiert. Die vollständige Liste der Sysvar-Konten finden Sie hier.

import { Address, createSolanaRpc } from "@solana/kit";

const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");

const SYSVAR_CLOCK_ADDRESS =
  "SysvarC1ock11111111111111111111111111111111" as Address;

const accountInfo = await rpc
  .getAccountInfo(SYSVAR_CLOCK_ADDRESS, { encoding: "base64" })
  .send();
console.log(accountInfo);

import { Address, createSolanaRpc } from "@solana/kit";

const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");

const SYSVAR_CLOCK_ADDRESS =
  "SysvarC1ock11111111111111111111111111111111" as Address;

const accountInfo = await rpc
  .getAccountInfo(SYSVAR_CLOCK_ADDRESS, { encoding: "base64" })
  .send();
console.log(accountInfo);

Programmkonto

Die Bereitstellung eines Solana-Programms erstellt ein ausführbares Programmkonto. Das Programmkonto speichert den ausführbaren Code des Programms.

Programmkonten gehören einem Loader-Programm.

Programmkonto

Der Einfachheit halber können Sie das Programmkonto als das Programm selbst betrachten. Wenn Sie die Anweisungen eines Programms aufrufen, geben Sie die Adresse des Programmkontos an (allgemein als "Program ID" bezeichnet).

import { Address, createSolanaRpc } from "@solana/kit";

const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");

const programId = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address;

const accountInfo = await rpc
  .getAccountInfo(programId, { encoding: "base64" })
  .send();
console.log(accountInfo);

import { Address, createSolanaRpc } from "@solana/kit";

const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");

const programId = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address;

const accountInfo = await rpc
  .getAccountInfo(programId, { encoding: "base64" })
  .send();
console.log(accountInfo);

Pufferkonto

Loader-v3 verfügt über einen speziellen Kontotyp zum temporären Zwischenspeichern des Uploads eines Programms während der Bereitstellung oder Neubereitstellung/Upgrades. In loader-v4 gibt es immer noch Puffer, aber sie sind einfach normale Programmkonten.

Programmdatenkonto

Loader-v3 funktioniert anders als alle anderen BPF-Loader-Programme. Das Programmkonto enthält nur die Adresse eines Programmdatenkontos, das den eigentlichen ausführbaren Code speichert:

Programm-Datenkonto

Verwechseln Sie diese Programm-Datenkonten nicht mit den Datenkonten von Programmen (siehe unten).

Datenkonto

Bei Solana wird der ausführbare Code eines Programms in einem anderen Konto gespeichert als der Zustand des Programms. Dies ähnelt der Art und Weise, wie Betriebssysteme typischerweise separate Dateien für Programme und ihre Daten haben.

Um den Zustand zu verwalten, definieren Programme Anweisungen zum Erstellen separater Konten, die sie besitzen. Jedes dieser Konten hat seine eigene eindeutige Adresse und kann beliebige willkürliche Daten speichern, die vom Programm definiert werden.

Datenkonto

Beachten Sie, dass nur das System-Programm neue Konten erstellen kann. Sobald das System-Programm ein Konto erstellt hat, kann es dann die Eigentümerschaft des neuen Kontos an ein anderes Programm übertragen oder zuweisen.

Mit anderen Worten, die Erstellung eines Datenkontos für ein benutzerdefiniertes Programm erfolgt in zwei Schritten:

1. Rufen Sie das System-Programm auf, um ein Konto zu erstellen, und übertragen Sie dann die Eigentümerschaft an das benutzerdefinierte Programm
2. Rufen Sie das benutzerdefinierte Programm auf, das jetzt Eigentümer des Kontos ist, um die Kontodaten gemäß der vom Programm definierten Anweisung zu initialisieren

Dieser Kontoerstellungsprozess wird oft als ein einzelner Schritt abstrahiert, aber es ist hilfreich, den zugrundeliegenden Prozess zu verstehen.

import {
  airdropFactory,
  appendTransactionMessageInstructions,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  createTransactionMessage,
  generateKeyPairSigner,
  getSignatureFromTransaction,
  lamports,
  pipe,
  sendAndConfirmTransactionFactory,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  signTransactionMessageWithSigners
} from "@solana/kit";
import { getCreateAccountInstruction } from "@solana-program/system";
import {
  getInitializeMintInstruction,
  getMintSize,
  TOKEN_2022_PROGRAM_ADDRESS
} from "@solana-program/token-2022";

// Create Connection, local validator in this example
const rpc = createSolanaRpc("http://127.0.0.1:8899");
const rpcSubscriptions = createSolanaRpcSubscriptions("ws://localhost:8900");

// Generate keypairs for fee payer
const feePayer = await generateKeyPairSigner();

// Fund fee payer
await airdropFactory({ rpc, rpcSubscriptions })({
  recipientAddress: feePayer.address,
  lamports: lamports(1_000_000_000n),
  commitment: "confirmed"
});

// Generate keypair to use as address of mint
const mint = await generateKeyPairSigner();

// Get default mint account size (in bytes), no extensions enabled
const space = BigInt(getMintSize());

// Get minimum balance for rent exemption
const rent = await rpc.getMinimumBalanceForRentExemption(space).send();

// Instruction to create new account for mint (token 2022 program)
// Invokes the system program
const createAccountInstruction = getCreateAccountInstruction({
  payer: feePayer,
  newAccount: mint,
  lamports: rent,
  space,
  programAddress: TOKEN_2022_PROGRAM_ADDRESS
});

// Instruction to initialize mint account data
// Invokes the token 2022 program
const initializeMintInstruction = getInitializeMintInstruction({
  mint: mint.address,
  decimals: 9,
  mintAuthority: feePayer.address
});

const instructions = [createAccountInstruction, initializeMintInstruction];

// Get latest blockhash to include in transaction
const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

// Create transaction message
const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }), // Create transaction message
  (tx) => setTransactionMessageFeePayerSigner(feePayer, tx), // Set fee payer
  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), // Set transaction blockhash
  (tx) => appendTransactionMessageInstructions(instructions, tx) // Append instructions
);

// Sign transaction message with required signers (fee payer and mint keypair)
const signedTransaction =
  await signTransactionMessageWithSigners(transactionMessage);

// Send and confirm transaction
await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(
  signedTransaction,
  { commitment: "confirmed" }
);

// Get transaction signature
const transactionSignature = getSignatureFromTransaction(signedTransaction);

console.log("Mint Address:", mint.address);
console.log("Transaction Signature:", transactionSignature);

const accountInfo = await rpc.getAccountInfo(mint.address).send();
console.log(accountInfo);

import {
  airdropFactory,
  appendTransactionMessageInstructions,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  createTransactionMessage,
  generateKeyPairSigner,
  getSignatureFromTransaction,
  lamports,
  pipe,
  sendAndConfirmTransactionFactory,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  signTransactionMessageWithSigners
} from "@solana/kit";
import { getCreateAccountInstruction } from "@solana-program/system";
import {
  getInitializeMintInstruction,
  getMintSize,
  TOKEN_2022_PROGRAM_ADDRESS
} from "@solana-program/token-2022";

// Create Connection, local validator in this example
const rpc = createSolanaRpc("http://127.0.0.1:8899");
const rpcSubscriptions = createSolanaRpcSubscriptions("ws://localhost:8900");

// Generate keypairs for fee payer
const feePayer = await generateKeyPairSigner();

// Fund fee payer
await airdropFactory({ rpc, rpcSubscriptions })({
  recipientAddress: feePayer.address,
  lamports: lamports(1_000_000_000n),
  commitment: "confirmed"
});

// Generate keypair to use as address of mint
const mint = await generateKeyPairSigner();

// Get default mint account size (in bytes), no extensions enabled
const space = BigInt(getMintSize());

// Get minimum balance for rent exemption
const rent = await rpc.getMinimumBalanceForRentExemption(space).send();

// Instruction to create new account for mint (token 2022 program)
// Invokes the system program
const createAccountInstruction = getCreateAccountInstruction({
  payer: feePayer,
  newAccount: mint,
  lamports: rent,
  space,
  programAddress: TOKEN_2022_PROGRAM_ADDRESS
});

// Instruction to initialize mint account data
// Invokes the token 2022 program
const initializeMintInstruction = getInitializeMintInstruction({
  mint: mint.address,
  decimals: 9,
  mintAuthority: feePayer.address
});

const instructions = [createAccountInstruction, initializeMintInstruction];

// Get latest blockhash to include in transaction
const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

// Create transaction message
const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }), // Create transaction message
  (tx) => setTransactionMessageFeePayerSigner(feePayer, tx), // Set fee payer
  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), // Set transaction blockhash
  (tx) => appendTransactionMessageInstructions(instructions, tx) // Append instructions
);

// Sign transaction message with required signers (fee payer and mint keypair)
const signedTransaction =
  await signTransactionMessageWithSigners(transactionMessage);

// Send and confirm transaction
await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(
  signedTransaction,
  { commitment: "confirmed" }
);

// Get transaction signature
const transactionSignature = getSignatureFromTransaction(signedTransaction);

console.log("Mint Address:", mint.address);
console.log("Transaction Signature:", transactionSignature);

const accountInfo = await rpc.getAccountInfo(mint.address).send();
console.log(accountInfo);