Model kont Solana

W Solana wszystkie dane są przechowywane w tzw. "kontach". Możesz myśleć o danych w Solana jako o publicznej bazie danych z jedną tabelą "Konta", gdzie każdy rekord w tej tabeli to "konto". Każde konto Solana korzysta z tego samego podstawowego typu konta.

Konta

Kluczowe informacje

• Konta mogą przechowywać do 10MiB danych, które zawierają kod programu wykonywalnego lub stan programu.
• Konta wymagają depozytu rent w lamportach (SOL), który jest proporcjonalny do ilości przechowywanych danych, a można go w pełni odzyskać, zamykając konto.
• Każde konto ma programowego właściciela. Tylko program, który jest właścicielem konta, może zmieniać jego dane lub odejmować saldo w lamportach. Jednak każdy może zwiększyć saldo.
• Konta Sysvar to specjalne konta przechowujące stan klastra sieci.
• Konta programowe przechowują kod wykonywalny smart kontraktów.
• Konta danych są tworzone przez programy w celu przechowywania i zarządzania stanem programu.

Konto

Każde konto w Solana ma unikalny 32-bajtowy adres, często przedstawiany jako ciąg zakodowany w base58 (np. 14grJpemFaf88c8tiVb77W7TYg2W3ir6pfkKz3YjhhZ5).

Relacja między kontem a jego adresem działa jak para klucz-wartość, gdzie adres jest kluczem do zlokalizowania odpowiadających danych on-chain konta. Adres konta działa jako "unikalny identyfikator" dla każdego rekordu w tabeli "Konta".

Adres konta

Większość kont Solana używa klucza publicznego Ed25519 jako swojego adresu.

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

Chociaż klucze publiczne są powszechnie używane jako adresy kont, Solana obsługuje również funkcję o nazwie Program Derived Addresses (PDAs). PDAs to specjalne adresy, które można deterministycznie wyprowadzić z identyfikatora programu i opcjonalnych danych wejściowych (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}`);

Typ konta

Konta mają maksymalny rozmiar 10MiB i każde konto na Solana korzysta z tego samego podstawowego typu konta.

Typ konta

Każde konto na Solana posiada następujące pola.

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

Aby przechowywać dane w łańcuchu bloków, konta muszą utrzymywać saldo lamportów (SOL) proporcjonalne do ilości danych przechowywanych na koncie (w bajtach). To saldo nazywane jest "rent", ale działa bardziej jak depozyt, ponieważ można odzyskać pełną kwotę po zamknięciu konta. Obliczenia można znaleźć tutaj z użyciem tych stałych.

Termin "rent" pochodzi z przestarzałego mechanizmu, który regularnie potrącał lamporty z kont, które spadły poniżej progu rent. Mechanizm ten nie jest już aktywny.

Właściciel programu

Na Solanie "inteligentne kontrakty" nazywane są programami. Własność programu jest kluczowym elementem modelu kont Solany. Każde konto ma przypisany program jako właściciela. Tylko program-właściciel może:

• Zmienić pole data konta
• Potrącić lamporty z salda konta

Każdy program definiuje strukturę danych przechowywanych w polu data konta. Instrukcje programu określają, jak te dane oraz saldo konta lamports mogą być zmieniane.

System Program

Domyślnie wszystkie nowe konta są przypisane do System Program. System Program wykonuje następujące kluczowe funkcje:

Zwróć uwagę, że wszystkie konta "portfela" na Solanie to "Konta Systemowe" należące do System Program. Saldo lamportów na tych kontach pokazuje ilość SOL należących do portfela. Tylko Konta Systemowe mogą opłacać opłaty transakcyjne.

Konto Systemowe

Gdy SOL jest wysyłany na nowy adres po raz pierwszy, konto jest automatycznie tworzone na tym adresie i należy do System Program.

W poniższym przykładzie generowany jest nowy keypair i zasilany SOL. Uruchom kod, aby zobaczyć wynik. Zwróć uwagę, że pole owner konta to System Program z adresem 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);

Konta Sysvar

Konta Sysvar to specjalne konta o z góry określonych adresach, które zapewniają dostęp do danych o stanie klastra. Te konta są dynamicznie aktualizowane danymi o sieci klastrowej. Pełną listę Kont Sysvar można znaleźć tutaj.

Poniższy przykład pokazuje, jak pobrać i deserializować dane z konta Sysvar 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);

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

Konto Programu

Wdrożenie programu Solana tworzy konto programu wykonawczego. Konto programu przechowuje kod wykonywalny programu. Konta programów są własnością Loader Program.

Konto Programu

Dla uproszczenia możesz traktować konto programu jako sam program. Gdy wywołujesz instrukcje programu, określasz adres konta programu (często nazywany "Program ID").

Poniższy przykład pobiera konto Token Program, aby pokazać, że konta programów mają ten sam podstawowy typ Account, z wyjątkiem pola executable, które jest ustawione na true. Ponieważ konta programów zawierają kod wykonywalny w swoim polu danych, nie deserializujemy tych danych.

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

Konto bufora

Loader-v3 ma specjalny typ konta do tymczasowego przechowywania programu podczas deplymentu lub aktualizacji. W loader-v4 nadal istnieją bufory, ale są to zwykłe konta programów.

Konto danych programu

Loader-v3 działa inaczej niż wszystkie inne programy BPF Loader. Konto programu zawiera jedynie adres konta danych programu, które przechowuje rzeczywisty kod wykonywalny:

Konto danych programu

Nie myl tych kont danych programu z kontami danych programów (patrz poniżej).

Konto danych

Na Solanie kod wykonywalny programu jest przechowywany na innym koncie niż stan programu. Jest to podobne do tego, jak systemy operacyjne zazwyczaj mają oddzielne pliki dla programów i ich danych.

Aby utrzymać stan, programy definiują instrukcje do tworzenia oddzielnych kont, które są ich własnością. Każde z tych kont ma swój unikalny adres i może przechowywać dowolne dane zdefiniowane przez program.

Konto danych

Zauważ, że tylko System Program może tworzyć nowe konta. Po utworzeniu konta przez System Program, może ono przypisać własność nowego konta innemu programowi.

Innymi słowy, utworzenie konta danych dla niestandardowego programu wymaga dwóch kroków:

1. Wywołanie System Program w celu utworzenia konta, a następnie przeniesienie własności na niestandardowy program
2. Wywołanie niestandardowego programu, który teraz jest właścicielem konta, w celu zainicjowania danych konta zgodnie z instrukcją programu

Proces tworzenia konta jest często uproszczony do jednego kroku, ale warto zrozumieć proces leżący u jego podstaw.

Poniższy przykład pokazuje, jak utworzyć i pobrać konto Token Mint będące własnością programu Token 2022.

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