Giao thức NEAR và Solana
Hướng dẫn / Bởi Sasha | ahsaS.NEAR / 10 phút đọc
Tweet + 4nLEARN
Hôm nay chúng ta hãy xem xét hai trong số các nền tảng hợp đồng thông minh hứa hẹn nhất trên thế giới - Giao thức gần và Solana. Trong khi Ethereum vẫn thống trị thị trường này, thực tế là việc thiếu khả năng mở rộng và phí cao đã buộc hầu hết các nhà phát triển phải tìm kiếm các giải pháp thay thế khả thi. Near và Solana đã nổi lên như hai người chạy hàng đầu.
Solana là gì?
Solana được thành lập vào năm 2017 bởi Anatoly Yakovenko, người trước đó đã làm việc tại DropBox. Yakovenko, cùng với Eric Williams và CTO Greg Fritzgerald, đã tạo ra Solana để giải quyết các vấn đề hiện có trong Bitcoin và Ethereum. Dự án đã thu hút đầu tư từ Multicoin Capital, Foundation Capital, SLOW Capital, CMCC Global, Abstract Ventures, v.v.
GẦN Solana
Các tính năng của chuỗi khối Solana
50.000 giao dịch mỗi giây và thời gian chặn 0,4 giây
Hệ thống có thể cung cấp 28,4 triệu giao dịch mỗi giây trên mạng 40 gigabit.
Solana sử dụng thuật toán đồng thuận Proof-of-History.
Proof-of-History (PoH) hoạt động như thế nào?
Trong một mạng lưới phi tập trung trải rộng trên một khu vực rộng lớn, sự đồng thuận là điều cần thiết. Bitcoin sử dụng sự đồng thuận bằng chứng công việc (PoW) để quan tâm đến sự đồng thuận. Mặc dù phương pháp này có tính bảo mật cao, nhưng khó có thể bỏ qua vấn đề quan trọng nhất của nó - thiếu khả năng mở rộng. Đừng quên rằng Bitcoin chỉ có thể thực hiện 7 giao dịch mỗi giây.
Solana sử dụng bằng chứng lịch sử, trong đó nó tạo ra các bản ghi lịch sử để chứng minh rằng một sự kiện xảy ra trong một thời điểm cụ thể. Dưới đây là một số điểm bạn cần lưu ý:
Thuật toán sử dụng Hàm độ trễ có thể xác minh tần số cao yêu cầu một số bước tuần tự nhất định để kết thúc.
Các giao dịch hoặc sự kiện được thực hiện trong mạng sẽ được chỉ định một số băm duy nhất, có thể được xác minh công khai.
Số lượng cho phép mạng biết chính xác thời điểm giao dịch hoặc sự kiện đã xảy ra.
Mỗi nút đều có một đồng hồ mật mã giúp theo dõi thời gian mạng và thứ tự của các sự kiện.
Do PoH, mạng Solana hỗ trợ 50.000 giao dịch mỗi giây trong khi chạy với GPU.
Cụm Solana là gì?
Cụm là một tập hợp các máy tính sở hữu độc lập làm việc cùng nhau và có thể được xem như một hệ thống đơn lẻ. Các tính năng chính của Cluster như sau:
Chúng giúp xác minh đầu ra của các chương trình không đáng tin cậy, do người dùng gửi.
Lưu giữ hồ sơ về bất kỳ giao dịch hoặc sự kiện nào mà người dùng thực hiện.
Nó theo dõi những máy tính nào đã làm công việc có ý nghĩa để giữ cho mạng hoạt động.
Nó theo dõi việc sở hữu các tài sản trong thế giới thực.
Điều nào sau đây sử dụng sharding?
1.Solana
2.Giao thức GẦN(right)
3.Cả hai
Lập trình trong Solana
Các hợp đồng thông minh trong Solana được viết bằng Rust hoặc C và được biên dịch sang mã bytecode Bộ lọc gói Berkeley (BPF). Vì có nhiều công cụ hơn, bạn nên viết mã bằng Rust. Người mới bắt đầu nên viết mã chương trình của họ bằng khung Anchor, giúp đơn giản hóa việc thực thi.
Solana có một mô hình tài khoản duy nhất tương tự như các tệp trong hệ điều hành Linux. Chúng có thể chứa bất kỳ dữ liệu tùy ý nào và cũng chứa siêu dữ liệu về cách chúng có thể được truy cập. Tuy nhiên, hãy nhớ rằng các tài khoản có kích thước cố định và không thể thay đổi kích thước.
Mô hình lập trình hiện tại của Solana có thể buộc bạn phải di chuyển logic ứng dụng ra khỏi chuỗi hoặc sửa đổi chức năng không hiệu quả và bị giới hạn bởi kích thước tài khoản cố định.
Phần nào sau đây là một phần không thể thiếu của Solana?
1.Cluster
2.Tập thể
3.Parachain
Hợp đồng mẫu
#! [feature (proc_macro_hygiene)]
sử dụng anchor_lang :: prelude :: *;
sử dụng anchor_spl :: token :: {self, TokenAccount, Transfer};
[program]
pub mod plutocratic_hosting {
use super :: *;
/// Khởi tạo hợp đồng mới với nội dung đã khởi tạo.
# [access_control (Initialize :: validate (& ctx, nonce))]
pub fn khởi tạo (
ctx: Context <Initialize>,
price: u64,
content: String,
nonce: u8,
) -> ProgramResult {
// Chuyển tiền vào kho tiền hợp đồng.
let cpi_accounts = Transfer {
from: ctx.accounts.from.to_account_info (). clone (),
to: ctx.accounts.vault.to_account_info (). clone (),
Authority: ctx.accounts.owner.clone (),
} ;
let cpi_program = ctx.accounts.token_program.clone ();
let cpi_ctx = CpiContext :: new (cpi_program, cpi_accounts);
mã thông báo :: chuyển (cpi_ctx, giá) ?;
// Khởi tạo dữ liệu nội dung.
let content_record = & mut ctx.accounts.content;
content_record.price = giá;
content_record.content = nội dung;
content_record.nonce = nonce;
content_record.owner = * ctx.accounts.owner.to_account_info (). key;
content_record.vault = * ctx.accounts.vault.to_account_info (). key;
Vâng(())
}
/// Mua địa chỉ nội dung với giá mới, nếu chuyển nhiều mã thông báo hơn.
# [access_control (check_funds (& ctx.accounts.content, price))]
mua pub fn (ctx: Context <Purchase>, price: u64, content: String) -> ProgramResult {
// Chuyển tiền từ hợp đồng trở lại chủ sở hữu.
let seed = & [
ctx.accounts.content.to_account_info (). key.as_ref (),
& [ctx.accounts.content.nonce],
];
để người ký tên = & [& hạt [..]];
let cpi_accounts = Transfer {
from: ctx.accounts.vault.to_account_info (). clone (),
sang: ctx.accounts.owner_token.to_account_info (). clone (),
Authority: ctx.accounts.contract_signer.clone (),
};
let cpi_program = ctx.accounts.token_program.clone ();
let cpi_ctx = CpiContext :: new_with_signer (cpi_program, cpi_accounts, signer);
mã thông báo :: chuyển (cpi_ctx, ctx.accounts.content.price) ?;
// Chuyển tiền từ chủ sở hữu mới sang hợp đồng.
hãy cpi_accounts = Chuyển {
từ:. ctx.accounts.new_owner_token.to_account_info () clone (),
để: ctx.accounts.vault.to_account_info clone () (),.
quyền: ctx.accounts.new_owner.clone (),
} ;
let cpi_program = ctx.accounts.token_program.clone ();
let cpi_ctx = CpiContext :: new (cpi_program, cpi_accounts);
mã thông báo :: chuyển (cpi_ctx, giá) ?;
// Ghi đè nội dung
let content_record = & mut ctx.accounts.content;
content_record.price = giá;
content_record.content = nội dung;
content_record.owner = * ctx.accounts.new_owner.to_account_info (). key;
Được rồi (())
}
}
[account]
pub struct ContentRecord {
/// Giá mà nội dung hiện tại được sở hữu.
giá pub: u64,
/// Dữ liệu nội dung.
nội dung pub: Chuỗi,
/// Khóa công khai của chủ sở hữu hiện tại của nội dung.
chủ quán rượu: Pubkey,
/// Địa chỉ cho chương trình mã thông báo của quỹ bị khóa trong hợp đồng.
pub vault: Pubkey,
/// Nonce cho nội dung, để tạo các địa chỉ dẫn xuất chương trình hợp lệ.
pub nonce: u8,
}
[origin (Accounts)]
pub struct Khởi tạo nội dung <‘info> {
# [account (init)]
: ProgramAccount <’ info, ContentRecord>,
# [account (mut, “& vault.owner == contract_signer.key”)]
vault: CpiAccount <'info, TokenAccount>,
/// Địa chỉ dẫn xuất chương trình cho hợp đồng.
contract_signer: AccountInfo <'info>,
/// Token tài khoản mà hợp đồng được tạo.
# [account (mut, has_one = owner)]
from: CpiAccount <'info, TokenAccount>,
/// Chủ sở hữu tài khoản token from.
chủ sở hữu: AccountInfo <‘info>,
token_program: AccountInfo <’ info>,
thuê: Sysvar <'info, Rent>,
}
impl <‘info> Initialize <’ info> {
pub fn validate (ctx: & Context , nonce: u8) → Kết quả <()> {
let signer = Pubkey :: create_program_address (
& [
ctx.accounts.content. to_account_info (). key.as_ref (),
& [nonce],
],
ctx.program_id,
)
.map_err (| _ | ErrorCode :: InvalidNonce) ?;
if & signer! = ctx.accounts.contract_signer.to_account_info (). key {
return Err (ErrorCode :: InvalidSigner.into ());
}
Được rồi (())
}
}
[secure (Accounts)]
pub struct Purchase <‘info> {
# [account (mut, has_one = vault)]
content: ProgramAccount <’ info, ContentRecord>,
# [account (mut)]
vault: CpiAccount <'info, TokenAccount>,
# [account (seed = [
content.to_account_info (). Key.as_ref (),
& [content.nonce],
])]
contract_signer: AccountInfo <'info>,
# [account (mut, has_one = owner) ]
owner_token: CpiAccount <‘info, TokenAccount>,
# [account (mut)]
new_owner_token: CpiAccount <’ info, TokenAccount>,
# [account (signer)]
new_owner: AccountInfo <'info>,
owner: AccountInfo <'thông tin>,
token_program: AccountInfo <'info>,
}
fn check_funds (check: & ContentRecord, new_price: u64) → Kết quả <()> {
if check.price> = new_price {
return Err (ErrorCode ::
InsuffnoughFunds.into ()); }
Được rồi (())
}
[error]
pub enum ErrorCode {
# [msg (“Số nonce đã cho không tạo ra địa chỉ dẫn xuất chương trình hợp lệ.”)]
InvalidNonce,
# [msg (“Trình ký kết dẫn xuất không khớp với địa chỉ được cung cấp.”)]
InvalidSigner ,
# [msg (“Không đủ tiền cung cấp để mua lộ trình.”)]
InsuffnoughFunds,
}
Điều gì đang xảy ra trong hợp đồng?
Tất cả các tài khoản được truy cập đều được chú thích trong cấu trúc cho mỗi cuộc gọi với # [dẫn xuất (Tài khoản)].
Các chức năng giúp phức tạp hóa dữ liệu tài khoản cho chủ sở hữu ban đầu và Mua hàng. Điều này cho phép bất kỳ ai mua nó để có thêm mã thông báo.
Dữ liệu tạm thời được chuyển vào các tham số của hàm. Các tham số này nằm bên trong các chức năng khởi tạo và mua hàng. Điều này cũng bao gồm Bối cảnh nắm giữ các tài khoản yêu cầu cho giao dịch.
Trạng thái của hợp đồng nằm trong cấu trúc ContentRecord. Điều này được chú thích thêm với # [tài khoản] để cho biết rằng nó đại diện cho bố cục dữ liệu cho một tài khoản.
Giao thức NEAR là gì?
Ra đời vào mùa hè năm 2018, giao thức được thiết kế để tạo ra môi trường hoàn hảo cho các ứng dụng phi tập trung bằng cách cung cấp tốc độ cao hơn, thông lượng cao hơn và khả năng tương thích tốt hơn với các chuỗi khác. NEAR có một kỹ thuật Sharding độc đáo và giới thiệu một cơ chế tạo khối được gọi là “Doomslug” được đề xuất vào năm 2019. Doomslug cho phép tính cuối cùng thực tế hoặc “Doomslug”, đảm bảo rằng các khối nhận được tính chính thức trong vài giây.
Giao thức NEAR được phát triển bởi NEAR Collective, một cộng đồng các nhà phát triển và nhà nghiên cứu hợp tác xây dựng dự án. Một số tính năng quan trọng của NEAR là:
NEAR là một hệ thống phân mảnh cho phép khả năng mở rộng vô hạn.
Một giao thức dễ sử dụng, NEAR cho phép các nhà phát triển xây dựng ứng dụng một cách dễ dàng và nhanh chóng.
NEAR không phải là một chuỗi bên mà là một giao thức Lớp-1.
dApps được tạo bằng cách sử dụng NEAR chạy trên đầu lớp NEAR bên dưới.
Tập thể GẦN là gì?
Tập thể NEAR bao gồm các tổ chức cá nhân và những người đóng góp khác đang liên tục làm việc để cải thiện Giao thức NEAR. Collective làm việc trên các dự án như viết mã ban đầu và triển khai cho Mạng GẦN. NEAR hoàn toàn phi tập trung, hoạt động độc lập và không thể bị tắt hoặc thao túng, ngay cả bởi những người đã xây dựng nó.
Đây là một tổ chức phi lợi nhuận tập trung vào việc tạo ra một hệ sinh thái sôi động xung quanh chuỗi khối NEAR. Nó giúp điều phối các hoạt động quản trị và phát triển. NEAR Collective có một số dự án, với NEAR blockchain chỉ là một trong số các dự án dưới sự bảo trợ của tập thể.
GẦN Cơ chế Đồng thuận
Cơ chế đồng thuận được thực hiện trên NEAR được gọi là Nightshade. Nightshade mô hình hóa hệ thống như một chuỗi khối duy nhất. Danh sách tất cả các giao dịch trong mỗi khối được chia thành các phần vật lý, một phần cho mỗi phân đoạn. Tất cả các khối tích lũy thành một khối. Lưu ý rằng các phân đoạn chỉ có thể được xác thực bởi các nút duy trì trạng thái của phân đoạn đó.
Nói về xác thực, một thành phần quan trọng của NEAR là các trình xác nhận. Các trình xác nhận này chịu trách nhiệm duy trì sự đồng thuận trong giao thức. Trình xác thực là các nút chuyên biệt cần giữ máy chủ của họ trực tuyến 100% thời gian trong khi giữ cho hệ thống của họ được cập nhật liên tục.
Dưới đây là một số điểm mà bạn phải ghi nhớ về trình xác thực mạng.
NEAR xác định các trình xác thực mạng của mình mỗi kỷ nguyên mới, bầu họ dựa trên số tiền mà họ đặt ra.
Những người xác thực đã được bầu chọn sẽ được đăng ký lại bằng cách tự động đặt lại mã thông báo của họ cộng với phần thưởng đã tích lũy.
Người xác nhận tiềm năng phải có cổ phần của họ trên một mức được xác định động.
Có hai phương pháp mà người xác nhận có thể sử dụng để củng cố cổ phần của họ - mua mã thông báo của chính họ hoặc vay thông qua ủy quyền cổ phần.
Phần thưởng bạn nhận được tỷ lệ thuận với tiền đặt cược của bạn — càng nhiều tiền đặt cược, phần thưởng của bạn càng nhiều.
Sự đồng thuận dựa trên sự đồng thuận dây chuyền nặng nề nhất. Có nghĩa là, khi một nhà sản xuất khối xuất bản một khối, họ sẽ thu thập chữ ký của các nút trình xác nhận. Trọng lượng của một khối sau đó là số tiền tích lũy của tất cả những người ký có chữ ký được bao gồm trong khối. Trọng lượng của một chuỗi là tổng trọng lượng của khối. Ngoài ra, sự đồng thuận sử dụng một tiện ích cuối cùng đưa ra các điều kiện cắt giảm bổ sung để bảo mật chuỗi cao hơn.
Doomslug ”là một cơ chế tạo khối của giao thức nào?
1.Giao thức GẦN(right)
2.Solana
Giao thức Aurora và NEAR
Aurora cũng đã ra mắt trên Giao thức NEAR, cung cấp trải nghiệm Ethereum Layer-2. Một số cách mà Aurora cải thiện GẦN là:
Nó giúp tăng thông lượng lên hàng nghìn giao dịch mỗi giây.
Thời gian hoàn thành khối là 2 giây.
Tăng trưởng hệ sinh thái bền vững trong tương lai
Phí giao dịch thấp, thấp hơn 1000 lần so với Ethereum.
Khả năng tương thích hoàn hảo với Ethereum.
Hợp đồng mẫu
sử dụng near_sdk :: borsh :: {self, BorshDeserialize, BorshSerialize};
sử dụng near_sdk :: collection :: LookupMap;
sử dụng near_sdk :: {env, near_bindgen, AccountId, Balance, Promise};
[global_allocator]
static ALLOC: near_sdk :: fro_alloc :: WeeAlloc = near_sdk :: fro_alloc :: WeeAlloc :: INIT;
[origin (BorshDeserialize, BorshSerialize)]
pub struct ContentRecord {
pub price: Số dư,
nội dung pub: String,
pub chủ sở hữu: AccountId,
}
[near_bindgen]
[origin (BorshDeserialize, BorshSerialize)]
pub struct ContentTracker {
value: LookupMap <String, ContentRecord>,
contract_owner: AccountId,
}
impl Mặc định cho ContentTracker {
fn default () → Bản thân {
let contract_owner = env :: currency_account_id ();
Tự {
giá trị: LookupMap :: new (b “v” .to_vec ()),
contract_owner,
}
}
}
[near_bindgen]
impl ContentTracker {
/// Nhận nội dung tại một tuyến đường nhất định.
pub fn get_route (& self, route: String) → Tùy chọn {
self.values.get (& route) .map (| v | v.content)
}
/// Mua một tuyến đường dựa trên số tiền được gửi đến hợp đồng.
# [phải trả]
mua pub fn (& mut self, route: String, content: String) {
let Deposit = env :: attachment_deposit ();
khẳng định! (tiền gửi> 0);
if let Some (entry) = self.values.get (& route) {
khẳng định! (
ký quỹ> entry.price,
"Không đủ ký gửi để mua tuyến, giá: {} ký gửi: {}",
entry.price,
ký gửi
);
// Hoàn tiền mua hàng cho chủ sở hữu hiện tại
Promise :: new (entry.owner) .transfer (entry.price);
}
// Cập nhật bản ghi cho trạng thái hợp đồng.
self.values.insert (
& route,
& ContentRecord {
giá: tiền gửi,
nội dung,
chủ sở hữu: env :: secure_account_id (),
},
);
}
/// Cho phép chủ sở hữu của hợp đồng rút tiền.
pub fn rút lui (& mut self) {
khẳng định_eq! (env :: secure_account_id (), self.contract_owner);
// Gửi tiền theo hợp đồng cho chủ hợp đồng
Promise :: new (self.contract_owner.clone ()). Transfer (env :: account_balance ());
}
}
Điều gì đang xảy ra trong hợp đồng?
Vì vậy, những gì đang xảy ra ở đây trong hợp đồng? Chúng ta hãy xem xét kỹ hơn.
Hợp đồng được định nghĩa bởi # [near_bindgen] trong ContentTracker, nó tương tự như một phương thức khởi tạo trong Solidity và được gọi khi hợp đồng được triển khai.
Chức năng mua hàng được chú thích bằng # [phải trả].
Hợp đồng bao gồm các lệnh gọi không đồng bộ ở dạng Promise :: new (…) .transfer (…); các dòng.
Cấu trúc dữ liệu LookupMap <String, ContentRecord> xử lý tra cứu khóa-giá trị, truy cập bộ nhớ. Điều này tương đương với “ánh xạ” Solidity.
Phần kết luận
Cả Solana và NEAR Protocol đều là những nền tảng hợp đồng thông minh tuyệt vời đã xây dựng nên những cộng đồng tích cực. Cả hai đều mang lại những tính năng đặc biệt giúp chống lại vấn đề lớn nhất đang gây ra cho thế giới phi tập trung - tốc độ. Cả hai nền tảng vẫn đang phát triển và có nhiều hứa hẹn.