Cara Membuat Smart Contract NEAR Protocol Dengan Mudah

Bagaimanakah cara membuat smart contract NEAR dengan mudah? Melalu langkah demi langkah yang akan kami bagikan ini, kami berharap tutorial ini akan sangat muadah dipahami bahkan untuk pemula sekalipun. Sebelum kita masuk ke inti dari pembahasannya, yuk sama-sama kita ketahui apa itu NEAR Protocol, kekurangan dan kelebihannya, bahasa apa saja yang dipakai untuk membuat smart contract NEAR? Simak beberapa ulasannya di bawah ini ya:

NEAR Protocol terkenal dengan ekosistemnya, yang menyediakan lingkungan yang paling cocok untuk membangun dApps. Dengan menggunakan protokol ini, pengembang dapat meng-host aplikasi tanpa server dan Smart Contract untuk menghubungkan ke jaringan keuangan terbuka dan mendapatkan manfaat dari ekosistem Smart Contract yang dapat digunakan kembali. NEAR protocol lebih disukai oleh pengembang dan pengguna karena antarmuka pengguna yang nyaman, keamanan dan skalabilitasnya.

NEAR Protocol membantu dengan cara berikut:

  • Pembuatan Aplikasi
    Ini membantu dalam mengembangkan dApps dengan menyediakan platform pengembangan yang mudah.
  • Antarmuka Pengguna Yang Mudah Dipahami
    Bergabung dengan lancar di NEAR Protocol karena antarmuka pengguna yang nyaman untuk menggunakan kripto, token, dompet, kunci, atau artefak blockchain lainnya.
  • Skalabilitas
    Ini membantu menskalakan aplikasi dengan mulus melalui proses sharding. NEAR Protocol memperluas kapasitasnya untuk menskalakan dApps melalui sharding tanpa biaya atau upaya tambahan dari pihak pengguna.

Tidak seperti infrastruktur cloud terpusat, NEAR memiliki infrastruktur berbasis cloud terdesentralisasi yang digunakan oleh pengembang untuk membangun aplikasi di atasnya. Pusat data terdesentralisasi dari NEAR Protocol ini merupakan orang-orang di seluruh dunia yang mengoperasikan node di dalam jaringan. Dengan demikian, NEAR Protocol memiliki infrastruktur berbasis cloud yang dioperasikan oleh komunitas.

Sangat penting bagi setiap platform blockchain untuk memiliki hambatan pengembang yang rendah, untuk adopsi arus utamanya. Ini menjadi faktor penting dalam pemilihan platform blockchain, NEAR adalah salah satu platform termudah dan terbaik untuk mengembangkan dApps dengan mudah di dalamnya. Untuk membangun aplikasi terdesentralisasi di blockchain, Smart Contract diperlukan untuk mengatur proses pengembangan. Untuk mencukupi pembuatan Smart Contract yang mudah, NEAR Protocol mendukung AssemblyScript karena kesamaannya dengan JavaScript dan kemudahannya dalam menulis Smart Contract.

Artikel ini akan membantu Kamu mengungkap proses langkah demi langkah pembuatan smart contract NEAR Protocol.

Sekilas Tentang NEAR Protocol

NEAR Protocol adalah salah satu contoh terbaik dari blockchain generasi ke-3. Ini berfokus pada pemecahan masalah skalabilitas dan memberi insentif kepada jaringan untuk mengembangkan dan meluncurkan aplikasi terdesentralisasi pada ekosistem DeFi. NEAR Protocol menghasilkan keuntungan dengan melakukan staking dan sharding pada platform jaringan. Ini mengatasi kelemahan tertentu seperti kecepatan rendah, throughput rendah, dan kompatibilitas cross-chain yang dapat diabaikan.

Konsep inti dari desain NEAR Protocol didasarkan pada sharding. Ini mengurangi beban komputasi dengan berfokus pada pemisahan infrastruktur jaringan menjadi bagian-bagian berbeda yang dikenal sebagai node, untuk mengelola sebagian kecil dari transaksi platform. Pemisahan node jaringan misalnya adalah bahwa setiap node yang menjalankan semua kode jaringan membantu dalam pengambilan dan penskalaan data yang mudah di jaringan yang terdesentralisasi.

Jaringan blockchain NEAR tidak memiliki izin dan aman. Inovasinya terdiri dari mekanisme konsensus berbeda yang dikenal sebagai ‘Doomslug’. Struktur NEAR juga didasarkan pada mekanisme konsensus Proof-of-Stake. Ini adalah platform yang dijalankan komunitas untuk cloud computing.

NEAR berfungsi dengan cara yang sama seperti platform penyimpanan data terpusat. Misalnya, Amazon Web Services (AWS), berfungsi dalam bentuk lapisan dasar tempat aplikasi dikembangkan. Satu-satunya perbedaan antara AWS dan NEAR adalah bahwa NEAR dikelola oleh jaringan komputer terdistribusi dan bukan otoritas tunggal. Mirip dengan AWS, NEAR memungkinkan fasilitasi struktur yang dibangun di sekitar jaringan rantai komputer dan token asli NEAR.

Platform ini memiliki beberapa komponen yang diperlukan untuk membangunnya:

  • Token asli bernama NEAR
  • Mintbase
  • Platform Pencetakan NFT
  • Flux protocol untuk pembuatan pasar pengembang berdasarkan komoditas, aset, dll

Sekarang mari kita jelajahi bagian-bagian berbeda dari aplikasi NEAR di bagian berikutnya dalam konteks lapisan Smart Contractnya.

Ada dua bagian berbeda dari aplikasi NEAR

Aplikasi web NEAR memiliki dua bagian yang berbeda dalam bentuk front-end dan back-end:

  • Smart Contract
    Mereka mengelola penyimpanan dan modifikasi data secara on-chain. Smart contract membutuhkan pengungkapan cara-cara yang akan membantu klien untuk “melihat” dan “mengubah” keadaannya.
  • Interaksi dengan Smart Contract
    Mirip dengan cloud API, Kita berhak untuk berinteraksi dengan kontrak Kita atau kontrak yang disebarkan oleh orang lain. Kita melakukan ini dengan menggunakan Quickstart near-api-js dan Code Snippets yang tersedia di aplikasi.

Fitur near-api-js

Dasar dari API platform NEAR adalah antarmuka JSON-RPC. Near-api-js membungkus antarmuka RPC bersama dengan fungsi kenyamanan dan memunculkan NEAR primitives dalam bentuk objek JavaScript. near-api-js digunakan sebagai antarmuka utama dengan NEAR Protocol pada saat menulis JavaScript (klien atau sisi server). near-api-js memiliki fitur berikut:

  • Generasi key pairs
  • Pembuatan transaksi
  • Penandatanganan transaksi
  • Mengirimkan transaksi melalui jaringan

near-api-js juga menyediakan dukungan untuk berinteraksi dengan primitif penting lainnya dari sistem NEAR seperti yang disebutkan di bawah ini:

  • Toko kunci dan kunci
  • Akun
  • Kontrak
  • Dompet (khusus sisi klien)
  • Penyedia koneksi (saat ini RPC)

Sekarang setelah kita mengenal dua bagian berbeda dari aplikasi NEAR, mari kita buka alat dan bahasa yang diperlukan untuk menulis dan mengkompilasi smart contract NEAR di bagian berikutnya.

Bahasa dan Alat Yang Digunakan Untuk Menyusun Smart Contract NEAR

Kita dapat menggunakan bahasa apa pun yang didukung oleh Web Assembly (Wasm) untuk mengkompilasi Smart Contract NEAR Protocol, tetapi saat ini yg mendukung adalah berikut:

Rust (near-sdk-rs)

Rust adalah pembungkus yang membantu meningkatkan keamanan bahasa pemrograman Rust yang digunakan untuk menulis smart contract bernilai tinggi.

AssemblyScript (near-sdk-as)

AssemblyScript adalah sekelompok pembantu yang membantu agar smart contract NEAR terlihat sama dengan TypeScript sambil mengompilasinya dalam wasm untuk secara khusus menjalankannya. Saat ini tidak digunakan dalam pengembangan aplikasi desentralisasi keuangan karena bahasa pemrograman yang baru dan alat kompilasi yang terkait dengannya.

Sekarang setelah kita mengetahui tentang bahasa dan alat yang digunakan untuk mengembangkan smart contract NEAR, Mari kita lihat dengan cepat dasar-dasar panggilan dan penerapan Smart Contract.

  • Memanggil Smart Contract NEAR Protocol
    Untuk menyelesaikan panggilan JSON-RPC, gunakan Quickstarts dan Code Snippets near-api-js.
  • Cara Menyebarkan Smart Contract
    Ada testnet di mana kita diizinkan untuk menjalankan jaringan lokal dan mainnet kita seperti di Platform NEAR. Status smart contract didasarkan pada jenis jaringan yang digunakannya dan jika kita ingin memanggilnya dari jaringan yang sama, kita perlu memeriksa konfigurasi kita saat menerapkan, menguji, dan memanggil smart contract.

Cara Membuat Smart Contract NEAR Dengan Rust

  1. Install Rust toolchain
  2. Membuat Akun NEAR
  3. Memesan ID Akun NEAR
  4. Amankan Akun Kamu
  5. Pemulihan Akun Email/Nomor Kontak
  6. Menginstal near-cli
  7. Pembuatan Repositori Smart Contract NEAR
  8. Membuat File Smart Contract NEAR
  9. Mengedit Cargo.toml
  10. Membuat Lib.rs
  11. Struktur
  12. Tes Unit
  13. Menulis Tes
  14. Uji dan kompilasi
  15. Uji kodenya
  16. Kompilasi kodenya
  17. Menyebarkan Smart Contract NEAR

Dari langkah-langkah di atas akan memandu Kamu semua dalam proses membuat, menguji, dan menjalankan pada smart contract NEAR Protocol. Contoh yang ada pada bagian ini adalah smart contract sederhana yang berfungsi dalam bentuk Counter, incrementing, decrementing dan return counter value.

Menulis smart contract pada platform blockchain adalah perubahan paradigma yang besar. Saat ini, ada konsep smart contract tertentu yang menjadi fokus seperti status kontrak, transfer, akun, dan informasi saldo. Bahasa pilihan untuk menulis Smart Contract Near adalah Rust.

Persyaratan

  • Rust toolchain
  • Akun NEAR
  • NEAR command-line interface (near-cli)

Siapkan persyaratan

Menggunakan Rust environment , buat akun NEAR dan kemudian install near-cli.

Cara Install Rust toolchain

1. Instal Rustup

Jalankan perintah berikut untuk menginstal Rustup:

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

2. Konfigurasikan shell saat ini

Masukkan perintah berikut untuk konfigurasi shell Kamu saat ini:

source $HOME/.cargo/env

3. Tambahkan target wasm ke jaringan blockchain

Run,

rustup target add wasm32-unknown-unknown

Cara Membuat Akun NEAR

Buat akun NEAR melalui dompet NEAR. NEAR memiliki berbagai jaringan pengembangan yang berfungsi secara independen melalui ID akun mereka sendiri.

Buat akun testnet, jika Kamu sudah memiliki akun testnet, Kamu tidak perlu mengikuti langkah-langkah yang disebutkan di bawah ini:

Cara memesan ID Akun NEAR

  • Cari ke https://wallet.testnet.near.org dan pilih opsi ‘buat akun’
  • Kemudian, masukkan nama akun yang ingin Kamu gunakan

Amankan Akun Kamu

Pilih metode pemulihan akun Kamu. Frase pemulihan dan ledger adalah dua metode yang paling aman.

Pemulihan Akun Email/Nomor Kontak

Masukkan kode aktivasi akun yang Kamu dapatkan dan kemudian akun testnet dibuat. Setelah metode pemulihan diikuti Kamu juga akan diarahkan ke dashboard akun Kamu.

Cara Menginstal near-cli

Ikuti langkah-langkah yang disebutkan di bawah ini untuk menginstal near-cli. Kamu dapat melewati langkah-langkah ini jika Kamu sudah memiliki command-line interface:

Linux dan macOS

  • Instal npm dan node melalui manajer paket seperti nvm.
  • Periksa apakah Kamu telah menginstal npm dan NodeJS versi terbaru di sistem Kamu.
  • Instal secara global near-cli dengan menjalankan perintah berikut, npm install -g near-cli.

Windows

Gunakan Subsistem Windows untuk Linux (WSL).

  • Instal WSL.
  • Kemudian instal Node.js.
  • Kemudian ubah direktori default npm.
  • Klik WSL dan instal secara global near-cli dengan menjalankan perintah berikut: npm install -g near-cli.

Cara Pembuatan Repositori Smart Contract NEAR

Buat repositori proyek baru dengan bantuan kargo. Untuk ini, Kamu perlu menavigasi kembali ke direktori proyek dan kemudian menjalankan perintah berikut:

$ cargo new rust-counter-tutorial
$ cd rust-counter-tutorial

Perintah-perintah ini menyediakan direktori baru yang dikenal sebagai rust-counter-tutorial. Kamu dapat menamai file tersebut sebagai project rust-counter-tutorial. Cargo akan membuat file di direktori dengan nama yang mirip.

Cargo akan menghasilkan dua file dan sekarang direktori: file Cargo.toml dan direktori src dengan file main.rs di dalamnya.

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

Cara Membuat File Smart Contract NEAR

Untuk pembuatan file, smart contract NEAR memiliki tata letak yang sangat sederhana:

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

Smart contract NEAR memiliki file utama yang berisi kode: ./src/lib.rs

Ini adalah nama file konvensional Rust library’s. Libraries bekerja dengan lancar untuk melakukan kompilasi di WebAssembly dan untuk menyebarkan ke blockchain.

Cara Mengedit Cargo.toml

Klik dan buka Cargo.toml di editor teks pilihan Kamu. File akan dalam format Tam’s Obvious Minimal Language (TOML). TOML adalah format konfigurasi Cargo yang sama dengan file package.json. Selanjutnya, ganti seluruh konten dengan perintah berikut dari file Cargo.toml,

/Cargo.toml

[package]
name = "rust-counter-tutorial"
version = "0.1.0"
authors = ["NEAR Inc <[email protected]>"]
edition = "2018"

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

[dependencies]
near-sdk = "3.1.0"

[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

Cara Membuat Lib.rs

Buat file ./src/lib.rs di editor teks. Salin dan tempel konten file lib.rs. Instance ini menggunakan file lib.rs bersama dengan smart contract logics melalui struct, fungsi struct, dan unit test. Semua ini akan berada dalam satu file tunggal dengan menjalankan perintah yang disebutkan di bawah ini,

/src/lib.rs

//! This contract implements simple counter backed by storage on blockchain.
//!
//! The contract provides methods to [increment] / [decrement] counter and
//! [get it's current value][get_num] or [reset].
//!
//! [increment]: struct.Counter.html#method.increment
//! [decrement]: struct.Counter.html#method.decrement
//! [get_num]: struct.Counter.html#method.get_num
//! [reset]: struct.Counter.html#method.reset

use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::{env, near_bindgen};

near_sdk::setup_alloc!();

// add the following attributes to prepare your code for serialization and invocation on the blockchain
// More built-in Rust attributes here: https://doc.rust-lang.org/reference/attributes.html#built-in-attributes-index
#[near_bindgen]
#[derive(Default, BorshDeserialize, BorshSerialize)]
pub struct Counter {
// See more data types at https://doc.rust-lang.org/book/ch03-02-data-types.html
val: i8, // i8 is signed. unsigned integers are also available: u8, u16, u32, u64, u128
}

#[near_bindgen]
impl Counter {
/// Returns 8-bit signed integer of the counter value.
///
/// This must match the type from our struct's 'val' defined above.
///
/// Note, the parameter is `&self` (without being mutable) meaning it doesn't modify state.
/// In the frontend (/src/main.js) this is added to the "viewMethods" array
/// using near-cli we can call this by:
///
/// ```bash
/// near view counter.YOU.testnet get_num
/// ```
pub fn get_num(&self) -> i8 {
return self.val;
}

/// Increment the counter.
///
/// Note, the parameter is "&mut self" as this function modifies state.
/// In the frontend (/src/main.js) this is added to the "changeMethods" array
/// using near-cli we can call this by:
///
/// ```bash
/// near call counter.YOU.testnet increment --accountId donation.YOU.testnet
/// ```
pub fn increment(&mut self) {
// note: adding one like this is an easy way to accidentally overflow
// real smart contracts will want to have safety checks
// e.g. self.val = i8::wrapping_add(self.val, 1);
// https://doc.rust-lang.org/std/primitive.i8.html#method.wrapping_add
self.val += 1;
let log_message = format!("Increased number to {}", self.val);
env::log(log_message.as_bytes());
after_counter_change();
}

/// Decrement (subtract from) the counter.
///
/// In (/src/main.js) this is also added to the "changeMethods" array
/// using near-cli we can call this by:
///
/// ```bash
/// near call counter.YOU.testnet decrement --accountId donation.YOU.testnet
/// ```
pub fn decrement(&mut self) {
// note: subtracting one like this is an easy way to accidentally overflow
// real smart contracts will want to have safety checks
// e.g. self.val = i8::wrapping_sub(self.val, 1);
// https://doc.rust-lang.org/std/primitive.i8.html#method.wrapping_sub
self.val -= 1;
let log_message = format!("Decreased number to {}", self.val);
env::log(log_message.as_bytes());
after_counter_change();
}

/// Reset to zero.
pub fn reset(&mut self) {
self.val = 0;
// Another way to log is to cast a string into bytes, hence "b" below:
env::log(b"Reset counter to zero");
}
}

// unlike the struct's functions above, this function cannot use attributes #[derive(…)] or #[near_bindgen]
// any attempts will throw helpful warnings upon 'cargo build'
// while this function cannot be invoked directly on the blockchain, it can be called from an invoked function
fn after_counter_change() {
// show helpful warning that i8 (8-bit signed integer) will overflow above 127 or below -128
env::log("Make sure you don't overflow, my friend.".as_bytes());
}

/*
* the rest of this file sets up unit tests
* to run these, the command will be:
* cargo test --package rust-counter-tutorial -- --nocapture
* Note: 'rust-counter-tutorial' comes from cargo.toml's 'name' key
*/

// use the attribute below for unit tests
#[cfg(test)]
mod tests {
use super::*;
use near_sdk::MockedBlockchain;
use near_sdk::{testing_env, VMContext};

// part of writing unit tests is setting up a mock context
// in this example, this is only needed for env::log in the contract
// this is also a useful list to peek at when wondering what's available in env::*
fn get_context(input: Vec, is_view: bool) -> VMContext {
VMContext {
current_account_id: "alice.testnet".to_string(),
signer_account_id: "robert.testnet".to_string(),
signer_account_pk: vec![0, 1, 2],
predecessor_account_id: "jane.testnet".to_string(),
input,
block_index: 0,
block_timestamp: 0,
account_balance: 0,
account_locked_balance: 0,
storage_usage: 0,
attached_deposit: 0,
prepaid_gas: 10u64.pow(18),
random_seed: vec![0, 1, 2],
is_view,
output_data_receivers: vec![],
epoch_height: 19,
}
}

// mark individual unit tests with #[test] for them to be registered and fired
#[test]
fn increment() {
// set up the mock context into the testing environment
let context = get_context(vec![], false);
testing_env!(context);
// instantiate a contract variable with the counter at zero
let mut contract = Counter { val: 0 };
contract.increment();
println!("Value after increment: {}", contract.get_num());
// confirm that we received 1 when calling get_num
assert_eq!(1, contract.get_num());
}

#[test]
fn decrement() {
let context = get_context(vec![], false);
testing_env!(context);
let mut contract = Counter { val: 0 };
contract.decrement();
println!("Value after decrement: {}", contract.get_num());
// confirm that we received -1 when calling get_num
assert_eq!(-1, contract.get_num());
}

#[test]
fn increment_and_reset() {
let context = get_context(vec![], false);
testing_env!(context);
let mut contract = Counter { val: 0 };
contract.increment();
contract.reset();
println!("Value after reset: {}", contract.get_num());
// confirm that we received -1 when calling get_num
assert_eq!(0, contract.get_num());
}
}

Mari kita memahami beberapa kode yang disebutkan di atas dengan memecahnya di bagian lain dari artikel ini.

use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::{env, near_bindgen};

Kamu akan melihat input standar di bagian atas file ini. Semua paket yang mengikuti pernyataan penggunaan disimpan di Cargo.toml dalam dependensi. Semua impor yang melibatkan serialisasi digunakan untuk mengelompokkan kode/penyimpanan, sehingga semuanya disiapkan untuk blockchain.

Disebutkan di bawah ini adalah beberapa cuplikan dari file lib.rs,

#[near_bindgen]
#[derive(Default, BorshDeserialize, BorshSerialize)]
pub struct Counter {
val: i8, // i8 is signed. unsigned integers are also available: u8, u16, u32, u64, u128
}

#[near_bindgen]
impl Counter {

Saat Kamu menulis smart contract, formatnya adalah menerima struct dengan impl terkait, di mana Kamu dapat menulis logika fundamental dalam bentuk fungsi.

Struktur

Kamu akan mendeklarasikan Counter dan impl Kamu, dengan menyatakan fungsi yang pasti untuk memanggilnya di blockchains.

Ikuti perintah yang disebutkan di bawah ini untuk struct oj NEAR:

#[near_bindgen]
#[derive(Default, BorshDeserialize, BorshSerialize)]

Perintah-perintah ini membantu kompilasi di WebAssemble agar mendukung dan dioptimalkan untuk NEAR Protocol.

Kamu juga dapat menggunakan referensi env untuk menulis log seperti yang telah kita sebutkan sebelumnya di artikel ini.

Lihatlah beberapa fungsi </>env yang diberikan di bawah ini:

  • signer_account_id – id akun dari akun yang menandatangani transaksi asli yang mengarah ke eksekusi ini
  • attached_deposit – jika seseorang mengirim token bersama dengan panggilan
  • account balance – saldo yang dilampirkan ke akun yang diberikan

Cara Tes Unit

Tes unit akan dimulai pada,


mod tests {

}

dan akan berlanjut sampai akhir file lib.rs. Kode yang disebutkan di atas adalah boilerplate in nature.

Cara Menulis Tes

Kode pengujian unit khusus yang kamu buat, akan digunakan sebagai berikut:

let mut contract = Counter{ val: 0 };
contract.increment();
// confirm that we received 1 when calling get_num
println!("Value after increment: {}", contract.get_num());
assert_eq!(1, contract.get_num());

Uji dan kompilasi

Uji Smart Contract, lalu kompilasi dan buat wasm release binary.

Uji kodenya

Uji kode Smart Contract melalui kargo,

cargo test -- --nocapture

Kamu kemudian akan menerima output berupa:

running 3 tests
Value after decrement: -1
Value after increment: 1
Value after reset: 0
test tests::decrement ... ok
test tests::increment ... ok
test tests::increment_and_reset ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Kompilasi kodenya

Setelah Kamu mendapatkan semua tes lulus ok, lanjutkan dengan kompilasi dengan Smart Contract sekarang,

cargo build --target wasm32-unknown-unknown --release

.
├── Cargo.lock ⟵ created during build to lock dependencies
├── Cargo.toml
├── src
│ └── lib.rs
└── target ⟵ created during build, holds the compiled wasm

Menyebarkan Smart Contract NEAR

Dengan file .wasm yang baru dikompilasi, gunakan Smart Contract Kamu. Kamu akan menyebarkannya menggunakan near-cli dan testnet dari akun NEAR Kamu.

Login with near-cli,
near login
near deploy --wasmFile target/wasm32-unknown-unknown/release/rust_counter_tutorial.wasm --accountId
YOUR_ACCOUNT_HERE

Alasan Mengapa Kamu harus Membuat Smart Contract di Near Protocol?

Near Protocol menargetkan menghilangkan penyumbatan yang muncul dalam cara mengadopsi web 3.0. Ini memberikan transaksi cepat dengan biaya pemrosesan minimal. NEAR memiliki UX yang kuat dan progresif untuk pengguna dApp pada platform keuangan terdesentralisasi. Ini ramah lingkungan di alam, muncul sebagai salah satu ekosistem pasar digital terbaik. Mekanisme NEAR didasarkan pada teknik sharding dan oleh karena itu, membantu memfasilitasi pengambilan data yang mudah dan penskalaan dApp pada platform DeFi.

NEAR menggunakan mekanisme pemilihan yang dikenal dengan Threshold Proof-of-Stake (TPoS). Dengan bantuan TPoS, NEAR menciptakan cara yang telah ditentukan untuk melibatkan sejumlah besar peserta untuk menjaga ekosistem blockchain. Ini mengarah pada peningkatan desentralisasi dan keamanan jaringan blockchain. Menggunakan mekanisme TPoS, NEAR membangun sistem penghargaan yang adil untuk pengguna dApp.

Kesimpulan

Near Protocol adalah salah satu Protokol yang paling teknis dibandingkan dengan jaringan blockchain lainnya. Ini sama-sama berfokus pada membangun aplikasi terdesentralisasi (dApp) dengan bantuan teknologi sharding untuk mencapai skalabilitas.

Untuk mencapai tujuan ini, NEAR Protocol menyediakan fitur seperti nama akun yang dapat dibaca manusia dan bukan alamat dompet kriptografi. Ini membantu pengguna dApp baru untuk berkomunikasi dengan dApps dan Smart Contract.

5/5 - (300 votes)
Share Jika Bermanfaat Ya 🙂

Leave a Comment