Bagaimana Membangun di NEAR? Panduan Awal

10 min read
To Share and +4 nLEARNs

Prasyarat

Developers adalah sumber kehidupan ekosistem blockchain. Agar teknologi blockchain mendapatkan mainstream adoption (keadaan ketika blockchain menjadi biasa dan sudah melekat menjadi bagian dari masyarakat), perlu dengan diturunkannya hambatan masuk bagi developer dan memungkinkan mereka untuk membuat aplikasi yang menyenangkan dan juga canggih agar dapat dinikmati semua kalangan. Karena alasan inilah smart contract NEAR ditulis dengan menggunakan AssemblyScript karena kemiripannya dengan JavaScript.

Jadi, apabila kamu ingin membangun di NEAR, kamu bisa menggunakan tools berikut,

  • JavaScript SDK. Sambungkan (connect), tandatangani (sign), transaksikan (transact), dan sebarkan (deploy) ke jaringan NEAR mana pun dari konteks JS mana pun juga
  • Rust Contract SDK. Bangun contract yang aman dan terjamin yang mengelola aset bernilai tinggi
  • AssemblyScript Contract SDK. Pelajari dan lakukan prototype dengan zero friction menggunakan JS syntax
  • JSON RPC API. Semua komunikasi dengan menggunakan platform yang melewati API jenis ini juga termasuk milik kami.
  • Command Line Interface. Command line toolkit berfitur lengkap diperuntukkan kepada developers dan validators
  • NEAR Explorer. Alat pencarian blockchain (blockchain search tool) yang memungkinkan developers untuk melihat detail transaksi, akun, detail blokir, dan lainnya
  • NEAR Wallet. Buat akun (create account), kelola kunci akses (manage access key), dan lainnya dengan UI yang ramah pengguna.
  • nearup. Kelola deployment secara lokal dan gabung dengan public network maupun private network manapun
  • Bridge. Interoperabilitas yang cepat dan aman
  • EVM. Mesin virtual yang kompatibel dengan Ethereum

Baiklah, mari kita lakukan langkah pertama.

Tinjauan Singkat

Aplikasi di NEAR memiliki dua bagian yang berbeda – back-end dan front-end.

Smart Contract (back-end): Menyimpan dan memodifikasi data pada rantai. Contract perlu mengekspos metode yang memungkinkan klien untuk “melihat” dan “mengubah” keadaan.

Interaksi dengan Smart Contract (front-end): Anda dapat berinteraksi dengan contract Anda atau contract yang disebarkan oleh orang lain. Anda melakukan hal ini dengan menggunakan bantuan near-api-js Quickstart dan Code Snippets di aplikasi Anda.

Express quiz +2 nLEARNs

Aplikasi di NEAR memiliki dua bagian yang berbeda – back-end dan front-end. Yang merupakan back-end adalah…

Correct! Wrong!

Cara Membangun dan Memanggil Smart Contracts

NEAR saat ini men-support:

  • Rust – near-sdk-rs: “Pembungkus” yang menyediakan keamanan yang telah berimprovisasi untuk bahasa pemrograman Rust pada contract bernilai tinggi.
  • AssemblyScript near-sdk-as: Sekumpulan bantuan yang membuat SmartContracts Anda terlihat mirip dengan TypeScript saat dikompilasi dengan Wasm untuk dieksekusi.

CATATAN: AssemblyScript saat ini tidak direkomendasikan untuk aplikasi keuangan produksi karena barunya bentuk bahasa dan alat kompilasi yang tersedia.

Baiklah, mari kita serius.

Setting Up Testnet

Cara termudah untuk membuat akun di NEAR adalah dengan NEAR Wallet. NEAR memiliki beberapa jaringan pengembangan yang beroperasi secara independen satu sama lain dengan accountIDs mereka sendiri. Ayo, ikuti langkah-langkah untuk membuat wallet. Pastikan Anda telah mengikuti langkah-langkah yang diperlukan untuk cadangan keamanan Anda.

CATATAN: Membuat akun di mainnet hampir sama dengan membuat akun di testnet, tetapi akan dibutuhkan dana awal untuk akun di Mainnet. Berikut adalah panduan untuk pembuatan akun mainnet.

Tidak masalah ketika saat men-deploy, apakah aplikasi ditulis dalam Rust atau AssemblyScript. Semua kode kontrak (contract code) dikompilasi ke WebAssembly dan disebarkan (deploy) ke jaringan untuk dijalankan di dalam Wasm-compatible virtual machine. Anda akan memakai perintah seperti yarn dev untuk sebagian besar aplikasi, tetapi Anda akan dapat dengan mudah menerapkan aplikasi menggunakan NEAR CLI dengan near dev-deploy untuk TestNet (atau near deploy jika Anda telah membuat akun).

Semua kode contract dikompilasi ke WebAssembly dan disebarkan ke jaringan untuk dijalankan di dalam _______

Correct! Wrong!

Sekarang, lakukan hal berikut sebagai pemanasan:

  1. Lihatlah di NEAR Explorer. Di sini kamu bisa mencari seluruh transaksi dan blocks yang dihasilkan di NEAR. Coba cari akun yang baru saja Anda buat dan lihat transaksi yang telah Anda buat.
  2. Sekarang instal near-cli. Ini adalah command line interface yang memungkinkan Anda berinteraksi secara lancar dengan NEAR. Dokumen NEAR ini memiliki semua perintah near-cli dengan banyak contoh.
  3. Coba jalankan perintah pertama Anda: near login. Ini akan mengarahkanmu ke NEAR Wallet Anda dan menyimpan kunci akun testnet Anda secara lokal.

Setelah memeriksa testnet, Anda boleh menjalankan local node-mu. Namun, jika Anda hanya ingin bermain-main dengan kode, kami sarankan Anda tetap menggunakan testnet.

Bagaimana Saya Menjalankan Node?

Seperti ekosistem berbasis blockchain lainnya, NEAR Protocol berjalan di atas sekumpulan komputer yang dikelola secara publik (atau “node”).

Anda dapat memutuskan untuk menjalankan node Anda sendiri karena beberapa alasan:

  • Untuk mengembangkan dan menerapkan contract pada node yang terhubung ke MainNet, TestNet, atau BetaNet
  • Untuk mengembangkan dan menyebarkan contract pada node lokal (independen dan terisolasi) (terkadang disebut “LocalNet”).
  • Untuk bergabung dengan sebuah jaringan sebagai validator yang menjalankan “validator node”

Anda dapat meluncurkan node NEAR betanet dan testnet dengan menginstal nearup. Anda dapat melakukannya dengan mengikuti petunjuk di https://github.com/near/nearup

Express quiz +2 nLEARNs

Seperti ekosistem berbasis blockchain lainnya, NEAR Protocol berjalan di atas sekumpulan komputer yang dikelola secara publik yang disebut _______

Correct! Wrong!

Menjalankan Official Node menggunakan Docker

Secara standar, NEAR menggunakan Docker untuk menjalankan client. Maka, hal pertama yang Anda lakukan adalah menginstal Docker dan nearup. Sekarang, jalankan sistem Anda dengan ini:

nearup betanet

(Jika Anda lebih suka menggunakan TestNet maka ganti saja betanet dengan testnet pada perintah di atas)

Kemudian anda akan diminta sebuah ID Akun. Anda dapat membiarkannya kosong jika Anda hanya ingin menjalankan sebuah node. Validator harus menggunakan ID akun dari akun yang ingin Anda jadikan percobaan. Setelah itu, Anda harus memasukkan kode ini:

Masukkan ID akun Anda (biarkan kosong jika tidak akan menjadi validator)

Sekarang, node Anda akan mulai di background dengan Docker. Untuk memeriksa log di dalam Docker, jalankan docker logsfollow nearcore.

Membuat Kode Sederhana Pada NEAR

NEAR memiliki daftar program yang bermanfaat atau kode contoh (code examples) yang dapat Anda lihat dengan mudah. Jadi, kode yang akan kita periksa adalah Guest Book. Menggunakan program memungkinkan Anda masuk dengan NEAR dan menambahkan pesan ke Guest Book! Sebuah aplikasi awal yang dibuat dengan backend AssemblyScript dan frontend React.

Melihat Guest Book Code

Untuk menjalankan project ini secara lokal, Anda perlu memastikan hal berikut.

  • Pastikan Anda telah menginstal Node.js ≥ 12 (https://nodejs.org), lalu gunakan untuk menginstal yarn: npm install –global yarn (atau cukup npm i -g yarn)
  • Instal dependencies: yarn install (atau hanya yarn)
  • Jalankan local development server: yarn dev (lihat package.json untuk daftar lengkap script yang dapat Anda jalankan dengan yarn)

Sekarang Anda akan memiliki local development server yang didukung oleh NEAR TestNet! Menjalankan yarn dev akan membuat Anda menjadi tahu URL mana yang dapat Anda kunjungi di browser untuk melihat aplikasi.

Oh dan juga pastikan Anda telah membuka halaman GitHub.

Anda mungkin akan membutuhkan video dibawah ini.

<iframe width=”561″ height=”316″ src=”https://www.youtube.com/embed/B6Gc_OQjX9E” title=”NEAR from Scratch: AssemblyScript Project Setup” frameborder=”0″ allow=”accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share” allowfullscreen></iframe>

Menjelajahi Kode

Seperti yang Anda ketahui, ada dua sisi kode – backend dan frontend:

Kode backend berada di folder /assembly. Kode ini diterapkan ke blockchain NEAR saat Anda menjalankan yarn deploy: contract. Ini adalah smart contract NEAR.

Kode frontend berada di folder /src. /src/index.html adalah tempat yang bagus untuk memulai penjelajahan. Perhatikan bahwa itu dimuat di /src/index.js, di mana Anda dapat mempelajari bagaimana frontend terhubung ke blockchain NEAR.

Kode Backend (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&lt<PostedMessage>("m");

Analisa

@nearBindgen menandai kelas sebagai sesuatu yang serializable. Serializable adalah sebuah marker interface yang digunakan untuk “menandai” kelas sehingga objek dari kelas tersebut dapat memperoleh kemampuan tertentu.

Kelas “PostedMessage” memiliki tiga fitur –

  • premium untuk menandai pesan dengan token NEAR terlampir
  • sender untuk melacak penandatangan guest book message
  • text untuk menyimpan guest book message

Terakhir, “messages” adalah kumpulan guest book message yang disimpan sebagai PersistentVector dari objek 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&lt;PostedMessage&gt;(numMessages);

  for(let i = 0; i <  numMessages; i++) {

    result[i] = messages[i + startIndex];

  }

  return result;

}

Analisa

MESSAGE_LIMIT digunakan untuk menghindari panggilan tak terbatas (yaitu berpotensi mahal) untuk mengambil guest book message dari penyimpanan

Kami juga menggunakan dua fungsi publik yang berbeda dalam kontrak ini – addMessage() dan getMessages()

Kode Frontend (Frontend Code)

#1 Network Connection :  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;

Analisa

Kode di atas menentukan data dan endpoint yang diperlukan untuk terhubung ke jaringan NEAR. Informasi koneksi yang ditentukan di sini disertakan untuk MainNet, TestNet, dan BetaNet serta default LocalNet configuration

#2 Configuration : 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 }) =&gt; {

    ReactDOM.render(

      &lt;App

        contract={contract}

        currentUser={currentUser}

        nearConfig={nearConfig}

        wallet={walletConnection}

      /&gt;,

      document.getElementById('root')

    );

  });

Analisa

Ini adalah hal-hal yang mendasar namun fundamental dari bagian front-end, saat Anda mengonfigurasi koneksi ke jaringan NEAR. Anda dapat mengonfigurasi contract interface dengan menyuntikkan wallet connection dan menyambungkan kedua metode kontrak.

Menyebarkan (Deploying) Smart Contract

Setiap smart contract di NEAR memiliki akun yang terasosiasi. Saat Anda menjalankan yarn dev, smart contract Anda diterapkan ke TestNet NEAR langsung dengan akun sementara. Jika sekarang Anda ingin menjadikannya permanen, inilah yang perlu Anda lakukan.

Langkah 0: Instal near-cli

Inilah cara Anda memasang near-cli secara global

npm install –global near-cli

Dengan begitu anda akan mendapatkan NEAR CLI tool. Pastikan ini diinstal dengan:

near –version

Langkah 1: Buat akun untuk kontrak

Kunjungi NEAR Wallet dan buat akun baru. Anda akan men-deploy smart contract ke akun baru tersebut.

Sekarang beri otorisasi NEAR CLI untuk akun baru dan ikuti instruksi yang diberikan kepada Anda:

near login

Langkah 2: Tetapkan nama kontrak dalam kode

Ubah baris di src/config.js yang menetapkan nama akun kontrak. Pasang ke id akun yang Anda gunakan di atas.

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

Langkah 3: Ubah remote URL jika Anda mengkloning repo ini

Jika Anda mem-fork repositori, Anda perlu mengubah remote URL ke repo yang aksesnya telah “terikat” dengan anda. Hal ini akan memungkinkan penerapan otomatis ke Halaman Github dari baris perintah.

  1. Buka GitHub dan buat sebuah repositori baru untuk project ini.
  2. Buka terminal anda dan pada root project dan masukan seperti yang berikut ini:

$ `git remote set-url origin https://github.com/YOUR_USERNAME/YOUR_REPOSITORY.git`

Langkah 4: Deploy!

Anda hanya perlu perintah berikut untuk men-deploy smart contract anda:

yarn deploy

Perintah ini melakukan dua hal:

  • Mem-build dan men-deploy smart contract pada NEAR TestNet
  • Mem-build dan men-deploy kode frontend contract ke GitHub menggunakan gh-pages. Hal ini hanya akan bisa berlaku apabila project sudah memiliki repositori yang telah disiapkan di GitHub.

Setiap smart contract di NEAR memiliki ____ yang terasosiasi.

Correct! Wrong!

Apa Selanjutnya?

Baiklah, sekarang setelah Anda tahu cara menjalankan basic code, Anda mungkin ingin mempelajari NEAR lebih dalam. Untuk itu, coba lihat dokumen NEAR developer.

 

Generate comment with AI 2 nL

Tinggalkan Komentar

Hire AI to help with Comment

To leave a comment you should to:


Scroll to Top
Wheel of Transactions NEAR Testnet
This is default text for notification bar
Report a bug👀