Account 확인하기

Account 확인하기 에서는 우리의 Program이 소유하는 Account를 하나 생성하고, Account가 생성됐는지 확인해보겠습니다.Account가 생성된 것인지 아닌지에 대해 확인하기 위해, Client에서 생성할 Account와 이미 생성한 Account 두 개의 키쌍을 Instruction으로 보낼 것입니다. 이 "생성한" Account 하나는 Client에서 미리 SystemProgram에 생성을 요청하고, 다른 하나의 Account는 생성을 요청하지 않는 키쌍입니다. Server Program은 이 두 개의 Account에 대해 몇 가지 확인하는 작업을 갖고 있습니다. 두 Account의 상태가 어떻게 다른지 알아봅시다.

빌드와 배포 등 기본적인 내용은 Hello Solana를 참고해주세요.

프로그램 구조

Client Program이 요청하는 Transaction은 두 가지입니다.

• System Program에 Account_A의 생성을 요청하는 Transaction
• Server Program에 Account_A와 Account_B에 대한 확인을 요청하는 Transaction

위 이미지에서 볼 수 있듯이 Server Program은 넘어온 Account들에 대해 여러가지 검증 작업을 수행합니다.

Native 프로그래밍

Native 프로그래밍을 먼저 살펴봅시다.

Server Program

 1use solana_program::{
 2    account_info::{ AccountInfo, next_account_info },
 3    entrypoint,
 4    entrypoint::ProgramResult,
 5    msg,
 6    program_error::ProgramError,
 7    pubkey::Pubkey,
 8    system_program,
 9};
10
11entrypoint!(process_instruction);
12
13fn process_instruction(
14    program_id: &Pubkey,
15    accounts: &[AccountInfo],
16    _instruction_data: &[u8],
17) -> ProgramResult {
18
19    // instruction으로 들어온 Program ID 값이 이 프로그램이 맞는지 확인
20    if system_program::check_id(program_id) {
21        return Err(ProgramError::IncorrectProgramId)
22    };
23
24    if accounts.len() < 4 {
25        msg!("Instruction은 4개의 인자가 필요합니다 :");
26        msg!(" payer, account_to_create, account_to_change, system_program");
27        return Err(ProgramError::NotEnoughAccountKeys)
28    };
29
30    // vec에 담겨져 넘어온 Account들은 프로그램이 정한 순서대로 넘겨야 합니다.
31    let accounts_iter = &mut accounts.iter();
32    let _payer = next_account_info(accounts_iter)?;
33    let account_to_create = next_account_info(accounts_iter)?;
34    let account_to_change = next_account_info(accounts_iter)?;
35    let system_program = next_account_info(accounts_iter)?;
36
37    // 새로 생성할 Account 초기화 검증
38    msg!("새로운 Account: {}", account_to_create.key);
39    if account_to_create.lamports() != 0 {
40        msg!("생성할 Account가 이미 초기화 됬습니다.");
41        return Err(ProgramError::AccountAlreadyInitialized)
42    };
43    // Create Account...
44
45    // 변경할 Account가 초기화 됐는지 검증
46    msg!("변경할 Account: {}", account_to_change.key);
47    if account_to_change.lamports() == 0 {
48        msg!("변경할 Account가 초기화되지 않았습니다.");
49        return Err(ProgramError::UninitializedAccount)
50    };
51
52    // 변경할 Account가 현재 프로그램이 소유한 Account가 맞는지 검증
53    if account_to_change.owner != program_id {
54        msg!("변경할 account의 소유자가 현재 프로그램이 아닙니다.");
55        return Err(ProgramError::IncorrectProgramId)
56    };
57
58    // System Program을 알맞게 보냈는지 검증
59    if system_program.key != &system_program::ID {
60        return Err(ProgramError::IncorrectProgramId)
61    };
62
63    Ok(())
64}

• system_program::check_id(program_id)
  -> 현재 ProgramId가 맞는지 검증.
• account_to_create.lamports()
  -> lamports가 0이 아니면 이미 초기화된 것입니다.
• account_to_change.lamports()
  -> 여기서 account_to_change는 Client에서 미리 System_Program에 생성 요청한 Account입니다.
• account_to_change.owner != program_id
  -> Program이 특정 Account를 변경하기 위해서는 그 Account를 소유하고 있어야 합니다.
• system_program.key != &system_program::ID
  -> 넘어온 System Program의 ID 값이 올바른지 검증합니다. System Program ID 값은 solana native 라이브러리에 상수로 정의되어 있습니다.

Client Program

 1import {
 2    Connection,
 3    Keypair,
 4    PublicKey,
 5    sendAndConfirmTransaction,
 6    SystemProgram,
 7    Transaction,
 8    TransactionInstruction,
 9} from '@solana/web3.js';
10
11function createKeypairFromFile(path: string): Keypair {
12    return Keypair.fromSecretKey(
13        Buffer.from(JSON.parse(require('fs').readFileSync(path, "utf-8")))
14    )
15};
16
17describe("Checking accounts", async () => {
18    const connection = new Connection(`http://127.0.0.1:8899`, 'confirmed');
19    const payer = createKeypairFromFile(require('os').homedir() + '/.config/solana/id.json');
20
21    const PROGRAM_ID: PublicKey = new PublicKey("3hgMHgz4Ht5AdY3a8pHDw63GKb879r7c2wbZ7TjrGCT4");
22
23    // System Program에 생성을 요창하고, 우리 프로그램이 수정할 Account
24    const accountToChange = Keypair.generate();
25    // 우리 프로그램이 생성할 Account
26    const accountToCreate = Keypair.generate();
27
28    it("Create an account owned by our program", async () => {
29
30        let ix = SystemProgram.createAccount({
31            fromPubkey: payer.publicKey,
32            newAccountPubkey: accountToChange.publicKey,
33            lamports: await connection.getMinimumBalanceForRentExemption(0),
34            space: 0,
35            programId: PROGRAM_ID,
36        });
37
38        await sendAndConfirmTransaction(
39            connection, 
40            new Transaction().add(ix),
41            [payer, accountToChange]
42        );
43    });
44
45    it("Check accounts", async () => {
46        let ix = new TransactionInstruction({
47            keys: [
48                {pubkey: payer.publicKey, isSigner: true, isWritable: true},
49                {pubkey: accountToCreate.publicKey, isSigner: true, isWritable: true},
50                {pubkey: accountToChange.publicKey, isSigner: true, isWritable: true},
51                {pubkey: SystemProgram.programId, isSigner: false, isWritable: false}
52            ],
53            programId: PROGRAM_ID,
54            data: Buffer.alloc(0),
55        });
56
57        await sendAndConfirmTransaction(
58            connection,
59            new Transaction().add(ix),
60            [payer, accountToCreate, accountToChange]
61        )
62    });
63});

앞서 설명했듯이, Client는 두 개의 Keypair(Account)를 생성하고, 두 개의 Transaction을 보냅니다.

1. System Program에 Account_A 생성 요청.
   -> fromPubkey : 이 Instruction에 비용을 지불하는 payer
   -> newAccountPubkey : 새로 생성할 Account의 pubkey
   -> lamports : 새로 생성할 Account에 보낼 lamports
   -> space : 새로 생성할 Account에 할당할 바이트 단위 공간
   -> programId : 새로 생성할 Account를 소유할 ProgramId
2. Server Program에 Account_A, Account_B 확인 요청
   -> keys : payer, Account_A, Account_B, System Program ID 네 개의 Account
   -> programId : Server Program ID
   -> data : 0

Test

테스트 결과 System Program에 Account 생성을 요청하는 Transaction과 Server Program에 Account 확인을 요청하는 Transaction 모두 성공한 것을 볼 수 있습니다.

Transaction logs에서도 두 개의 Transaction이 성공한 것을 볼 수 있습니다. Program ID로 나타나는 "11111111111111111111111111111111"은 System Program을 의미하고, "3hgMHgz4Ht5AdY3a8pHDw63GKb879r7c2wbZ7TjrGCT4"는 Server Program을 의미합니다.

Anchor 프로그래밍

다음은 Anchor 프로그래밍을 살펴봅시다.

Server Program

 1use anchor_lang::prelude::*;
 2
 3declare_id!("DYPmxWtKT24YyH2oKQ41ukNAtU6KVRpiYmCNnzzyW7jo");
 4
 5#[program]
 6pub mod checking_account {
 7    use super::*;
 8
 9    pub fn check_accounts(_ctx: Context<CheckingAccounts>) -> Result<()> {
10
11        Ok(())
12    }
13}
14
15#[derive(Accounts)]
16pub struct CheckingAccounts<'info> {
17    payer: Signer<'info>,
18    /// CHECK: 이 Account의 데이터는 비어있습니다.
19    #[account(mut)]
20    account_to_create: AccountInfo<'info>,
21    /// CHECK: 이 Account의 데이터는 비어있습니다.
22    #[account(mut)]
23    account_to_change: AccountInfo<'info>,
24    system_program: Program<'info, System>,
25}

Server Program의 코드를 보면 Native 프로그래밍의 코드와 많이 다른 것을 알 수 있습니다. 특히 앞서 설명했던 검증 절차들이 보이지 않습니다. 이는 Anchor가 Client로부터 받은 Account들을 우리가 정의한 CheckingAccounts 타입에 바인딩하면서 기본적인 검증 처리를 자동으로 해주기 때문입니다.

1. CheckingAccounts
   -> payer: Signer 타입으로 이 Account가 서명했는지 검증합니다
   -> account_to_create: AccountInfo 타입으로 Client에서 생성한 Account
   -> account_to_change: AccountInfo 타입으로 Client에서 생성해 System Program으로 생성 요청했던 Account
   -> system_program: Program 타입으로 Client에서 보낸 System Program의 Account

AccountInfo 타입과 UncheckedAccount 타입은 다른 타입과 달리 넘어온 Account에 대해 어떤 확인도 하지 않습니다. 이 타입을 사용할 때는 Rust의 "///" 또는 "/**" doc comment를 사용해서 이 Account가 안전하다는 것을 표시해줘야 합니다. 위 코드에서 "///" 주석을 제거해 보면 컴파일 에러가 발생하는 것을 확인할 수 있습니다.

Client Program

 1import * as anchor from "@project-serum/anchor";
 2import { Program } from "@project-serum/anchor";
 3import { CheckingAccount } from "../target/types/checking_account";
 4
 5describe("checking-account", () => {
 6
 7  const provider = anchor.AnchorProvider.env();
 8  anchor.setProvider(provider);
 9
10  const program = anchor.workspace.CheckingAccount as Program<CheckingAccount>;
11  const payer = provider.wallet as anchor.Wallet;
12
13  const accountToChange = anchor.web3.Keypair.generate();
14  const accountToCreate = anchor.web3.Keypair.generate();
15
16  it("Create an account owned by our program", async () => {
17
18    let ix = anchor.web3.SystemProgram.createAccount({
19      fromPubkey: provider.wallet.publicKey,
20      newAccountPubkey: accountToChange.publicKey,
21      lamports: await provider.connection.getMinimumBalanceForRentExemption(0),
22      space: 0,
23      programId: program.programId,
24    });
25
26    await anchor.web3.sendAndConfirmTransaction(
27      provider.connection,
28      new anchor.web3.Transaction().add(ix),
29      [payer.payer, accountToChange]
30    );
31  });
32
33  it("Check accounts", async () => {
34
35    await program.methods.checkAccounts()
36      .accounts({
37        payer: payer.publicKey,
38        accountToCreate: accountToCreate.publicKey,
39        accountToChange: accountToChange.publicKey,
40        systemProgram: anchor.web3.SystemProgram.programId,
41      })
42      .signers([payer.payer])
43      .rpc();
44
45  });
46});

Client Program의 코드에서 System Program에 생성을 요청하는 코드는 Native 프로그램과 거의 같은 같습니다. 위 코드 "Check accounts"에서 Server Program에 Account 확인을 요청하는 절차가 Native Program과 다릅니다.

Anchor 프로그래밍의 Server Program을 빌드하면 자동으로 ts 파일이 생성되는데, Client Program은 이 ts 파일을 사용합니다. 여기서는 checking_account.ts 파일 입니다.

• .methods.checkAccounts()
  -> Server Program에서 정의한 check_accounts 함수로 camelCase로 변환되어 만들어집니다.
• .accounts()
  -> 앞서 설명한 4개의 Account들
• .signers()
  -> 서명자
• .rpc()
  -> rpc 호출

Test

References

• https://github.com/solana-developers/program-examples