บันทึกการเขียน Smart Contract แรก บน NEAR Protocol

// write the given name and save "Hello {message}!" to contract storage.
export function hello(message: string): string {}

// read a message by account_id from contract storage.
export function get_hello(account_id: AccountId): string {}

rustup target add wasm32-unknown-unknown

npx create-next-app helloworld

npm install -D tailwindcss postcss autoprefixer
npx tailwindcss init -p

cargo new contract --lib

[package]
name = "helloworld"
authors = ["Chai Phonbopit"]
version = "0.1.0"
edition = "2021"

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

[dependencies]
near-sdk = "3.1.0"

[lib]
crate-type = ["cdylib"]

[profile.release]
codegen-units = 1
# Tell `rustc` to optimize for small code size.
opt-level = "z"
lto = true
debug = false
panic = "abort"
# Opt into extra safety checks on arithmetic operations https://stackoverflow.com/a/64136471/249801
overflow-checks = true

use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::LookupMap;
use near_sdk::{env, log, near_bindgen, AccountId};

#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct HelloWorld {
    pub messages: LookupMap<AccountId, String>,
}

impl Default for HelloWorld {
    fn default() -> Self {
        Self {
            // messages: LookupMap::new(b"a".to_vec()),
            messages: LookupMap::new("".as_bytes().to_vec()),
        }
    }
}

#[near_bindgen]
impl HelloWorld {
    pub fn hello(&mut self, message: String) {
        let account_id = env::signer_account_id();
        let greeting = format_args!("Hello {message}!").to_string();

        log!(
            "{} hello with message {} and greeting: {}",
            account_id,
            message,
            greeting
        );

        self.messages.insert(&account_id, &greeting);
    }

    pub fn get_hello(&self, account_id: AccountId) -> String {
        match self.messages.get(&account_id) {
            Some(value) => {
                log!("value from lookupMap(messages) is {}", value);
                value
            }
            None => "not found".to_string(),
        }
    }
}

#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct HelloWorld {
    pub messages: LookupMap<AccountId, String>,
}

impl Default for HelloWorld {
    fn default() -> Self {
        Self {
            // messages: LookupMap::new(b"a".to_vec()),
            messages: LookupMap::new("".as_bytes().to_vec()),
        }
    }
}

pub fn hello(&mut self, message: String) {
    let account_id = env::signer_account_id();
    let greeting = format_args!("Hello {message}!").to_string();

    log!(
        "{} hello with message {} and greeting: {}",
        account_id,
        message,
        greeting
    );

    self.messages.insert(&account_id, &greeting);
}

pub fn get_hello(&self, account_id: AccountId) -> String {
    match self.messages.get(&account_id) {
        Some(value) => {
            log!("value from lookupMap(messages) is {}", value);
            value
        }
        None => "not found".to_string(),
    }
}

use near_sdk::MockedBlockchain;
use near_sdk::{testing_env, VMContext};

#[test]
fn set_then_get_hello() {
    let context = get_context(vec![], false);
    testing_env!(context);

    let mut contract = HelloWorld::default();
    contract.hello("Chuck".to_string());

    let message = contract.get_hello("bob_near".to_string());
    assert_eq!("Hello Chuck!".to_string(), message);
}

#[test]
fn get_default_hello() {
    let context = get_context(vec![], true);
    testing_env!(context);

    let contract = HelloWorld::default();
    let message = contract.get_hello("bob_near".to_string());

    assert_eq!("not found".to_string(), message);
}

build:
	cd contract && cargo build --target wasm32-unknown-unknown --release
deploy:
	near deploy --wasmFile contract/target/wasm32-unknown-unknown/release/helloworld.wasm --accountId helloworld.0xchai.testnet
test:
	cd contract && cargo test

const config = {
  // ...config
};

function MyApp({ Component, pageProps }) {
  return (
    <NearWalletProvider config={config}>
      <Component {...pageProps} />
    </NearWalletProvider>
  );
}

// 1. กำหนด config (ถ้าใน NearWalletProvider ผมส่งเป็น prop มา)
const config = {
  networkId: 'testnet',
  nodeUrl: 'https://rpc.testnet.near.org',
  walletUrl: 'https://wallet.testnet.near.org',
  helperUrl: 'https://helper.testnet.near.org',
  explorerUrl: 'https://explorer.testnet.near.org'
};

// 2. Connect Wallet
const near = await connect({
  ...config,
  keyStore: new keyStores.BrowserLocalStorageKeyStore()
});

// 3. Connect ด้วยชื่อ app เรา
const wallet = new WalletConnection(near, 'helloworld');

// 4. เช็ค authorized
let accountId = wallet.getAccountId();

// 5. ถ้า signed in เราก็จะ get account กับ initial contract.
if (accountId) {
  const accountState = await wallet.account().state();

  // 6. initial contract. ขอ view, call `get_hello` กับ `hello`
  const contract = await new Contract(wallet.account(), config.contractName, {
    viewMethods: ['get_hello'],
    changeMethods: ['hello']
  });

  // 7. set state (Provider.Context) เผื่อเอาไปใช้
  setState({
    wallet,
    contract,
    account: {
      accountId
    },
    signIn: () => {
      wallet.requestSignIn(config.contractName);
    },
    signOut: () => wallet.signOut(),
    isSignedIn: wallet.isSignedIn(),
    loadAccount: (accountId) => () => near.account(accountId)
  });
}

export default function Home() {
  const { account, contract, signIn } = useContext(WalletContext);

  const hello = async () => {
    await contract.hello({ message });
  };

  const handleMessage = (event) => {
    const value = event.target.value;
    setMessage(value);
  };

  const handleGetHello = async () => {
    const message = await contract.get_hello({
      account_id: account?.accountId
    });
  };

  const connectWallet = async () => {
    signIn();
  };

  return (
    //...
  )
}