Hướng dẫn xây dựng và phát triển trên NEAR

điều kiện tiên quyết:

NEAR là gì?

Kinh nghiệm phát triển JavaScript

Những kĩ sư lập trình là nguồn độc lực chính để phát triển các ứng dụng trong hệ sinh thái của một blockchain. Một blockchain cần phải cung cấp những công cụ và hệ thống giúp những kĩ sư lập trình có thể dễ dàng phát triển và triển khai những ứng dụng trên nền tản của blockchain đó. Do vậy, trong hệ sinh thái NEAR, các hợp động thông minh – smart contract có thể viết bằng một trong hai ngôn ngữ lập trình phổ biến đó là AssemblyScript và Rust.

Để xây dựng ứng dụng trên nền tảng blockchain của NEAR, chúng ta có thể sử dụng những công cụ sau:

• JavaScript SDK: Kết nối, đăng ký, giao dịch và triển khai với bất kỳ mạng lưới NEAR nào từ bất kỳ JS context nào.
• Rust Contract SDK: Xây dựng các hợp đồng an toàn, bảo mật để quản lý các tài sản có giá trị cao.
• AssemblyScript Contract SDK: Tìm hiểu và tạo nguyên bản bằng cú pháp JS.
• JSON RPC API: Tất cả các thông tin giao tiếp với nền tảng đều thông qua API này.
• Near CLI: cung cấp tập hợp những câu lệnh cho phép người dùng tương tác với hệ thống blockchain của Near (ví dụ: tạo account, kiểm tra trạng thái của một giao dịch etc…)
• NEAR Explorer: Near Explorer: hiển thị trực quan theo thời gian thực các thông tin liên quan đến Near blockchain, cho phép kiểm tra thông tin các tài khoản Near, lịch sử giao dịch etc..
• Near Wallet: Ứng dụng web cho phép tạo và tương tác với những tài khoản người dùng của Near. Giao diện ứng dụng thân thiện và dễ dàng sử dụng trên các thiết bị mobile hoặc máy tính
• NEARUP: Quản lý triển khai cục bộ và tham gia bất kỳ mạng lưới công cộng hoặc riêng tư nào.
• Bridge: Khả năng tương tác nhanh, an toàn.
• EVM: Máy ảo tương thích với Ethereum.

 

Bắt đầu nào, hãy thực hiện các bước đầu tiên.

Thông tin tổng quan

Các ứng dụng trên NEAR có hai phần riêng biệt, đó là back-end và front-end.

• Hợp đồng thông minh (back-end): Lưu trữ và sửa đổi dữ liệu trên chuỗi. Hợp đồng cần đưa ra các phương pháp cho phép client (máy khách) “xem” và “thay đổi” trạng thái.

Tương tác với Hợp đồng thông minh (front-end): Bạn có thể tương tác với hợp đồng của mình hoặc hợp đồng do người khác triển khai. Bạn thực hiện việc này bằng cách sử dụng near-api-js Quickstart và Code Snippets trong ứng dụng của bạn.

Cách xây dựng và gọi hợp đồng thông minh

NEAR hiện hỗ trợ:

• Rust – near-sdk-rs: Một trình wrapper (bọc) cung cấp sự an toàn được cải thiện cho ngôn ngữ lập trình Rust cho các hợp đồng giá trị cao.
• AssemblyScript near-sdk-as: Một tập hợp các trình hỗ trợ làm cho các hợp đồng thông minh của bạn tương tự như TypeScript khi biên dịch sang Wasm để thực thi.

 

GHI CHÚ: AssemblyScript hiện không được khuyến nghị cho các ứng dụng tài chính sản xuất do tính mới của ngôn ngữ và các công cụ biên dịch có sẵn.

Tiếp đến, cùng đi sâu và hãy nghiêm túc.

Thiết lập Testnet

Cách dễ nhất để tạo tài khoản trên NEAR là với NEAR Wallet. NEAR có một số mạng lưới phát triển hoạt động độc lập với nhau với các ID tài khoản của riêng họ. Thực hiện theo các bước để tạo ví. Đảm bảo rằng bạn đã làm theo các bước bắt buộc để sao lưu bảo mật.

LƯU Ý: Tạo tài khoản trên mainnet gần giống với testnet nhưng sẽ yêu cầu một số NEAR nhất định để kích hoạt  tài khoản. Đây là hướng dẫn tạo tài khoản mainnet.

Khi triển khai, cho dù ứng dụng được viết bằng Rust hay AssemblyScript. Tất cả mã hợp đồng được biên dịch sang WebAssembly và được triển khai vào mạng lưới để chạy bên trong một máy ảo tương thích với Wasm. Bạn sẽ sử dụng một lệnh giống như yarn dev cho hầu hết các ứng dụng nhưng bạn có thể dễ dàng triển khai ứng dụng bằng cách sử dụng NEAR CLI với NEAR dev-deploy cho TestNet (hoặc triển khai NEAR nếu bạn đã tạo tài khoản).

Bây giờ, hãy làm những điều sau để bắt đầu khởi động:

1. Nhìn xung quanh trong NEAR Explorer. Tại đây bạn có thể tìm kiếm tất cả các giao dịch và block (khối) được sản xuất trên NEAR. Hãy thử tìm kiếm tài khoản bạn vừa tạo và xem các giao dịch bạn đã tạo.
2. Cài đặt ngay near-cli. Đây là một giao diện dòng lệnh cho phép bạn tương tác liền mạch với NEAR. Tài liệu NEAR này có tất cả các lệnh near-cli kèm theo các ví dụ.
3. Thử chạy lệnh đầu tiên của bạn: near login. Thao tác này sẽ chuyển hướng bạn đến NEAR Wallet của bạn và lưu các khóa tài khoản testnet của bạn.

Sau khi kiểm tra testnet, bạn có thể thoải mái chạy node (nút) cục bộ của mình. Tuy nhiên, nếu bạn chỉ muốn thử với các mã, thì chúng tôi khuyên bạn nên sử dụng testnet.

Làm thế nào để chạy một node?

Như với bất kỳ hệ sinh thái dựa trên blockchain nào, NEAR Protocol chạy trên một tập hợp các máy tính được bảo trì công khai (hoặc “các node”).

Bạn có thể quyết định chạy một node của riêng mình với một số lý do:

• Để phát triển và triển khai các hợp đồng trên một node được kết nối với MainNet, TestNet hoặc BetaNet.
• Để phát triển và triển khai các hợp đồng trên một node cục bộ (“LocalNet”).
• Để tham gia mạng lưới với tư cách là validator, hãy chạy một “validator node”

Bạn có thể chạy các Node BetaNet và TestNet bằng cách cài đặt nearup. Xem hướng dẫn chi tiết tại https://github.com/near/nearup

Chạy một node chính thức bằng Docker

Theo mặc định, NEAR sử dụng Docker để chạy các client (máy khách). Vì vậy, điều đầu tiên bạn làm là cài đặt Docker và nearup. Bây giờ, hãy chạy hệ thống của bạn như bên dưới:

nearup betanet

(Nếu bạn thích sử dụng TestNet thì chỉ cần thay betanet bằng testnet trong lệnh trên)

Sau đó, bạn sẽ được yêu cầu nhập ID tài khoản. Bạn có thể để trống phần này nếu bạn chỉ muốn chạy một node. Các validator nên sử dụng ID tài khoản của tài khoản bạn muốn stake. Sau đó, bạn cần nhập lệnh này:

Nhập ID tài khoản của bạn (để trống nếu không trở thành một validator)

Bây giờ, node của bạn sau đó sẽ bắt đầu ở chế độ nền với Docker. Để kiểm tra các log bên trong Docker, hãy chạy docker log –follow nearcore.

Viết mã lệnh đơn giản trên NEAR

NEAR có một danh sách các chương trình hữu ích hoặc các ví dụ code mà bạn có thể kiểm tra một cách dễ dàng. Vì vậy, code mà chúng tôi sẽ kiểm tra là Guest Book. Sử dụng chương trình cho phép bạn đăng nhập với NEAR và thêm tin nhắn vào Guest Book! Một ứng dụng dành cho người mới bắt đầu được xây dựng với backend là AssemblyScript và frontend là React.

Tìm hiểu code của Guest Book

Để chạy dự án này trên môi trường cục bộ (localhost), bạn cần đảm bảo những điều sau:

• Download và cài đặt Node.js ≥ 12 (https://nodejs.org/en/download/) –
• Sử dụng công cụ NPM của Node.js để cài đặt Yarn bằng lệnh sau: npm install –global yarn (hoặc npm i -g yarn) –
• Cài đặt các dependencies với lệnh: yarn install –frozen-lockfile (hoặc yarn –frozen-lockfile)

Triển khai ứng dụng trên môi trường cục bộ với lệnh: yarn dev (xem package.json để biết danh sách đầy đủ các scripts mà bạn có thể chạy với yarn)

Giờ đây, bạn sẽ có một môi trường phát triển cục bộ được hỗ trợ bởi NEAR TestNet! Chạy yarn dev sẽ cho bạn biết URL mà bạn có thể truy cập trong trình duyệt của mình để xem ứng dụng.

Một điều là hãy đảm bảo rằng bạn đã mở trang GitHub.

Bạn cũng có thể xem video bên dưới biết thêm chi tiết.

Khám phá code

Như bạn có thể thấy, có hai phần chính của code đó là backend và frontend:

• Code backend nằm trong thư mục /assembly. Code này được triển khai trên NEAR Blockchain khi bạn chạy triển khai yarn:contract. Đây là một hợp đồng thông minh trên NEAR.
• Code frontend nằm trong thư mục /src. Và /src/index.html là một nơi tuyệt vời để bắt đầu khám phá. Cách mà phần frontend kết nối với NEAR Blockchain được định nghĩa trong /src/index.js.

Backend Code

#1 Contract Data Model:  assembly/model.ts

import { context, u128, PersistentVector } from "near-sdk-as";
/** 
 * Exporting a new class PostedMessage so it can be used outside of this file.
 */
@nearBindgen
export class PostedMessage {
  premium: boolean;
  sender: string;
  constructor(public text: string) {
    this.premium = context.attachedDeposit >= u128.from('10000000000000000000000');
    this.sender = context.sender;
  }
}
/**
 * collections.vector is a persistent collection. Any changes to it will
 * be automatically saved in the storage.
 * The parameter to the constructor needs to be unique across a single contract.
 * It will be used as a prefix to all keys required to store data in the storage.
 */
export const messages = new PersistentVector<PostedMessage>("m");

Phân tích

@nearBindgen đánh dấu lớp là có thể tuần tự hóa. Serializable là một giao diện “đánh dấu” được sử dụng để các lớp đối tượng có thể có được một khả năng nhất định.

Lớp “PostedMessage” có ba tính năng:

• premium để gắn cờ các tin nhắn có token NEAR đính kèm
• sender để theo dõi người ký tin nhắn Guest Book
• text để giữ tin nhắn Guest Book

Cuối cùng, “messages” là một tập hợp các tin nhắn trong Guest Book được lưu trữ dưới dạng PersistentVector của các đối tượng PostedMessage

#2 Contract Behavior:  assembly/main.ts

import { PostedMessage, messages } from './model';
// --- contract code goes below
// The maximum number of latest messages the contract returns.
const MESSAGE_LIMIT = 10;
/**
 * Adds a new message under the name of the sender's account id.
 * NOTE: This is a change method. Which means it will modify the state.
 * But right now we don't distinguish them with annotations yet.
 */
export function addMessage(text: string): void {
  // Creating a new message and populating fields with our data
  const message = new PostedMessage(text);
  // Adding the message to end of the the persistent collection
  messages.push(message);
}
/**
 * Returns an array of last N messages.
 * NOTE: This is a view method. Which means it should NOT modify the state.
 */
export function getMessages(): PostedMessage[] {
  const numMessages = min(MESSAGE_LIMIT, messages.length);
  const startIndex = messages.length - numMessages;
  const result = new Array<PostedMessage>(numMessages);
  for(let i = 0; i < numMessages; i++) {
    result[i] = messages[i + startIndex];
  }
  return result;
}

Phân tích

MESSAGE_LIMIT được sử dụng để tránh các lệnh gọi không giới hạn (tức là có thể tốn nhiều phí) để lấy các tin nhắn trong Guest Book từ bộ nhớ

Chúng ta đang sử dụng hai chức năng công cộng khác nhau trong hợp đồng này là addMessage() và getMessages()

Frontend Code

#1 Kết nối mạng lưới :  src/config.js

const CONTRACT_NAME = process.env.CONTRACT_NAME || 'guest-book.testnet';
function getConfig(env) {
  switch(env) {
    case 'mainnet':
      return {
        networkId: 'mainnet',
        nodeUrl: 'https://rpc.mainnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.near.org',
        helperUrl: 'https://helper.mainnet.near.org'
      };
    // This is an example app so production is set to testnet.
    // You can move production to mainnet if that is applicable.
    case 'production':
    case 'development':
    case 'testnet':
      return {
        networkId: 'default',
        nodeUrl: 'https://rpc.testnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.testnet.near.org',
        helperUrl: 'https://helper.testnet.near.org'
      };
    case 'betanet':
      return {
        networkId: 'betanet',
        nodeUrl: 'https://rpc.betanet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.betanet.near.org',
        helperUrl: 'https://helper.betanet.near.org'
      };
    case 'local':
      return {
        networkId: 'local',
        nodeUrl: 'http://localhost:3030',
        keyPath: `${process.env.HOME}/.near/validator_key.json`,
        walletUrl: 'http://localhost:4000/wallet',
        contractName: CONTRACT_NAME
      };
    case 'test':
    case 'ci':
      return {
        networkId: 'shared-test',
        nodeUrl: 'https://rpc.ci-testnet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    case 'ci-betanet':
      return {
        networkId: 'shared-test-staging',
        nodeUrl: 'https://rpc.ci-betanet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    default:
      throw Error(`Unconfigured environment '${env}'. Can be configured in src/config.js.`);
  }
}
module.exports = getConfig;

Phân tích

Đoạn code trên xác định dữ liệu và điểm cuối cần thiết để kết nối với mạng lưới NEAR. Thông tin kết nối được xác định ở đây được bao gồm cho MainNet, TestNet và BetaNet cũng như cấu hình mặc định LocalNet.

#2 Cấu hình :  src/index.js

import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
import getConfig from './config.js';
import * as nearAPI from 'near-api-js';
// Initializing contract
async function initContract() {
  const nearConfig = getConfig(process.env.NODE_ENV || 'testnet');
  // Initializing connection to the NEAR TestNet
  const near = await nearAPI.connect({
    deps: {
      keyStore: new nearAPI.keyStores.BrowserLocalStorageKeyStore()
    },
    ...nearConfig
  });
  // Needed to access wallet
  const walletConnection = new nearAPI.WalletConnection(near);
  // Load in account data
  let currentUser;
  if(walletConnection.getAccountId()) {
    currentUser = {
      accountId: walletConnection.getAccountId(),
      balance: (await walletConnection.account().state()).amount
    };
  }
  // Initializing our contract APIs by contract name and configuration
  const contract = await new nearAPI.Contract(walletConnection.account(), nearConfig.contractName, {
    // View methods are read-only – they don't modify the state, but usually return some value
    viewMethods: ['getMessages'],
    // Change methods can modify the state, but you don't receive the returned value when called
    changeMethods: ['addMessage'],
    // Sender is the account ID to initialize transactions.
    // getAccountId() will return empty string if user is still unauthorized
    sender: walletConnection.getAccountId()
  });
  return { contract, currentUser, nearConfig, walletConnection };
}
window.nearInitPromise = initContract()
  .then(({ contract, currentUser, nearConfig, walletConnection }) => {
    ReactDOM.render(
      <App
        contract={contract}
        currentUser={currentUser}
        nearConfig={nearConfig}
        wallet={walletConnection}
      />,
      document.getElementById('root')
    );
  });

Phân tích

Đây là phần hấp dẫn nhất của phần giao diện người dùng, khi bạn cấu hình kết nối với mạng lưới NEAR. Bạn có thể cấu hình giao diện hợp đồng bằng cách chèn kết nối ví và kết nối cả hai phương thức hợp đồng.

Triển khai một hợp đồng thông minh

Mỗi hợp đồng thông minh trong NEAR đều có tài khoản liên kết riêng. Khi bạn chạy yarn dev, các hợp đồng thông minh của bạn sẽ được triển khai tới mạng lưới NEAR TestNet trực tiếp với một tài khoản tạm thời. Nếu bây giờ bạn muốn đặt nó vĩnh viễn, đây là những gì bạn cần làm.

Bước 0: Cài đặt near-cli

Đây là cách bạn cài đặt near-cli

npm install --global near-cli

Điều này sẽ cung cấp cho bạn công cụ near CLI. Đảm bảo rằng nó được cài đặt với:

near --version

Bước 1: Tạo tài khoản cho hợp đồng

Truy cập NEAR Wallet và tạo một tài khoản mới. Bạn sẽ triển khai các hợp đồng thông minh đến tài khoản mới này.

Bây giờ ủy quyền NEAR CLI cho tài khoản mới này và làm theo hướng dẫn:

near login

Bước 2: Đặt tên hợp đồng

Sửa đổi dòng trong src/config.js đặt tên tài khoản của hợp đồng. Đặt nó thành ID tài khoản bạn đã sử dụng ở trên.

const CONTRACT_NAME = process.env.CONTRACT_NAME || 'your-account-here!'

Bước 3: Đổi cách kết nối URL từ xa nếu bạn đã sao chép repo (nơi lưu trữ). Trừ khi bạn đã phân tách kho lưu trữ, bạn sẽ cần phải thay đổi cách kết nối URL từ xa tới một kho lưu trữ mà bạn có quyền truy cập đến. Thực hiện những bước sau sẽ cho phép tự động triển khai đổi cách kết nối URL từ xa lên trang Github:

1. 1.  Truy cập GitHub và tạo một kho lưu trữ mới cho dự án này.
   2. Mở giao diện dòng lệnh của bạn và vào bên trong thư mục gốc (root project) của dự án này, nhập thông tin sau:

$ `git remote set-url origin https:/Bước 3: Đổi cách kết nối URL từ xa nếu bạn đã sao chép repo (nơi lưu trữ). Trừ khi bạn đã phân tách kho lưu trữ, bạn sẽ cần phải thay đổi cách kết nối URL từ xa tới một kho lưu trữ mà bạn có quyền truy cập đến. Thực hiện những bước sau sẽ cho phép tự động triển khai đổi cách kết nối URL từ xa lên trang Github: 1. Truy cập GitHub và tạo một kho lưu trữ mới cho dự án này. 2. Mở giao diện dòng lệnh của bạn và vào bên trong thư mục gốc (root project) của dự án này, nhập thông tin sau:om/YOUR_USERNAME/YOUR_REPOSITORY.git`

Bước 4: Triển khai

Bạn chỉ cần lệnh sau để triển khai hợp đồng thông minh của mình:

yarn deploy

Lệnh này thực hiện hai điều:

• Xây dựng và triển khai các hợp đồng thông minh cho NEAR TestNet
• Xây dựng và triển khai code frontend cho GitHub bằng cách sử dụng gh-pages. Điều này sẽ chỉ hoạt động nếu dự án đã có một kho lưu trữ được thiết lập trên GitHub. Vui lòng sửa script triển khai trong package.json để triển khai ở nơi khác.

What Next?

Vừa rồi chúng ta đã đi qua những thông tin cơ bản và giờ đây bạn đã biết cách chạy các dòng code cơ bản, tìm hiểu sâu hơn và chi tiết hơn nữa trên NEAR có thể xem các tài liệu dành cho nhà phát triển.