Model kont na Solanie

Na Solanie wszystkie dane są przechowywane w tzw. "kontach". Możesz myśleć o danych na Solanie jak o publicznej bazie danych z jedną tabelą "Konta", gdzie każdy rekord w tej tabeli to "konto". Każde konto na Solanie 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 pełny zwrot depozytu jest możliwy po zamknięciu konta.
• Każde konto ma programowego właściciela. Tylko program będący 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 sieciowego.
• 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 na Solanie 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 jak "unikalny identyfikator" dla każdego wpisu 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ę zwaną Program Derived Addresses (PDA). PDA 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 Solanie korzysta z tego samego podstawowego typu Account.

Typ konta

Każde konto na Solanie zawiera następujące pola:

• data: Tablica bajtów przechowująca dowolne dane dla konta. W przypadku kont nieegzekwowalnych często przechowuje stan, który ma być odczytywany. W przypadku kont programowych (smart contracts) zawiera wykonywalny kod programu. Pole danych jest często nazywane "danymi konta".
• executable: Ten znacznik wskazuje, czy konto jest programem.
• lamports: Saldo konta w lamportach, najmniejszej jednostce SOL (1 SOL = 1 miliard lamportów).
• owner: Identyfikator programu (klucz publiczny) programu, który jest właścicielem tego konta. Tylko program właściciela może zmieniać dane konta lub odejmować jego saldo w lamportach.
• rent_epoch: Pole dziedzictwa z czasów, gdy Solana miała mechanizm okresowego odejmowania lamportów z kont. Chociaż to pole nadal istnieje w typie konta, nie jest już używane, ponieważ pobieranie opłat za przechowywanie zostało wycofane.

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

Opłata za przechowywanie

Aby przechowywać dane w łańcuchu, konta muszą również utrzymywać saldo lamportów (SOL), które jest proporcjonalne do ilości danych przechowywanych na koncie (w bajtach). To saldo nazywane jest "rentem", ale działa bardziej jak depozyt, ponieważ można odzyskać całą 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 odejmował lamporty z kont, które spadały poniżej progu rentu. Ten mechanizm nie jest już aktywny.

Właściciel programu

Na Solanie "smart 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:

• Zmieniać pole data konta
• Odejmować lamporty z salda konta

System Program

Domyślnie wszystkie nowe konta są przypisane do System Program. System Program wykonuje kilka kluczowych zadań:

• Tworzenie nowych kont: Tylko System Program może tworzyć nowe konta.
• Alokacja przestrzeni: Ustawia pojemność w bajtach dla pola danych każdego konta.
• Transfer / przypisanie własności programu: Po utworzeniu konta przez System Program, może on przypisać właściciela programu do innego konta programu. W ten sposób niestandardowe programy przejmują własność nowych kont utworzonych przez System Program.

Wszystkie konta "portfela" na Solanie to po prostu konta przypisane do System Program. Saldo lamportów na tych kontach pokazuje ilość SOL posiadaną przez portfel. Tylko konta przypisane do System Program mogą płacić opłaty transakcyjne.

Konto systemowe

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 o dane dotyczące klastra sieciowego. Pełną listę kont Sysvar znajdziesz tutaj.

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

Program Account

Wdrożenie programu Solana tworzy wykonywalne konto programu. Konto programu przechowuje wykonywalny kod 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").

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 wdrażania lub ponownego wdrażania/aktualizacji. W loader-v4 nadal istnieją bufory, ale są to po prostu 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 wykonywalny kod:

Konto danych programu

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

Konto danych

W Solanie kod wykonywalny programu jest przechowywany w innym koncie niż stan programu. 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. Gdy System Program utworzy konto, może następnie przekazać lub przypisać własność nowego konta innemu programowi.

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

1. Wywołanie System Program w celu utworzenia konta, a następnie przekazanie własności niestandardowemu programowi
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 abstrakcyjny jako pojedynczy krok, ale warto zrozumieć proces leżący u jego podstaw.

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