มาลองหัดเขียน Smart Contract บน Solana กัน ด้วยแอพ Hello World

1
[package]
2
name = "solana-helloworld"
3
version = "0.1.0"
4
edition = "2021"
5

6
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
7

8
[features]
9
no-entrypoint = []
10

11
[dependencies]
12
borsh = "0.9.3"
13
borsh-derive = "0.9.3"
14
solana-program = "=1.10.6"
15

16
[lib]
17
name = "solana_helloworld"
18
crate-type = ["cdylib", "lib"]

1
use borsh::{BorshDeserialize, BorshSerialize};
2
use solana_program::{
3
    account_info::{next_account_info, AccountInfo},
4
    entrypoint,
5
    entrypoint::ProgramResult,
6
    msg,
7
    program_error::ProgramError,
8
    pubkey::Pubkey,
9
};
10

11
/// Define the type of state stored in accounts
12
#[derive(BorshSerialize, BorshDeserialize, Debug)]
13
pub struct GreetingAccount {
14
    /// number of greetings
15
    pub counter: u32,
16
}
17

18
// Declare and export the program's entrypoint
19
entrypoint!(process_instruction);
20

21
// Program entrypoint's implementation
22
pub fn process_instruction(
23
    program_id: &Pubkey, // Public key of the account the hello world program was loaded into
24
    accounts: &[AccountInfo], // The account to say hello to
25
    _instruction_data: &[u8], // Ignored, all helloworld instructions are hellos
26
) -> ProgramResult {
27
    msg!("Hello World Rust program entrypoint");
28

29
    // Iterating accounts is safer than indexing
30
    let accounts_iter = &mut accounts.iter();
31

32
    // Get the account to say hello to
33
    let account = next_account_info(accounts_iter)?;
34

35
    // The account must be owned by the program in order to modify its data
36
    if account.owner != program_id {
37
        msg!("Greeted account does not have the correct program id");
38
        return Err(ProgramError::IncorrectProgramId);
39
    }
40

41
    // Increment and store the number of times the account has been greeted
42
    let mut greeting_account = GreetingAccount::try_from_slice(&account.data.borrow())?;
43
    greeting_account.counter += 1;
44
    greeting_account.serialize(&mut &mut account.data.borrow_mut()[..])?;
45

46
    msg!("Greeted {} time(s)!", greeting_account.counter);
47

48
    Ok(())
49
}

1
{
2
  "name": "solana-helloworld",
3
  "version": "1.0.0",
4
  "main": "index.js",
5
  "author": "Chai Phonbopit",
6
  "license": "MIT",
7
  "dependencies": {
8
    "@solana/web3.js": "1.37.1",
9
    "borsh": "0.7.0",
10
    "yaml": "2.0.0"
11
  },
12
  "devDependencies": {
13
    "@tsconfig/recommended": "1.0.1",
14
    "@types/yaml": "1.9.7",
15
    "ts-node": "10.7.0",
16
    "typescript": "4.6.3"
17
  }
18
}

1
{
2
  "extends": "@tsconfig/recommended/tsconfig.json",
3
  "ts-node": {
4
    "compilerOptions": {
5
      "module": "commonjs"
6
    }
7
  },
8
  "compilerOptions": {
9
    "declaration": true,
10
    "moduleResolution": "node",
11
    "module": "es2015"
12
  },
13
  "include": ["src/**/*"],
14
  "exclude": ["node_modules"]
15
}

1
import {
2
  establishConnection,
3
  establishPayer,
4
  checkProgram,
5
  sayHello,
6
  reportGreetings
7
} from './hello_world'
8

9
async function main() {
10
  console.log("Let's say hello to a Solana account...")
11

12
  // Establish connection to the cluster
13
  await establishConnection()
14

15
  // Determine who pays for the fees
16
  await establishPayer()
17

18
  // Check if the program has been deployed
19
  await checkProgram()
20

21
  // Say hello to an account
22
  await sayHello()
23

24
  // Find out how many times that account has been greeted
25
  await reportGreetings()
26

27
  console.log('Success')
28
}
29

30
main().then(
31
  () => process.exit(),
32
  (err) => {
33
    console.error(err)
34
    process.exit(-1)
35
  }
36
)

1
import os from 'os'
2
import fs from 'fs/promises'
3

4
import path from 'path'
5
import yaml from 'yaml'
6
import { Keypair } from '@solana/web3.js'
7

8
/**
9
 * @private
10
 */
11
async function getConfig(): Promise<any> {
12
  // Path to Solana CLI config file
13
  const CONFIG_FILE_PATH = path.resolve(os.homedir(), '.config', 'solana', 'cli', 'config.yml')
14
  const configYml = await fs.readFile(CONFIG_FILE_PATH, { encoding: 'utf8' })
15
  return yaml.parse(configYml)
16
}
17

18
/**
19
 * Load and parse the Solana CLI config file to determine which RPC url to use
20
 */
21
export async function getRpcUrl(): Promise<string> {
22
  try {
23
    const config = await getConfig()
24
    if (!config.json_rpc_url) throw new Error('Missing RPC URL')
25
    return config.json_rpc_url
26
  } catch (err) {
27
    console.warn('Failed to read RPC url from CLI config file, falling back to localhost')
28
    return 'http://127.0.0.1:8899'
29
  }
30
}
31

32
/**
33
 * Load and parse the Solana CLI config file to determine which payer to use
34
 */
35
export async function getPayer(): Promise<Keypair> {
36
  try {
37
    const config = await getConfig()
38
    if (!config.keypair_path) throw new Error('Missing keypair path')
39
    return await createKeypairFromFile(config.keypair_path)
40
  } catch (err) {
41
    console.warn(
42
      'Failed to create keypair from CLI config file, falling back to new random keypair'
43
    )
44
    return Keypair.generate()
45
  }
46
}
47

48
/**
49
 * Create a Keypair from a secret key stored in file as bytes' array
50
 */
51
export async function createKeypairFromFile(filePath: string): Promise<Keypair> {
52
  const secretKeyString = await fs.readFile(filePath, { encoding: 'utf8' })
53
  const secretKey = Uint8Array.from(JSON.parse(secretKeyString))
54
  return Keypair.fromSecretKey(secretKey)
55
}

1
/* eslint-disable @typescript-eslint/no-unsafe-assignment */
2
/* eslint-disable @typescript-eslint/no-unsafe-member-access */
3

4
import {
5
  Keypair,
6
  Connection,
7
  PublicKey,
8
  LAMPORTS_PER_SOL,
9
  SystemProgram,
10
  TransactionInstruction,
11
  Transaction,
12
  sendAndConfirmTransaction
13
} from '@solana/web3.js'
14
import fs from 'fs'
15
import path from 'path'
16
import * as borsh from 'borsh'
17

18
import { getPayer, getRpcUrl, createKeypairFromFile } from './utils'
19

20
let connection: Connection
21

22
let payer: Keypair
23

24
let programId: PublicKey
25

26
let greetedPubkey: PublicKey
27

28
const PROGRAM_PATH = path.resolve(__dirname, '../dist/program')
29
const PROGRAM_SO_PATH = path.join(PROGRAM_PATH, 'solana_helloworld.so')
30
const PROGRAM_KEYPAIR_PATH = path.join(PROGRAM_PATH, 'solana_helloworld-keypair.json')
31

32
/**
33
 * The state of a greeting account managed by the hello world program
34
 */
35
class GreetingAccount {
36
  counter = 0
37
  constructor(fields: { counter: number } | undefined = undefined) {
38
    if (fields) {
39
      this.counter = fields.counter
40
    }
41
  }
42
}
43

44
/**
45
 * Borsh schema definition for greeting accounts
46
 */
47
const GreetingSchema = new Map([
48
  [GreetingAccount, { kind: 'struct', fields: [['counter', 'u32']] }]
49
])
50

51
/**
52
 * The expected size of each greeting account.
53
 */
54
const GREETING_SIZE = borsh.serialize(GreetingSchema, new GreetingAccount()).length
55

56
/**
57
 * Establish a connection to the cluster
58
 */
59
export async function establishConnection(): Promise<void> {
60
  const rpcUrl = await getRpcUrl()
61
  connection = new Connection(rpcUrl, 'confirmed')
62
  const version = await connection.getVersion()
63
  console.log('Connection to cluster established:', rpcUrl, version)
64
}
65

66
/**
67
 * Establish an account to pay for everything
68
 */
69
export async function establishPayer(): Promise<void> {
70
  let fees = 0
71
  if (!payer) {
72
    const { feeCalculator } = await connection.getRecentBlockhash()
73

74
    // Calculate the cost to fund the greeter account
75
    fees += await connection.getMinimumBalanceForRentExemption(GREETING_SIZE)
76

77
    // Calculate the cost of sending transactions
78
    fees += feeCalculator.lamportsPerSignature * 100 // wag
79

80
    payer = await getPayer()
81
  }
82

83
  let lamports = await connection.getBalance(payer.publicKey)
84
  if (lamports < fees) {
85
    // If current balance is not enough to pay for fees, request an airdrop
86
    const sig = await connection.requestAirdrop(payer.publicKey, fees - lamports)
87
    await connection.confirmTransaction(sig)
88
    lamports = await connection.getBalance(payer.publicKey)
89
  }
90

91
  console.log(
92
    'Using account',
93
    payer.publicKey.toBase58(),
94
    'containing',
95
    lamports / LAMPORTS_PER_SOL,
96
    'SOL to pay for fees'
97
  )
98
}
99

100
/**
101
 * Check if the hello world BPF program has been deployed
102
 */
103
export async function checkProgram(): Promise<void> {
104
  // Read program id from keypair file
105
  try {
106
    const programKeypair = await createKeypairFromFile(PROGRAM_KEYPAIR_PATH)
107
    programId = programKeypair.publicKey
108
  } catch (err) {
109
    const errMsg = (err as Error).message
110
    throw new Error(
111
      `Failed to read program keypair at '${PROGRAM_KEYPAIR_PATH}' due to error: ${errMsg}. Program may need to be deployed with \`solana program deploy dist/program/helloworld.so\``
112
    )
113
  }
114

115
  // Check if the program has been deployed
116
  const programInfo = await connection.getAccountInfo(programId)
117
  if (programInfo === null) {
118
    if (fs.existsSync(PROGRAM_SO_PATH)) {
119
      throw new Error(
120
        'Program needs to be deployed with `solana program deploy dist/program/helloworld.so`'
121
      )
122
    } else {
123
      throw new Error('Program needs to be built and deployed')
124
    }
125
  } else if (!programInfo.executable) {
126
    throw new Error(`Program is not executable`)
127
  }
128
  console.log(`Using program ${programId.toBase58()}`)
129

130
  // Derive the address (public key) of a greeting account from the program so that it's easy to find later.
131
  const GREETING_SEED = 'hello'
132
  greetedPubkey = await PublicKey.createWithSeed(payer.publicKey, GREETING_SEED, programId)
133

134
  // Check if the greeting account has already been created
135
  const greetedAccount = await connection.getAccountInfo(greetedPubkey)
136
  if (greetedAccount === null) {
137
    console.log('Creating account', greetedPubkey.toBase58(), 'to say hello to')
138
    const lamports = await connection.getMinimumBalanceForRentExemption(GREETING_SIZE)
139

140
    const transaction = new Transaction().add(
141
      SystemProgram.createAccountWithSeed({
142
        fromPubkey: payer.publicKey,
143
        basePubkey: payer.publicKey,
144
        seed: GREETING_SEED,
145
        newAccountPubkey: greetedPubkey,
146
        lamports,
147
        space: GREETING_SIZE,
148
        programId
149
      })
150
    )
151
    await sendAndConfirmTransaction(connection, transaction, [payer])
152
  }
153
}
154

155
/**
156
 * Say hello
157
 */
158
export async function sayHello(): Promise<void> {
159
  console.log('Saying hello to', greetedPubkey.toBase58())
160
  const instruction = new TransactionInstruction({
161
    keys: [{ pubkey: greetedPubkey, isSigner: false, isWritable: true }],
162
    programId,
163
    data: Buffer.alloc(0) // All instructions are hellos
164
  })
165
  await sendAndConfirmTransaction(connection, new Transaction().add(instruction), [payer])
166
}
167

168
/**
169
 * Report the number of times the greeted account has been said hello to
170
 */
171
export async function reportGreetings(): Promise<void> {
172
  const accountInfo = await connection.getAccountInfo(greetedPubkey)
173
  if (accountInfo === null) {
174
    throw 'Error: cannot find the greeted account'
175
  }
176
  const greeting = borsh.deserialize(GreetingSchema, GreetingAccount, accountInfo.data)
177
  console.log(greetedPubkey.toBase58(), 'has been greeted', greeting.counter, 'time(s)')
178
}

1
export async function sayHello(): Promise<void> {
2
  console.log('Saying hello to', greetedPubkey.toBase58())
3

4
  let greetingAccount = new GreetingAccount({
5
    counter: 0
6
  })
7

8
  let data = borsh.serialize(GreetingSchema, greetingAccount)
9
  const instructionData = Buffer.from(data)
10
  console.log('data to send', instructionData.toString('utf-8'))
11

12
  const instruction = new TransactionInstruction({
13
    keys: [{ pubkey: greetedPubkey, isSigner: false, isWritable: true }],
14
    programId,
15
    data: instructionData
16
  })
17

18
  await sendAndConfirmTransaction(connection, new Transaction().add(instruction), [payer])
19
}

1
pub fn process_instruction(
2
    program_id: &Pubkey, // Public key of the account the hello world program was loaded into
3
    accounts: &[AccountInfo], // The account to say hello to
4
    instruction_data: &[u8], // Ignored, all helloworld instructions are hellos
5
) -> ProgramResult {
6
    msg!("Hello World Rust program entrypoint");
7

8
    // Iterating accounts is safer than indexing
9
    let accounts_iter = &mut accounts.iter();
10

11
    // Get the account to say hello to
12
    let account = next_account_info(accounts_iter)?;
13

14
    // The account must be owned by the program in order to modify its data
15
    if account.owner != program_id {
16
        msg!("Greeted account does not have the correct program id");
17
        return Err(ProgramError::IncorrectProgramId);
18
    }
19

20
    let input_data = GreetingAccount::try_from_slice(&instruction_data).unwrap();
21
    msg!("Input Data {:?}", input_data);
22

23
    // Increment and store the number of times the account has been greeted
24
    let mut greeting_account = GreetingAccount::try_from_slice(&account.data.borrow())?;
25

26
    if input_data.counter > 0 {
27
        greeting_account.counter = input_data.counter;
28
    } else {
29
        greeting_account.counter += 1;
30
    }
31

32
    greeting_account.serialize(&mut &mut account.data.borrow_mut()[..])?;
33

34
    msg!("Greeted {} time(s)!", greeting_account.counter);
35

36
    Ok(())
37
}

1
{
2
  "scripts": {
3
    "run": "npm run build && npm run deploy && npm run run-client",
4
    "build": "cargo build-bpf --manifest-path=./Cargo.toml --bpf-out-dir=dist/program",
5
    "deploy": "solana program deploy dist/program/solana_helloworld.so",
6
    "run-client": "./node_modules/.bin/ts-node client/main.ts"
7
  }
8
}