HỌC CÁCH XÂY DỰNG BLOCKCHAINS TỪ A -> Z

February 19, 2020

HỌC CÁCH XÂY DỰNG BLOCKCHAINS TỪ A -> Z (Phần 1)

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 = {

 

      'message': "New Block Forged",

      'index': block['index'],

      'transactions': block['transactions'],

      'proof': block['proof'],

      'previous_hash': block['previous_hash'],

  }

        return jsonify(response), 200

to be continued...

Nguồn tổng hợp

---

JT1 - IT Recruitment Agency
Website: 
https://www.jt1.vn
Email: hi@jt1.vn
Điện thoại: +8428 6675 6685
Xem thêm các bài viết khác tại: https://www.jt1.vn/blog
Theo dõi chúng tôi tại: https://www.facebook.com/jt1asia/

 

Please reload

Recent Posts

Please reload

banner-top-it-job-right.gif

Archive

Please reload

Tags