Вы читаете эту статью, потому что, как и я, со страстным интересом наблюдаете за растущей популярностью криптовалюты.
И вы хотите понять, как работает блокчейн — технология, лежащая в его основе.
Но понять блокчейн не так-то просто, по крайней мере, по моему опыту.
Я просматривал непонятные видеоролики, просматривал учебные пособия и с растущим разочарованием отмечал отсутствие наглядных примеров.
Я предпочитаю учиться на практике.
В этой ситуации мне приходится работать над темой сразу на уровне кода, что помогает закрепить навык.
Если вы последуете моему примеру, то к концу этой статьи у вас будет функционирующий блокчейн и четкое понимание того, как все это работает. 
Но сначала.
Напомню: блокчейн — это неизменяемая последовательная цепочка записей, называемых блоками.
Они могут содержать транзакции, файлы и, в принципе, любые другие типы данных.
Главное здесь то, что они связаны друг с другом посредством хэшей.
Если вы не совсем понимаете, что такое хэш, сюда .
Для кого предназначено это руководство? Для тех, кто без проблем умеет читать и писать простой код Python и имеет общее представление о том, как работают HTTP-запросы, мы будем общаться с нашим блокчейном через HTTP. Что вам понадобится для работы? Проверьте, что вы установили Питон 3.6+ (вместе с пипом).
Вам также потребуется установить Flask и отличную библиотеку Requests:
Ах да, вам еще понадобится HTTP-клиент, например, Почтальон или CURL. Здесь подойдет любой.pip install Flask==0.12.2 requests==2.18.4
Где я могу увидеть конечный результат? Доступен исходный код Здесь .
Шаг первый: создание блокчейна
Откройте свой любимый текстовый или графический редактор, например, мне нравится этот Пичарм .Создайте новый файл с именем блокчейн.
py. Мы будем работать только в этом файле, а если вы запутаетесь, вы всегда можете заглянуть в источник .
Обзор блокчейна Сначала мы создаем новый класс, конструктор которого создаст исходный пустой список (где будет храниться наш блокчейн) и еще один для транзакций.
Вот как выглядит структура класса: 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
Сорт Блокчейн отвечает за управление сетью.
Здесь будут храниться транзакции, а также некоторые вспомогательные методы для добавления новых блоков в цепочку.
Опишем эти методы.
Как выглядит блок? Каждый блок содержит индекс, метку времени (в Unix), список транзакций, доказательство и хеш предыдущего блока.
Вот пример того, как может выглядеть один блок: block = {
'index': 1,
'timestamp': 1506057125.900785,
'transactions': [
{
'sender': "8527147fe1f5426f9dd545de4b27ee00",
'recipient': "a77f5cdfa2934df3954a5c7c7da5df1f",
'amount': 5,
}
],
'proof': 324984774000,
'previous_hash': "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
}
Теперь идея цепочки должна быть очевидна — каждый блок включает в себя хеш предыдущего.
Это очень важно: так обеспечивается неизменяемость цепочки: если хакер повредит какой-либо блок, то абсолютно все последующие будут содержать неверные хеши.
Ясно? Если нет, остановитесь и дайте себе время усвоить эту информацию — это основной принцип блокчейна.
Добавление транзакций в блок Нам нужно как-то добавлять в блок новые транзакции.
За это отвечает метод новая_транзакция() , это работает довольно просто: 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
Когда новая_транзакция() добавляет в список новую транзакцию, возвращает индекс блока, в котором она была записана, до следующего, который будет добыт. Это будет полезно позже для следующего пользователя, добавляющего транзакцию.
Помимо создания блока генезиса в конструкторе, мы также распишем методы новый_блок() , новая_транзакция() И хеш() : 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, должен заканчиваться на 0. Соответственно, hash(x * y) = ac23dc.0. Для этого упрощенного примера установим x = 5. Давайте напишем все это на Python: from hashlib import sha256
x = 5
y = 0 # We don't know what y should be yet.
while sha256(f'{x*y}'.
encode()).
hexdigest()[-1] != "0":
y += 1
print(f'The solution is y = {y}')
Правильный ответ здесь: y = 21; Именно с этим значением получается хеш с 0 на конце: hash(5 * 21) = 1253e9373e.5e3600155e860
В Биткойне алгоритм доказательства работы называется ХэшКэш и особо не отличается от простого примера выше.
Это уравнение, которое майнеры спешат решить, чтобы создать новый блок.
В общем, сложность определяется тем, сколько символов необходимо вычислить в данной последовательности.
За правильный ответ майнеры получают вознаграждение в виде одной монеты — во время транзакции.
Их решение для системы проверить несложно.
Написание простого доказательства работы Теперь давайте напишем аналогичный алгоритм для нашего блокчейна.
Возьмем условия в духе приведенного выше примера: Найдите число p, которое при хэшировании с доказательством предыдущего блока дает хэш с четырьмя ведущими нулями.
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"
Мы можем варьировать сложность этой задачи, изменяя количество ведущих нулей.
Но четырех вполне достаточно.
Вы сами видите, что один дополнительный ноль существенно замедляет процесс поиска решения.
Работа над классом практически завершена и теперь мы готовы начать с ним взаимодействовать с помощью HTTP-запросов.
Шаг второй: Блокчейн как API
Здесь мы будем использовать Python Flask, микрофреймворк, который упрощает процесс сопоставления конечных точек с функциями Python, что позволяет нам вести диалог с блокчейном через Интернет с помощью HTTP-запросов.Создаем три метода:
- /транзакции/новое создать новую транзакцию в блоке
- /мой добыть новый блок на сервере
- /цепь чтобы вернуть полный блокчейн.
Напишем шаблонный код: 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)
Краткое пояснение того, что мы добавили:
Строка 15: Создает экземпляр узла.
Вы можете прочитать больше о Flask Здесь .
Строка 18: Создает собственное имя для узла.
Строка 21: Создает экземпляр класса Блокчейн .
Строки 24–26: Создает конечную точку.
/мой , то есть запрос GET. Строки 28–30: Создает конечную точку.
/транзакции/новое , то есть POST-запрос, так как именно сюда мы будем отправлять данные.
Строки 32–38: Создает конечную точку.
/цепь , который возвращает весь блокчейн.
Строки 40–41: Запускает сервер на порту 5000. Конечная точка транзакций Вот как будет выглядеть запрос транзакции.
Вот что пользователь отправляет на сервер: {
"sender": "my address",
"recipient": "someone else's address",
"amount": 5
}
У нас уже есть метод класса для добавления транзакции в блок, так что все остальное несложно.
Напишем функцию для добавления транзакции: 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
Конечный пункт добычи полезных ископаемых
Именно в этой конечной точке происходит вся магия, но в этом нет ничего особенно сложного.
Он должен сделать три вещи:
- Рассчитать подтверждение работы
- Дайте майнеру (то есть нам) вознаграждение, добавив транзакцию, в ходе которой мы получаем одну монету
- Встроить новый блок в цепочку
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
block = blockchain.new_block(proof)
response = {
'message': "New Block Forged",
'index': block['index'],
'transactions': block['transactions'],
'proof': block['proof'],
'previous_hash': block['previous_hash'],
}
return jsonify(response), 200
Обратите внимание, что получателем созданного блока является адрес узла.
Большая часть того, что мы здесь делаем, сводится к взаимодействию с методами нашего класса.
Блокчейн .
По завершении этого шага основная работа завершена, можно начинать диалог.
Шаг третий: Диалог с блокчейном
Для взаимодействия с API внутри системы можно использовать старый добрый cURL или Postman. Запустим сервер: $ python blockchain.py
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)Попробуем создать блок, отправив GET-запрос на localhost:5000/mine:
Теперь мы создаем новую транзакцию, отправляя POST-запрос, содержащий ее структуру, локальный хост :5000/транзакции/новое:
Если вы не работаете с Postman, сформулируйте аналогичный запрос в cURL следующим образом:
$ curl -X POST -H "Content-Type: application/json" -d '{
"sender": "d4ee26eee15148ee92c6cd394edd974e",
"recipient": "someone-other-address",
"amount": 5
}' " http://localhost:5000/transactions/new "Я перезапустил сервер и создал еще два блока, всего их стало три.
Давайте рассмотрим полученную цепочку с помощью запроса localhost:5000/chain: {
"chain": [
{
"index": 1,
"previous_hash": 1,
"proof": 100,
"timestamp": 1506280650.770839,
"transactions": []
},
{
"index": 2,
"previous_hash": "c099bc.bfb7",
"proof": 35293,
"timestamp": 1506280664.717925,
"transactions": [
{
"amount": 1,
"recipient": "8bbcb347e0634905b0cac7955bae152b",
"sender": "0"
}
]
},
{
"index": 3,
"previous_hash": "eff91a.10f2",
"proof": 35089,
"timestamp": 1506280666.1086972,
"transactions": [
{
"amount": 1,
"recipient": "8bbcb347e0634905b0cac7955bae152b",
"sender": "0"
}
]
}
],
"length": 3
}
Шаг четвертый: консенсус
Это все очень круто.У нас есть простой блокчейн, который позволяет совершать транзакции и создавать новые блоки.
Но блокчейн имеет смысл только в том случае, если он децентрализован.
А если мы сделаем его децентрализованным, как мы сможем вообще гарантировать, что везде будет отображаться одна и та же цепочка? Это называется проблемой консенсуса.
Если мы хотим иметь в системе более одного узла, нам придется ввести алгоритм консенсуса.
Распознавание новых узлов Прежде чем реализовывать алгоритм консенсуса, нам нужно что-то сделать, чтобы каждый узел системы знал о существовании своих соседей.
Каждый узел в системе должен иметь реестр всех остальных узлов.
Это означает, что вам потребуются дополнительные конечные точки:
- /узлы/регистр , который примет список новых узлов в формате URL.
- /узлы/решить реализовать алгоритм консенсуса, который будет разрешать конфликты и гарантировать, что узел содержит правильную цепочку.
.
from urllib.parse import urlparse
.
class Blockchain(object):
def __init__(self):
.
self.nodes = set()
.
def register_node(self, address):
"""
Add a new node to the list of nodes
:param address: <str> Address of node. Eg. ' http://192.168.0.5:5000 '
:return: None
"""
parsed_url = urlparse(address)
self.nodes.add(parsed_url.netloc)
Примечание: мы использовали набор() для хранения списка узлов.
Это простой способ гарантировать, что при добавлении новых узлов будет соблюдаться индемпотентность — то есть, сколько бы раз мы ни добавляли тот или иной узел, он будет засчитан только один раз.
Реализация алгоритма консенсуса Как я уже упоминал, конфликт возникает, когда цепочка одного узла отличается от цепочки другого.
Чтобы его устранить, введем следующее правило: прерогатива всегда принадлежит той цепочке, которая длиннее.
Другими словами, актуальной считается самая длинная цепочка в системе.
Используя этот алгоритм, мы достигаем консенсуса между всеми узлами системы: .
import requests class Blockchain(object) .
def valid_chain(self, chain):
"""
Determine if a given blockchain is valid
:param chain: <list> A blockchain
:return: <bool> True if valid, False if not
"""
last_block = chain[0]
current_index = 1
while current_index < len(chain):
block = chain[current_index]
print(f'{last_block}')
print(f'{block}')
print("\n-----------\n")
# Check that the hash of the block is correct
if block['previous_hash'] != self.hash(last_block):
return False
# Check that the Proof of Work is correct
if not self.valid_proof(last_block['proof'], block['proof']):
return False
last_block = block
current_index += 1
return True
def resolve_conflicts(self):
"""
This is our Consensus Algorithm, it resolves conflicts
by replacing our chain with the longest one in the network.
:return: <bool> True if our chain was replaced, False if not
"""
neighbours = self.nodes
new_chain = None
# We're only looking for chains longer than ours
max_length = len(self.chain)
# Grab and verify the chains from all the nodes in our network
for node in neighbours:
response = requests.get(f' http://{node}/chain ')
if response.status_code == 200:
length = response.json()['length']
chain = response.json()['chain']
# Check if the length is longer and the chain is valid
if length > max_length and self.valid_chain(chain):
max_length = length
new_chain = chain
# Replace our chain if we discovered a new, valid chain longer than ours
if new_chain:
self.chain = new_chain
return True
return False
Первый метод действительная_цепочка() отвечает за проверку цепочек на достоверность, просматривая каждый блок и проверяя как хэш, так и доказательство.
разрешить_конфликты() — метод, который обрабатывает все соседние узлы: загружает их цепочки и проверяет их описанным выше способом.
Если обнаруживается действующая цепочка, длиннее нашей, производится замена.
Давайте введем в наш API две конечные точки: одну для добавления соседей, другую для разрешения конфликтов: @app.route('/nodes/register', methods=['POST'])
def register_nodes():
values = request.get_json()
nodes = values.get('nodes')
if nodes is None:
return "Error: Please supply a valid list of nodes", 400
for node in nodes:
blockchain.register_node(node)
response = {
'message': 'New nodes have been added',
'total_nodes': list(blockchain.nodes),
}
return jsonify(response), 201
@app.route('/nodes/resolve', methods=['GET'])
def consensus():
replaced = blockchain.resolve_conflicts()
if replaced:
response = {
'message': 'Our chain was replaced',
'new_chain': blockchain.chain
}
else:
response = {
'message': 'Our chain is authoritative',
'chain': blockchain.chain
}
return jsonify(response), 200
На этом этапе, если хотите, вы можете задействовать другие машины и создать разные узлы для своей системы.
Или добиться того же, используя разные порты на одной машине.
Я создал новый узел на другом порту на той же машине и позволил исходному узлу распознать его.
Таким образом мы получили два узла: localhost:5000 и localhost:5001. 
Я добавил больше блоков ко второму узлу, чтобы сделать цепочку значительно длиннее.
Затем вызывается GET /узлы/решить в первом узле — и алгоритм консенсуса заменил свою цепочку на цепочку второй.
Ну вот и все.
Теперь соберите друзей и вместе протестируйте блокчейн.
Надеюсь, этот материал вдохновит вас на новые идеи.
Лично я с большим энтузиазмом отношусь к развитию криптовалюты: я уверен, что блокчейн изменит наше представление об экономике, правительстве и хранении информации.
В будущем планирую выпустить вторую часть статьи, где мы добавим в блокчейн механизм проверки транзакций и поговорим о том, как все это можно использовать в продуктах.
Теги: #платежные системы #блокчейн #python #криптовалюта #майнинг #биткойн #Криптография
-
Несколько Малоизвестных Практических Правил
19 Oct, 24 -
Openmoko В Qemu
19 Oct, 24 -
Интернет-Магазин – 13 Способов Разориться
19 Oct, 24
