Khi bạn bắt đầu tìm hiểu về thuật ngữ Blockchains, chắc hẳn bạn cũng đang rất quan tâm tới sự gia tăng của tiền điện tử. Thế nhưng để hiểu về Blockchains không phải là một điều dễ dàng, bạn sẽ chìm đắm trong một loạt thuật ngữ trước khi bạn có thể hiểu được cách hoạt động và công nghệ cơ bản đằng sau chúng. Cách tốt nhất là tự mình xây dựng một Blockchains để biết được những vấn đề phát sinh và nắm thật rõ ràng. Tham khảo cách xây dựng chi tiết Blockchains từ jt1.vn qua bài viết dưới đây.
Trước khi bắt đầu
Hãy nhớ rằng Blockchains là một chuỗi bất biến, liên tục của các bản ghi. Chúng có thể chứa các giao dịch, tệp hoặc bất kỳ dữ liệu nào bạn thích, chúng được kết nối với nhau bằng cách sử dụng hashes (hàm băm).
Bạn nên nắm chắc về Python cơ bản, cũng như có một số hiểu biết về cách yêu cầu HTTP hoạt động vì bài viết này sẽ xây dựng Blockchains thông qua HTTP. Đồng thời bạn cũng cần đảm bảo Python 3.6+ (cùng với pip) và Flask và thư viện Requests đã được cài đặt.
Bước 1: Xây dựng Blockchains
Tạo lớp Blockchains
Mở trình soạn thảo văn bản hoặc IDE yêu thích của bạn. Tạo một tệp mới và đặt tên nó là blockchain.py. Bạn cần tạo một lớp Blockchains để xây dựng danh sách trống ban đầu và một lớp khác để lưu trữ các giao dịch.
class Blockchain(object):
def __init__(self):
self.chain = []
self.current_transactions = []
def new_block(self):
# Creates a new Block and adds it to the chain
pass
def new_transaction(self):
# Adds a new transaction to the list of transactions
pass
@staticmethod
def hash(block):
# Hashes a Block
pass
@property
def last_block(self):
# Returns the last Block in the chain
pass
Bằng cách này mà nó có thể lưu trữ các giao dịch và có một số phương thức trợ giúp để thêm các block mới vào chuỗi..
Cách Block đơn được tạo dựng
block = {
'index': 1,
'timestamp': 1506057125.900785,
'transactions': [
{
'sender': "8527147fe1f5426f9dd545de4b27ee00",
'recipient': "a77f5cdfa2934df3954a5c7c7da5df1f",
'amount': 5,
}
],
'proof': 324984774000,
'previous_hash': "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
}
Tại thời điểm này, ý tưởng về một chuỗi cần phải rõ ràng, với mỗi block mới được tạo cần phải nằm trong chuỗi và các hàm băm của block trước đó. Điều này rất quan trọng bởi vì nó có thể mang lại sự bất biến cho Blockchains.
Thêm giao dịch vào một Block
Để thêm các giao dịch mới vào một block cần tới câu lệnh new_transaction().
class Blockchain(object):
...
def new_transaction(self, sender, recipient, amount):
"""
Creates a new transaction to go into the next mined Block
:param sender: <str> Address of the Sender
:param recipient: <str> Address of the Recipient
:param amount: <int> Amount
:return: <int> The index of the Block that will hold this transaction
"""
self.current_transactions.append({
'sender': sender,
'recipient': recipient,
'amount': amount,
})
return self.last_block['index'] + 1
Khởi tạo một Block mới
Ngoài việc tạo khối genesis - khối đầu tiên trong Blockchains, trong hàm tạo cần bổ sung các phương thức cho new_block (), new_transaction () và hash ().
import
hashlib
import json
from time import time
class Blockchain(object):
def __init__(self):
self.current_transactions = []
self.chain = []
# Create the genesis block
self.new_block(previous_hash=1, proof=100)
def new_block(self, proof, previous_hash=None):
"""
Create a new Block in the Blockchain
:param proof: <int> The proof given by the Proof of Work algorithm
:param previous_hash: (Optional) <str> Hash of previous Block
:return: <dict> New Block
"""
block = {
'index': len(self.chain) + 1,
'timestamp': time(),
'transactions': self.current_transactions,
'proof': proof,
'previous_hash': previous_hash or self.hash(self.chain[-1]),
}
# Reset the current list of transactions
self.current_transactions = []
self.chain.append(block)
return block
def new_transaction(self, sender, recipient, amount):
"""
Creates a new transaction to go into the next mined Block
:param sender: <str> Address of the Sender
:param recipient: <str> Address of the Recipient
:param amount: <int> Amount
:return: <int> The index of the Block that will hold this transaction
""'
self.current_transactions.append({
'sender': sender,
'recipient': recipient,
'amount': amount,
})
return self.last_block['index'] + 1
@property
def last_block(self):
return self.chain[-1]
@staticmethod
def hash(block):
"""
Creates a SHA-256 hash of a Block
:param block: <dict> Block
:return: <str>
"""
# We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes
block_string = json.dumps(block, sort_keys=True).encode()
return hashlib.sha256(block_string).hexdigest()
Xây dựng thuật toán Proof of Work (PoW)
Thuật toán Proof of Work (PoW) là cách các Block mới được tạo hoặc khai thác trên Blockchains. Mục tiêu của PoW là khám phá ra một con số giải quyết vấn đề. Trong Bitcoin, thuật toán PoW được gọi là Hashcash, độ khó được xác định bởi số lượng ký tự được tìm kiếm trong một chuỗi.
import
hashlib
import json
from time import time
from uuid import uuid4
class Blockchain(object):
...
def proof_of_work(self, last_proof):
"""
Simple Proof of Work Algorithm:
- Find a number p' such that hash(pp') contains leading 4 zeroes, where p is the previous p'
- p is the previous proof, and p' is the new proof
:param last_proof: <int>
:return: <int>
"""
proof = 0
while self.valid_proof(last_proof, proof) is False:
proof += 1
return proof
@staticmethod
def valid_proof(last_proof, proof):
"""
Validates the Proof: Does hash(last_proof, proof) contain 4 leading zeroes?
:param last_proof: <int> Previous Proof
:param proof: <int> Current Proof
:return: <bool> True if correct, False if not.
"""
guess = f'{last_proof}{proof}'.encode()
guess_hash = hashlib.sha256(guess).hexdigest()
return guess_hash[:4] == "0000"
Đến đây thì lớp Blockchains đã gần như hoàn tất và có thể tương tác với nó bằng các yêu cầu của HTTP.
Bước 2: Blockchains dưới dạng API
Sử dụng Python Flask Framework, điều này cho phép bạn thao tác với Blockchains qua web bằng các yêu cầu của HTTP.
Tạo dựng 3 cách thức:
/transactions/new để tạo một giao dịch mới cho Block
/mine để truyền tới máy chủ khi dùng một Block mới
/chain để trở về Blockchains đầy đủ
Thiết lập Flask
Máy chủ sẽ trực tiếp tạo thành một điểm nối trong mạng Blockchains. Hãy tạo ra một số mã soạn sẵn:
import
hashlib
import json
from textwrap import dedent
from time import time
from uuid import uuid4
from flask import Flask
class Blockchain(object):
...
# Instantiate our Node
app = Flask(__name__)
# Generate a globally unique address for this node
node_identifier = str(uuid4()).replace('-', '')
# Instantiate the Blockchain
blockchain = Blockchain()
@app.route('/mine', methods=['GET'])
def mine():
return "We'll mine a new Block"
@app.route('/transactions/new', methods=['POST'])
def new_transaction():
return "We'll add a new transaction"
@app.route('/chain', methods=['GET'])
def full_chain():
response = {
'chain': blockchain.chain,
'length': len(blockchain.chain),
}
return jsonify(response), 200
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)
Điểm cuối giao dịch
{
"sender": "my address",
"recipient": "someone else's address",
"amount": 5
}
Đây là những yêu cầu cho một giao dịch, nó là những gì người dùng gửi tới máy chủ.
Kể từ khi các phương thức cho việc giao dịch được thêm vào Block, bạn chỉ cần viết chức năng và thêm vào giao dịch.
import
hashlib
import json
from textwrap import dedent
from time import time
from uuid import uuid4
from flask import Flask, jsonify, request
...
@app.route('/transactions/new', methods=['POST'])
def new_transaction():
values = request.get_json()
# Check that the required fields are in the POST'ed data
required = ['sender', 'recipient', 'amount']
if not all(k in values for k in required):
return 'Missing values', 400
# Create a new Transaction
index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])
response = {'message': f'Transaction will be added to Block {index}'}
return jsonify(response), 201
Điểm cuối khai thác
Tại điểm cuối khai thác sẽ thực hiện ba nhiệm vụ chính:
Tính toán thuật toán Proof of Work (PoW).
Thưởng cho người dùng bằng cách thêm 1coin vào giao dịch.
Tạo một Block mới bằng cách thêm nó vào chuỗi.
import hashlib
import json
from time import time
from uuid import uuid4
from flask import Flask, jsonify, request
...
@app.route('/mine', methods=['GET'])
def mine():
# We run the proof of work algorithm to get the next proof...
last_block = blockchain.last_block
last_proof = last_block['proof']
proof = blockchain.proof_of_work(last_proof)
# We must receive a reward for finding the proof.
# The sender is "0" to signify that this node has mined a new coin.
blockchain.new_transaction(
sender="0",
recipient=node_identifier,
amount=1,
)
# Forge the new Block by adding it to the chain
previous_hash = blockchain.hash(last_block)
block = blockchain.new_block(proof, previous_hash)
response = {