Solana accountmodel

Op Solana wordt alle data opgeslagen in wat "accounts" worden genoemd. Je kunt data op Solana zien als een openbare database met een enkele "Accounts"-tabel, waarbij elke invoer in deze tabel een "account" is. Elk Solana-account deelt hetzelfde basis Account type.

Accounts

Belangrijke punten

• Accounts kunnen maximaal 10MiB aan data opslaan, die ofwel uitvoerbare programmacode of programmastatus bevat.
• Accounts vereisen een rent deposit in lamports (SOL) dat evenredig is aan de hoeveelheid opgeslagen data, en je kunt het volledig terugkrijgen wanneer je het account sluit.
• Elk account heeft een programma owner. Alleen het programma dat eigenaar is van een account kan de data wijzigen of het lamport-saldo verminderen. Maar iedereen kan het saldo verhogen.
• Sysvar accounts zijn speciale accounts die de netwerkclusterstatus opslaan.
• Program accounts slaan de uitvoerbare code van smart contracts op.
• Data accounts worden gemaakt door programma's om programmastatus op te slaan en te beheren.

Account

Elk account op Solana heeft een uniek 32-byte adres, vaak weergegeven als een base58 gecodeerde string (bijv. vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg).

De relatie tussen het account en zijn adres werkt als een sleutel-waarde paar, waarbij het adres de sleutel is om de bijbehorende on-chain data van het account te lokaliseren. Het accountadres fungeert als de "unieke ID" voor elke invoer in de "Accounts"-tabel.

Account Adres

De meeste Solana-accounts gebruiken een Ed25519 publieke sleutel als hun adres.

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

Hoewel publieke sleutels vaak worden gebruikt als account-adressen, ondersteunt Solana ook een functie genaamd Program Derived Addresses (PDA's). PDA's zijn speciale adressen die je deterministisch kunt afleiden van een programma-ID en optionele inputs (seeds).

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

Account type

Accounts hebben een maximale grootte van 10MiB en elk account op Solana deelt hetzelfde basis Account type.

Account Type

Elk account op Solana heeft de volgende velden.

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,
}

pub struct Account {
    /// lamports in the account
    pub lamports: u64,
}

// Example Token Mint Account
Account {
    lamports: 1461600,
}

// Example Token Program Account
Account {
    lamports: 4513200894,
}

Rent

Om gegevens on-chain op te slaan, moeten accounts ook een lamport (SOL) saldo aanhouden dat evenredig is aan de hoeveelheid opgeslagen gegevens op het account (in bytes). Dit saldo wordt "rent" genoemd, maar het werkt meer als een borg omdat je het volledige bedrag kunt terugkrijgen wanneer je een account sluit. Je kunt de berekening hier vinden met deze constanten.

De term "rent" komt van een verouderd mechanisme dat regelmatig lamports aftrok van accounts die onder de rent-drempel vielen. Dit mechanisme is niet langer actief.

Programma-eigenaar

Op Solana worden "smart contracts" programma's genoemd. Programma- eigendom is een essentieel onderdeel van het Solana Account Model. Elk account heeft een aangewezen programma als eigenaar. Alleen het eigenaarsprogramma kan:

• Het data veld van het account wijzigen
• Lamports aftrekken van het saldo van het account

Elk programma definieert de structuur van de gegevens die zijn opgeslagen in het data veld van een account. De instructies van het programma bepalen hoe deze gegevens en het lamports saldo van het account kunnen worden gewijzigd.

System Program

Standaard zijn alle nieuwe accounts eigendom van het System Program. Het System Program voert de volgende belangrijke functies uit:

Merk op dat alle "wallet" accounts op Solana "System Accounts" zijn die eigendom zijn van het System Program. Het lamport saldo in deze accounts toont de hoeveelheid SOL die de wallet bezit. Alleen System Accounts kunnen transactiekosten betalen.

System Account

Wanneer SOL voor het eerst naar een nieuw adres wordt verzonden, wordt er automatisch een account aangemaakt op dat adres dat eigendom is van het System Program.

In het onderstaande voorbeeld wordt een nieuw keypair gegenereerd en gefinancierd met SOL. Voer de code uit om de uitvoer te zien. Merk op dat het veld owner van het account het System Program is met het adres 11111111111111111111111111111111.

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

Sysvar accounts

Sysvar accounts zijn speciale accounts op vooraf gedefinieerde adressen die toegang bieden tot cluster statusgegevens. Deze accounts worden dynamisch bijgewerkt met gegevens over het netwerkcluster. Je kunt de volledige lijst van Sysvar Accounts hier vinden.

Het volgende voorbeeld laat zien hoe je de gegevens van het Sysvar Clock account kunt ophalen en deserialiseren.

import { createSolanaRpc } from "@solana/kit";
import { fetchSysvarClock, SYSVAR_CLOCK_ADDRESS } from "@solana/sysvars";

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

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

// Automatically fetch and deserialize the account data
const clock = await fetchSysvarClock(rpc);
console.log(clock);

import { createSolanaRpc } from "@solana/kit";
import { fetchSysvarClock, SYSVAR_CLOCK_ADDRESS } from "@solana/sysvars";

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

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

// Automatically fetch and deserialize the account data
const clock = await fetchSysvarClock(rpc);
console.log(clock);

Program account

Het implementeren van een Solana-programma creëert een uitvoerbaar program account. Het program account slaat de uitvoerbare code van het programma op. Program accounts zijn eigendom van een Loader Program.

Program Account

Voor de eenvoud kun je het program account behandelen als het programma zelf. Wanneer je de instructies van een programma aanroept, specificeer je het adres van het program account (algemeen bekend als de "Program ID").

Het volgende voorbeeld haalt het Token Program account op om te laten zien dat program accounts hetzelfde basis Account type hebben, behalve dat het veld executable is ingesteld op true. Omdat program accounts uitvoerbare code in hun gegevensveld bevatten, deserialiseren we de gegevens niet.

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

Buffer-account

Loader-v3 heeft een speciaal accounttype voor het tijdelijk opslaan van een programma tijdens implementatie of upgrades. In loader-v4 zijn er nog steeds buffers, maar dit zijn gewoon normale program accounts.

Program data account

Loader-v3 werkt anders dan alle andere BPF Loader-programma's. Het program account bevat alleen het adres van een program data account, dat de daadwerkelijke uitvoerbare code opslaat:

Program Data Account

Verwar deze program data accounts niet met de data accounts van programma's (zie hieronder).

Data-account

Op Solana wordt de uitvoerbare code van een programma opgeslagen in een ander account dan de status van het programma. Dit is vergelijkbaar met hoe besturingssystemen doorgaans aparte bestanden hebben voor programma's en hun gegevens.

Om de status bij te houden, definiëren programma's instructies om aparte accounts te maken die ze bezitten. Elk van deze accounts heeft zijn eigen unieke adres en kan willekeurige gegevens opslaan die door het programma zijn gedefinieerd.

Data Account

Merk op dat alleen het System Program nieuwe accounts kan aanmaken. Zodra het System Program een account heeft aangemaakt, kan het vervolgens het eigendom van het nieuwe account toewijzen aan een ander programma.

Met andere woorden, het creëren van een data-account voor een aangepast programma bestaat uit twee stappen:

1. Roep het System Program aan om een account te maken en draag vervolgens het eigendom over aan het aangepaste programma
2. Roep het aangepaste programma aan, dat nu eigenaar is van het account, om de accountgegevens te initialiseren zoals gedefinieerd door de instructie van het programma

Dit proces van accountcreatie wordt vaak geabstraheerd als een enkele stap, maar het is nuttig om het onderliggende proces te begrijpen.

Het volgende voorbeeld laat zien hoe je een Token Mint-account kunt maken en ophalen dat eigendom is van het Token 2022-programma.

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,
  fetchMint
} from "@solana-program/token-2022";

// Create Connection, local validator in this example
const rpc = createSolanaRpc("http://localhost: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);

const mintAccount = await fetchMint(rpc, mint.address);
console.log(mintAccount);

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,
  fetchMint
} from "@solana-program/token-2022";

// Create Connection, local validator in this example
const rpc = createSolanaRpc("http://localhost: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);

const mintAccount = await fetchMint(rpc, mint.address);
console.log(mintAccount);