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

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

rustup --version

rustc --version

cargo --version

sh -c "$(curl -sSfL https://release.solana.com/v1.10.6/install)"

sh -c "$(curl -sSfL https://release.solana.com/stable/install)"

solana version

brew install node

node --version

solana config set --url localhost

solana-keygen new

BIP39 Passphrase (empty for none):
``

จากนั้นระบบก็จะ generate 12 คำ ซึ่งก็เหมือน Wallet อื่นๆ เราต้องจดไว้

```bash
Wrote new keypair to /Users/chai/.config/solana/id.json
==============================================================================
pubkey: G2s5SoQt4uxpnt8soSdcfGL4Gt78cpt1MmyruP4BUoss
==============================================================================
Save this seed phrase and your BIP39 passphrase to recover your new keypair:
<--------12 คำ อยู่ตรงนี้------>
==============================================================================

solana config get

Config File: /Users/chai/.config/solana/cli/config.yml
RPC URL: http://localhost:8899
WebSocket URL: ws://localhost:8900/ (computed)
Keypair Path: /Users/chai/.config/solana/id.json
Commitment: confirmed

solana-test-validator

solana logs

cargo init solana-helloworld --lib

├── Cargo.toml
└── src
    └── lib.rs

[package]
name = "solana-helloworld"
version = "0.1.0"
edition = "2021"

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

[features]
no-entrypoint = []

[dependencies]
borsh = "0.9.3"
borsh-derive = "0.9.3"
solana-program = "=1.10.6"

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

use borsh::{BorshDeserialize, BorshSerialize};
use solana_program::{
    account_info::{next_account_info, AccountInfo},
    entrypoint,
    entrypoint::ProgramResult,
    msg,
    program_error::ProgramError,
    pubkey::Pubkey,
};

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

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

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

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

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

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

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

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

    Ok(())
}

cargo build --manifest-path=./Cargo.toml

  Compiling solana-helloworld v0.1.0 (/Users/chai/dev/solana-helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 20.31s

cargo build-bpf --manifest-path=./Cargo.toml --bpf-out-dir=dist/program

├── solana_helloworld-keypair.json
└── solana_helloworld.so

solana program deploy dist/program/solana_helloworld.so

Program Id: 2rQ5YJQ7tG6xEyY2M37frBi7Y1u3wWT1ap8hZDs9Gcwe

yarn init -y

# หรือ npm
npm init -y

npm install borsh @solana/web3.js yaml

npm install @types/yaml @tsconfig/recommended ts-node typescript --save

{
  "name": "solana-helloworld",
  "version": "1.0.0",
  "main": "index.js",
  "author": "Chai Phonbopit",
  "license": "MIT",
  "dependencies": {
    "@solana/web3.js": "1.37.1",
    "borsh": "0.7.0",
    "yaml": "2.0.0"
  },
  "devDependencies": {
    "@tsconfig/recommended": "1.0.1",
    "@types/yaml": "1.9.7",
    "ts-node": "10.7.0",
    "typescript": "4.6.3"
  }
}

{
  "extends": "@tsconfig/recommended/tsconfig.json",
  "ts-node": {
    "compilerOptions": {
      "module": "commonjs"
    }
  },
  "compilerOptions": {
    "declaration": true,
    "moduleResolution": "node",
    "module": "es2015"
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

import {
  establishConnection,
  establishPayer,
  checkProgram,
  sayHello,
  reportGreetings,
} from './hello_world';

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

  // Establish connection to the cluster
  await establishConnection();

  // Determine who pays for the fees
  await establishPayer();

  // Check if the program has been deployed
  await checkProgram();

  // Say hello to an account
  await sayHello();

  // Find out how many times that account has been greeted
  await reportGreetings();

  console.log('Success');
}

main().then(
  () => process.exit(),
  err => {
    console.error(err);
    process.exit(-1);
  },
);

import os from "os";
import fs from "fs/promises";

import path from "path";
import yaml from "yaml";
import { Keypair } from "@solana/web3.js";

/**
 * @private
 */
async function getConfig(): Promise<any> {
  // Path to Solana CLI config file
  const CONFIG_FILE_PATH = path.resolve(
    os.homedir(),
    ".config",
    "solana",
    "cli",
    "config.yml"
  );
  const configYml = await fs.readFile(CONFIG_FILE_PATH, { encoding: "utf8" });
  return yaml.parse(configYml);
}

/**
 * Load and parse the Solana CLI config file to determine which RPC url to use
 */
export async function getRpcUrl(): Promise<string> {
  try {
    const config = await getConfig();
    if (!config.json_rpc_url) throw new Error("Missing RPC URL");
    return config.json_rpc_url;
  } catch (err) {
    console.warn(
      "Failed to read RPC url from CLI config file, falling back to localhost"
    );
    return "http://127.0.0.1:8899";
  }
}

/**
 * Load and parse the Solana CLI config file to determine which payer to use
 */
export async function getPayer(): Promise<Keypair> {
  try {
    const config = await getConfig();
    if (!config.keypair_path) throw new Error("Missing keypair path");
    return await createKeypairFromFile(config.keypair_path);
  } catch (err) {
    console.warn(
      "Failed to create keypair from CLI config file, falling back to new random keypair"
    );
    return Keypair.generate();
  }
}

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

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

import {
  Keypair,
  Connection,
  PublicKey,
  LAMPORTS_PER_SOL,
  SystemProgram,
  TransactionInstruction,
  Transaction,
  sendAndConfirmTransaction,
} from "@solana/web3.js";
import fs from "fs";
import path from "path";
import * as borsh from "borsh";

import { getPayer, getRpcUrl, createKeypairFromFile } from "./utils";

let connection: Connection;

let payer: Keypair;

let programId: PublicKey;

let greetedPubkey: PublicKey;

const PROGRAM_PATH = path.resolve(__dirname, "../dist/program");
const PROGRAM_SO_PATH = path.join(PROGRAM_PATH, "solana_helloworld.so");
const PROGRAM_KEYPAIR_PATH = path.join(PROGRAM_PATH, "solana_helloworld-keypair.json");

/**
 * The state of a greeting account managed by the hello world program
 */
class GreetingAccount {
  counter = 0;
  constructor(fields: { counter: number } | undefined = undefined) {
    if (fields) {
      this.counter = fields.counter;
    }
  }
}

/**
 * Borsh schema definition for greeting accounts
 */
const GreetingSchema = new Map([
  [GreetingAccount, { kind: "struct", fields: [["counter", "u32"]] }],
]);

/**
 * The expected size of each greeting account.
 */
const GREETING_SIZE = borsh.serialize(
  GreetingSchema,
  new GreetingAccount()
).length;

/**
 * Establish a connection to the cluster
 */
export async function establishConnection(): Promise<void> {
  const rpcUrl = await getRpcUrl();
  connection = new Connection(rpcUrl, "confirmed");
  const version = await connection.getVersion();
  console.log("Connection to cluster established:", rpcUrl, version);
}

/**
 * Establish an account to pay for everything
 */
export async function establishPayer(): Promise<void> {
  let fees = 0;
  if (!payer) {
    const { feeCalculator } = await connection.getRecentBlockhash();

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

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

    payer = await getPayer();
  }

  let lamports = await connection.getBalance(payer.publicKey);
  if (lamports < fees) {
    // If current balance is not enough to pay for fees, request an airdrop
    const sig = await connection.requestAirdrop(
      payer.publicKey,
      fees - lamports
    );
    await connection.confirmTransaction(sig);
    lamports = await connection.getBalance(payer.publicKey);
  }

  console.log(
    "Using account",
    payer.publicKey.toBase58(),
    "containing",
    lamports / LAMPORTS_PER_SOL,
    "SOL to pay for fees"
  );
}

/**
 * Check if the hello world BPF program has been deployed
 */
export async function checkProgram(): Promise<void> {
  // Read program id from keypair file
  try {
    const programKeypair = await createKeypairFromFile(PROGRAM_KEYPAIR_PATH);
    programId = programKeypair.publicKey;
  } catch (err) {
    const errMsg = (err as Error).message;
    throw new Error(
      `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\``
    );
  }

  // Check if the program has been deployed
  const programInfo = await connection.getAccountInfo(programId);
  if (programInfo === null) {
    if (fs.existsSync(PROGRAM_SO_PATH)) {
      throw new Error(
        "Program needs to be deployed with `solana program deploy dist/program/helloworld.so`"
      );
    } else {
      throw new Error("Program needs to be built and deployed");
    }
  } else if (!programInfo.executable) {
    throw new Error(`Program is not executable`);
  }
  console.log(`Using program ${programId.toBase58()}`);

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

  // Check if the greeting account has already been created
  const greetedAccount = await connection.getAccountInfo(greetedPubkey);
  if (greetedAccount === null) {
    console.log(
      "Creating account",
      greetedPubkey.toBase58(),
      "to say hello to"
    );
    const lamports = await connection.getMinimumBalanceForRentExemption(
      GREETING_SIZE
    );

    const transaction = new Transaction().add(
      SystemProgram.createAccountWithSeed({
        fromPubkey: payer.publicKey,
        basePubkey: payer.publicKey,
        seed: GREETING_SEED,
        newAccountPubkey: greetedPubkey,
        lamports,
        space: GREETING_SIZE,
        programId,
      })
    );
    await sendAndConfirmTransaction(connection, transaction, [payer]);
  }
}

/**
 * Say hello
 */
export async function sayHello(): Promise<void> {
  console.log("Saying hello to", greetedPubkey.toBase58());
  const instruction = new TransactionInstruction({
    keys: [{ pubkey: greetedPubkey, isSigner: false, isWritable: true }],
    programId,
    data: Buffer.alloc(0), // All instructions are hellos
  });
  await sendAndConfirmTransaction(
    connection,
    new Transaction().add(instruction),
    [payer]
  );
}

/**
 * Report the number of times the greeted account has been said hello to
 */
export async function reportGreetings(): Promise<void> {
  const accountInfo = await connection.getAccountInfo(greetedPubkey);
  if (accountInfo === null) {
    throw "Error: cannot find the greeted account";
  }
  const greeting = borsh.deserialize(
    GreetingSchema,
    GreetingAccount,
    accountInfo.data
  );
  console.log(
    greetedPubkey.toBase58(),
    "has been greeted",
    greeting.counter,
    "time(s)"
  );
}

ts-node client/main.ts

Let's say hello to a Solana account...
Connection to cluster established: http://localhost:8899 { 'feature-set': 1070292356, 'solana-core': '1.9.14' }
Using account 2B82KUoFQXHjGz6aV8hzJgvCuCfgPTSi9eAW9TMpqbv1 containing 499999999.15446967 SOL to pay for fees
Using program 2rQ5YJQ7tG6xEyY2M37frBi7Y1u3wWT1ap8hZDs9Gcwe
Creating account 2mhCSXCeAK4A5uyw6TSq527vpw9pbdAuoSoWWZrp7juS to say hello to
Saying hello to 2mhCSXCeAK4A5uyw6TSq527vpw9pbdAuoSoWWZrp7juS
2mhCSXCeAK4A5uyw6TSq527vpw9pbdAuoSoWWZrp7juS has been greeted 1 time(s)
Success

class GreetingAccount {
  counter = 0;
  constructor(fields: { counter: number } | undefined = undefined) {
    if (fields) {
      this.counter = fields.counter;
    }
  }
}

const GreetingSchema = new Map([
  [GreetingAccount, { kind: 'struct', fields: [['counter', 'u32']] }]
]);

export async function sayHello(): Promise<void> {
  console.log("Saying hello to", greetedPubkey.toBase58());

  let greetingAccount = new GreetingAccount({
    counter: 0,
  });

  let data = borsh.serialize(GreetingSchema, greetingAccount);
  const instructionData = Buffer.from(data);
  console.log("data to send", instructionData.toString("utf-8"));

  const instruction = new TransactionInstruction({
    keys: [{ pubkey: greetedPubkey, isSigner: false, isWritable: true }],
    programId,
    data: instructionData,
  });

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

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

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

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

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

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

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

    if input_data.counter > 0 {
        greeting_account.counter = input_data.counter;
    } else {
        greeting_account.counter += 1;
    }

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

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

    Ok(())
}

cargo build-bpf --manifest-path=./Cargo.toml --bpf-out-dir=dist/program
solana program deploy dist/program/solana_helloworld.so
./node_modules/.bin/ts-node client/main.ts

./node_modules/.bin/ts-node client/main.ts

Let's say hello to a Solana account...
Connection to cluster established: http://localhost:8899 { 'feature-set': 1070292356, 'solana-core': '1.9.14' }
Using account 2B82KUoFQXHjGz6aV8hzJgvCuCfgPTSi9eAW9TMpqbv1 containing 499999998.305227 SOL to pay for fees
Using program FKb3rRG72e8ZukMhR1TKv58eWRH93WTJ9mPHTzEiWaD3
Saying hello to 86rXpsW7ApWABdsyq69YsTrVtcAyhgMQQqKVoYbCYr2R
data to send <Buffer 00 00 00 00>
86rXpsW7ApWABdsyq69YsTrVtcAyhgMQQqKVoYbCYr2R has been greeted 121 time(s)
Success

run: build deploy run-client
build:
	cargo build-bpf --manifest-path=./Cargo.toml --bpf-out-dir=dist/program
deploy:
	solana program deploy dist/program/solana_helloworld.so
run-client:
	./node_modules/.bin/ts-node client/main.ts

make run

make build

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

yarn build
yarn deploy
yarn run-client
# เนื่องจากคำสั่งชื่อไปชนกันกับ run :)
yarn run run

solana config set --url https://api.devnet.solana.com

solana airdrop 2

solana airdrop 2 <addresss>

solana address -K path/your/keypair.json