Pythonist

Bitcoin — всеобщий любимец из числа криптовалют. Новшество, которое он привнес, — решение проблемы двойного расходования при помощи блокчейна — цепочки блоков информации. Вместо того чтобы хранить значения в централизованном банке, блокчейн формирует децентрализованную систему.

Какую структуру имеет блокчейн? Каждый блок имеет хеш-сумму, также в нем содержатся данные о транзакции и метка времени. Кроме того, в блоке есть копия хеш-суммы предыдущего блока. Выглядит все это примерно так:

Хм, на что же это похоже? На какую структуру данных? Точно! Это же связный список!

Итак, давайте возьмем класс связного списка, который мы создали ранее (см. статью «Связный список на Python: что это такое и как его реализовать», — прим. ред. Pythonist), и превратим его в простой блокчейн. Мы внесем в него несколько простых изменений, и вы увидите, что объектно-ориентированное программирование на Python позволяет создавать крутые вещи.

Внедряем ООП

Для начала нам нужно внедрить в наш класс связного списка некоторые принципы ООП (объектно-ориентированного программирования). Да, поначалу это кажется сложным. Но если мы хотим, чтобы наш блокчейн был защищенным, нам нужно сделать кое-какие вещи приватными. Этот принцип называется инкапсуляцией. Суть его в том, что некоторые поля и методы делаются доступными только изнутри класса. Поскольку мы не хотим, чтобы кто-то мог нарушить структуру нашей криптовалюты, нам нужно ограничить возможность взаимодействия с ней.

Давайте сначала перечитаем класс Node, который мы создали ранее. Изменим его имя на Block, поскольку теперь он будет представлять один блок блокчейна. Также добавим пару импортов, которые будут использоваться в классе.

import datetime
import math
import pprint


class Block:
    def __init__(self, data):
        self.next = None
        self.data = data

    def append(self, val):
        end = Block(val)
        n = self
        while (n.next):
            n = n.next
        n.next = end

Стоит отметить, что блокчейн обладает парой отличительных свойств. Во-первых, он отличается иммутабельностью, т. е. записи в нем трудно изменить (если вообще возможно). Во-вторых, он публичный. Да, именно так. Блокчейн Bitcoin-а это публичные записи, вы можете просмотреть их хоть сейчас.

В настоящий момент данные нашего узла хранятся просто как data. При помощи дот-нотации кто угодно может получить к ним доступ и изменить их: my_block.data = "One Million Dollarssss". Нас это не устраивает. Мы можем сделать это поле приватным, добавив к имени data двойной символ подчеркивания (__data), а затем создав специальный метод, позволяющий пользователям читать данные (т. е. публичный доступ сохранится).

def __init__(self, data):
    self.next = None
    self.__data = data

Теперь давайте напишем метод, позволяющий пользователям читать значения. В ООП мы называем это get-методом, с его помощью мы просто возвращаем значение желаемого поля.

def get_data(self):
    return self.__data

Прокачиваем наш связный список

Теперь, когда мы встроили в наш класс защитный механизм, давайте добавим то, что сделает его собственно блокчейном. Для начала нам нужно сохранить кое-что в переменной data. Мы превратим ее в словарь, хранящий хеш блока, предыдущий хеш и метку времени. В блокчейне Bitcoin-а, как вы видели, в одном блоке могут храниться несколько транзакций (в форме дерева хешей). Мы не станем так углубляться и будем хранить только одну «транзакцию». Обязательно передайте в качестве параметров предыдущий хеш, транзактора и сумму.

def __init__(self, prev_hash, transactor, amount):
    self.next = None
    self.__data = {
        "prev_hash": prev_hash,
        "time": datetime.datetime.now().time(),
        "transactor": transactor,
        "amount": amount,
        "hash": ???
    }

Как сделать хеш блока? В блокчейне это делается так: вы берете хеш предыдущего блока и видоизменяете его, используя суперсекретный алгоритм хеширования. Вы можете сделать свой алгоритм сколь угодно сложным, но он может быть и очень простым:

def make_hash(self):
    return self.__data["prev_hash"] + 1

Теперь у нас есть автоматически инкрементирующаяся SQL-база данных. Прекрасно. Давайте сделаем нечто более сложное. Возьмем сумму транзакции, возведем ее в странную степень, прибавим порядковый номер последней буквы имени транзактора, и прибавим все это к предыдущему хешу.

def make_hash(self):
    return self.__data["prev_hash"] + int(int(self.__data["amount"])**1.5) + ord(self.__data["transactor"][-1])

Итак, у нас есть функция хеширования, теперь нужно вызвать ее в конструкторе. Вызывать нужно непременно после определения __data.

def __init__(self, prev_hash, transactor, amount):
    self.next = None
    self.__data = {
        "prev_hash": prev_hash,
        "time": datetime.datetime.now().time(),
        "transactor": transactor,
        "amount": amount,
        "hash": ""
    }
    self.__data["hash"] = self.make_hash()

Наконец, нужно обновить метод append(). Вместо data мы в качестве параметров будем передавать имя транзактора и сумму. Затем, прежде чем создать новый блок, мы получим последний хеш и передадим его в Block месте с другими данными. После этого добавим блок к концу цепочки.

def append(self, transactor, amount):
    n = self
    while (n.next):
        n = n.next
    prev_hash = n.get_data()["hash"]
    end = Block(prev_hash, transactor, amount)
    n.next = end

Делаем цепочку неизменяемой

Как вы помните, блокчейны отличаются неизменяемостью (иммутабельностью). То есть изменить их очень сложно. Это свойство завязано на том, что каждый хеш зависит от сохраняемых в блоке данных (по крайней мере в нашей функции). При изменении значения в блоке должны обновиться все хеши во всех последующих блоках. Если блоков всего несколько, это не займет много времени, но представьте, что у нас очень длинная цепочка, а ее обновление имеет временную сложность O(N).

Для обновления суммы транзакции мы создадим специальный метод. Блокчейн Bitcoin-а вполне может быть реализован как-то иначе, но у нас ведь просто его подобие. В ООП это называется set-методом. Он принимает новое значение и устанавливает скрытое значение data, исключая прямое вмешательство пользователя. Не забудьте вызвать функцию make_hash, чтобы получить обновленный хеш для блока.

def set_amount(self, amount):
    self.__data["amount"] = amount
    self.__data["hash"] = self.make_hash()

Но погодите, это еще не все. Нам нужно обновить хеши всех последующих блоков. Как это сделать? Конечно же путем обхода связного списка! (См. статью «Удаление дубликатов из связного списка в Python», — прим. ред. Pythonist). Как вы помните, мы начинаем со временного указателя и используем цикл while.

temp = self
while(temp.next):

Для каждого блока нам нужно получить его обновленный хеш и сохранить его как prev_hash. Затем, перейдя к следующему блоку, мы обновляем его хеши, используя хеш предыдущего блока. Мы будем делать это при помощи скрытого метода __update_hashes().

def set_amount(self, amount):
    self.__data["amount"] = amount
    self.__data["hash"] = self.make_hash()
    temp = self
    while (temp.next):
        prev_hash = temp.__data["hash"]
        temp = temp.next
        temp.__update_hashes(prev_hash)

В нашем методе __update_hashes() мы принимаем в качестве параметра предыдущий хеш, сохраняем его в __data, а затем используем функцию make_hash() для создания хеша текущего блока.

def __update_hashes(self, new_prev):
    self.__data["prev_hash"] = new_prev
    self.__data["hash"] = self.make_hash()

Вот и все! Мы создали базовый функционал нашего блокчейна.

Проверяем

Давайте построим блокчейн при помощи нашего метода Block. Следующий код вы можете просто скопировать (он позволит вывести нашу цепочку блоков).

def print_chain(chain):
    pp = pprint.PrettyPrinter(indent=4)
    node = chain
    pp.pprint(node.get_data())
    while node.next:
        node = node.next
        pp.pprint(node.get_data())

Давайте создадим первый блок. Передадим в него имя и сумму. Предыдущий хеш для первого блока в цепочке — всегда 0.

chain = Block(0, 'Tim', 120.00)

Теперь добавим еще несколько блоков.

chain.append('Jamil', 200.00)
chain.append('Carla', 123.45)
chain.append('Sarah', 450.00)

print_chain(chain)

Вы увидите следующий вывод:

{   'amount': 120.0,
    'hash': 1423,
    'prev_hash': 0,
    'time': datetime.time(0, 11, 46, 849539),
    'transactor': 'Tim'}
{   'amount': 200.0,
    'hash': 4359,
    'prev_hash': 1423,
    'time': datetime.time(0, 11, 46, 849608),
    'transactor': 'Jamil'}
{   'amount': 123.45,
    'hash': 5820,
    'prev_hash': 4359,
    'time': datetime.time(0, 11, 46, 849617),
    'transactor': 'Carla'}
{   'amount': 450.0,
    'hash': 15469,
    'prev_hash': 5820,
    'time': datetime.time(0, 11, 46, 849624),
    'transactor': 'Sarah'}

Если вы использовали другой алгоритм хеширования, ваши хеши могут отличаться. Но суть в том, что каждый хеш создается на базе предыдущего.

Давайте попробуем обновить сумму. Установим новое значение суммы для второго человека, Джамиля. По идее мы должны увидеть, что обновятся хеши всех последующих блоков, а хеш блока Тима останется тем же.

chain.next.set_amount(700)

print("UPDATE:")
print_chain(chain)

Вывод:

UPDATE:
{   'amount': 120.0,
    'hash': 1423,
    'prev_hash': 0,
    'time': datetime.time(0, 11, 46, 849539),
    'transactor': 'Tim'}
{   'amount': 700,
    'hash': 20051,
    'prev_hash': 1423,
    'time': datetime.time(0, 11, 46, 849608),
    'transactor': 'Jamil'}
{   'amount': 123.45,
    'hash': 21512,
    'prev_hash': 20051,
    'time': datetime.time(0, 11, 46, 849617),
    'transactor': 'Carla'}
{   'amount': 450.0,
    'hash': 31161,
    'prev_hash': 21512,
    'time': datetime.time(0, 11, 46, 849624),
    'transactor': 'Sarah'}

Все прошло по плану! Вы создали собственную криптовалюту! Ну ладно, нечто похожее на нее. Если вам интересно, можете сделать форк оригинального кода Bitcoin и на его основе создать что-то свое. Код доступен на GitHub.