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 za przechowywanie 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 zmniejszać saldo lamportów. 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 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ę nazwaną 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 Solanie korzysta z tego samego podstawowego typu konta.

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 niebędących programami często przechowuje stan, który ma być odczytywany. W przypadku kont programów (smart contracts) zawiera kod wykonywalny programu. Pole danych jest często nazywane "danymi konta".
• executable: Flaga wskazująca, 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ć saldo lamportów.
• 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 (rent) 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);

Rent

Aby przechowywać dane on-chain, konta muszą również 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 przy użyciu tych stałych.

Termin "rent" pochodzi z przestarzałego mechanizmu, który regularnie odejmował lamporty z kont, które spadły poniżej progu rent. Ten mechanizm nie jest już aktywny.

Właściciel programu

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

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

Program Systemowy

Domyślnie wszystkie nowe konta są przypisane do Programu Systemowego. Program Systemowy wykonuje kilka kluczowych funkcji:

• Tworzenie nowych kont: Tylko Program Systemowy może tworzyć nowe konta.
• Przydział przestrzeni: Ustawia pojemność w bajtach dla pola danych każdego konta.
• Transfer / Przypisanie własności programu: Po utworzeniu konta przez Program Systemowy, 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 Program Systemowy.

Wszystkie konta "portfela" na Solanie to po prostu konta przypisane do Programu Systemowego. Saldo lamportów na tych kontach pokazuje ilość SOL posiadanych przez portfel. Tylko konta przypisane do Programu Systemowego 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 można znaleźć 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);

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żna 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 bufory nadal istnieją, 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 kod wykonywalny:

Konto danych programu

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

Konto danych

Na Solanie kod wykonywalny programu jest przechowywany w 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. 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);