Как создать блокчейн – Как создать свой собственный Блокчейн

Как создать свой собственный Блокчейн

Согласно опросу, проведенному Juniper Research, 6 из 10 крупных владельцев бизнеса либо думают, либо развивают свои собственные блокчейн-технологии, как например – в здравохранении. Среди этих компаний 66% действительно считают, что блокчейн-технология будет интегрирована в их компании к началу 2019 года.

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

Дело в том, что системные изменения более эффективны, чем технологические. Таким образом, использование преимущества блокчейна предлагает надежный способ интеграции вашей компании в эпоху XXI века!

Blockchain против Database

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

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

2. Избыточность. Вам не нужно сходить с ума, потеряв важные файлы. Действительно, Вы можете получить один и тот же набор данных из любой точки вашей сети. Таким образом, больше нет потерь данных и повреждения файлов для Вас.

3. Безопасность. Централизованная база данных создает хорошую цель для хакеров. Блокчейн — это совсем другое «животное». Чем больше пользователей у Вас есть в сети, тем более точные копии бесценных данных вы получаете. Такой подход позволяет предотвратить жизненно важную информацию от серьезного искажения или даже постоянной потери.

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

5. Прозрачность. Используя блокчейна, вы получаете более высокий уровень доверия и способность вести бизнес открытым способом.

Давайте создадим Blockchain

Прежде чем мы начнем, вы также должны знать, что существует два типа блокчейна: частный блокчейн и публичный блокчейн.

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

Обратите внимание, что мы использовали Ubuntu, но также для пользователей будут удобны гайды других дистрибьюторов Linux, MacOS (с менеджером Homebrew) и Windows 10 (используя терминалы и последние стабильные двоичные файлы).

Установка Go Ethereum

Ваш первый шаг — установить Go Ethereum (geth). Go Ethereum является одной из исходных реализаций (вместе с C ++ и Python) протокола Ethereum, написанного на Go.

Для установки geth пользователи Mac OS X Вы должны использовать Homebrew, дополнительный менеджер пакетов для MacOS. Homebrew устанавливает необходимый Вам материал, который Вы не можете найти в Apple Store. После установки выполните следующие команды:

brew tap ethereum/ethereum
brew install ethereum

Чтобы установить Go Ethereum на Ubuntu, Вам нужно всего лишь использовать apt-get. Для этого выполните следующие команды:

sudo apt-get install software-properties-common
sudo add-apt-repository -y ppa:thereum/ethereum
sudo apt-get update
sudo apt-get install ethereum

Если Вы — пользователь Windows, Вам не нужно над этим долго думать. Все, что Вам нужно, это загрузить

соответствующую установку geth и запустить её.

Теперь Вы можете создать новый каталог и написать JSON файл для создания genesis-блока:

cd
mkdir eth-new
cd eth-new
nano genesis.json

Чтобы создать genesis-блок, вставьте следующий код в только что созданный JSON-файл:

{
"nonce": "0x0000000000000042",
"mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
"difficulty": "0x4000",
"alloc": {},
"coinbase": "0x0000000000000000000000000000000000000000",
"timestamp": "0x00",
"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",


"extraData": "Custem Ethereum Genesis Block",
"gasLimit": "0xffffffff"
}

Нажмите Ctrl + X, Y, Enter, чтобы сохранить Ваш новый genesis-блок.

Создайте свой блокчейн

Выполните следующие команды, чтобы создать блокчейн (для отключения функции maxexers установлено значение 0):

mkdir eth-data
geth --datadir eth-new genesis.json init eth-new/genesis.json --networkid 123 --nodiscover --maxpeers 0 console

Чтобы ввести новую учетную запись и пароль в консоли geth, выполни

merehead.com

Как создать blockchain 🚩 Финансы 🚩 Другое

Blockchain – цифровая система учета. В ней хранятся сведения о транзакциях, сделанных с использованием криптовалюты. Это публичная база данных, где новые сведения и алгоритмы записываются в виде специальных блоков. Они же образуют свою цепочку. Так формируется блокчейн.

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

Если вы решили создать подобную систему учета, определитесь с тем, как будет выглядеть блок. Он состоит и:

• ·         из индекса;
• ·         временной метки,
• ·         данных.

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

Информация о появлении новых массивов добавляется в блокчейн так: когда майнер разгадывает блок, он сразу добавляет его в базу. В течении сотой доли секунды информация передается другим участникам системы.

Для создания блокчейна потребуется самый первый массив. Он добавляется вручную или с использованием специальной программы. Для этого прописывается функция, добавляющая genesis block. Он содержит индекс, произвольные данные и хэш прошлого блока. Благодаря этому можно создать функцию для добавления новых алгоритмов. Она нужна для приемки предыдущей информации в сети в качестве основного параметра.

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

Для защиты системы от хакеров и внесения ложной информации в момент создания добавляется уникальное описание характеристик, полученное тоже с помощью метода шифрования. Система постоянно производит сверку соответствия параметров. Благодаря этому подделать или поменять местами массивы с информацией практически невозможно.

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

Система, построенная на блокчейн, считается одной из самых надежных. Криптовалюту невозможно подделать или украсть. Это связано с тем, что:

1. Информационная база есть сразу у всех участников, а копии постоянно проходят автоматическую сверку.
2. Хеш-функция высчитывается по специальному алгоритму, имеет временную метку. Если кому-то удастся разгадать схему, он не сможет ее использовать в собственных целях, поскольку временная метка не совпадет.
3. Все части системы взаимосвязаны с собой, не могут быть изменены.

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

www.kakprosto.ru

Изучаем блокчейн на практике / Everyday Tools corporate blog / Habr

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

Но разобраться в блокчейне не так-то просто, по крайней мере, по моему опыту. Я корпел над заумными видео, продирался через туториалы и с нарастающей досадой отмечал недостаток иллюстрирующих примеров.

Я предпочитаю учиться в процессе работы. При таком раскладе мне приходится отрабатывать тему сразу на уровне кода, что помогает закрепить навык. Если вы последуете моему примеру, то к концу статьи у вас будет функционирующий блокчейн и ясное понимание, как это все работает.

Но для начала…

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

Если вы не совсем понимаете, что такое хэш, вам сюда.

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

Что будет нужно для работы? Проверьте, чтобы у вас был установлен Python 3.6+ (вместе с pip). Также вам нужно будет установить Flask и прекрасную библиотеку Requests:

 pip install Flask==0.12.2 requests==2.18.4  

Ах да, еще вам понадобится HTTP клиент, например, Postman или cURL. Тут подойдет любой.

Где можно посмотреть то, что получится в итоге? Исходный код доступен здесь.

Шаг первый: Делаем блокчейн

Откройте свой любимый текстовый или графический редактор, мне вот, например, нравится PyCharm. Создайте новый файл под названием blockchain.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 

Класс Blockchain отвечает за управление цепочкой. Здесь будут храниться транзакции, а также некоторые вспомогательные методы для добавления в цепочку новых блоков. Давайте распишем эти методы.

Как выглядит блок?

В каждом блоке содержится индекс, метка времени (в Unix), список транзакций, доказательство и хэш предыдущего блока.

Вот пример того, как может выглядет отдельный блок:

block = {
    'index': 1,
    'timestamp': 1506057125.900785,
    'transactions': [
        {
            'sender': "8527147fe1f5426f9dd545de4b27ee00",
            'recipient': "a77f5cdfa2934df3954a5c7c7da5df1f",
            'amount': 5,
        }
    ],
    'proof': 324984774000,
    'previous_hash': "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
}

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

Понятно? Если нет, остановитесь и дайте себе время усвоить эту информацию — именно в ней состоит базовый принцип блокчейна.

Добавляем транзакции в блок

Нам нужно каким-то образом добавлять в блок новые транзакции. За это отвечает метод 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
 

Когда new_transaction() добавляет новую транзакцию в список, он возвращает индекс блока, куда она была записана, следующему, с которым будет осуществляться майнинг. Позже это пригодится следующему пользователю, добавляющему транзакцию.

Помимо создания блока genesis в конструкторе, мы также распишем методы new_block(),

new_transaction() и 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, должен оканчиваться на 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

В биткойне алгоритм доказательства работы называется HashCash и не особенно отличается от простенького примера, приведенного выше. Это уравнение, которые майнеры наперегонки пытаются разрешить, чтобы создать новый блок. В целом, сложность определяется тем, сколько символов нужно вычислить в заданной последовательности. За верный ответ майнеры получают вознаграждение в виде одной монеты — в ходе транзакции.

Проверить их решение для системы не составляет труда.

Пишем простое доказательство работы

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

Найдите число 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 запросов.

Создаем три метода:

• /transactions/new для создания новой транзакции в блоке
• /mine для майнинга нового блока на сервере
• /chain для возвращения полной цепочки блокчейна.

Настраиваем Flask

Наш «сервер» сгенерирует один-единственный узел сети в блокчейн-системе. Давайте напишем немного шаблонного кода:

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: Инстанцирует класс Blockchain.
Строки 24-26: Создает конечную точку /mine, то есть запрос GET.
Строки 28-30: Создает конечную точку /transactions/new, то есть запрос POST, так как именно туда мы и будем отсылать данные.
Строки 32-38: Создает конечную точку /chain, который возвращает блокчейн целиком.
Строки 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

Конечный пункт для майнинга

Именно в этой конечной точке творится вся магия, но ничего особо сложного в нем нет. Она должна делать три вещи:

1. Рассчитывать доказательство работы
2. Выдавать майнеру (то есть нам) вознаграждение, добавляя транзакцию, с ходе которой мы получаем одну монету
3. Встраивать новый блок в цепочку

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

Обратите внимание, что в качестве получателя созданного блока указан адрес узла. Большая часть того, что мы тут делаем, сводится к взаимодействию с методами нашего класса Blockchain. По завершению этого шага основная работа закончена, можно начинать диалог.

Шаг третий: Диалог с блокчйном

Для взаимодействия с API в рамках системы можно использовать старый-добрый cURL или Postman.

Запускаем сервер:

$ python blockchain.py
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Давайте попробуем создать блок, отправив запрос GET по адресу localhost:5000/mine:
Теперь создаем новую транзакцию, отправив запрос POST, содержащий ее структуру, по адресу localhost:5000/transactions/new:
Если вы работаете не с 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
}

Шаг четвертый: Консенсус

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

Распознаем новые узлы

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

1. /nodes/register, который будет принимать список новых узлов в URL формате
2. /nodes/resolve для внедрения алгоритма консенсуса, который будет разрешать возникающие конфликты и отслеживать, чтобы в узле содержалась правильная цепочка.

Нам нужно подкорректировать конструктор блокчейна и обеспечить метод для регистрации узлов:

...
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)

Заметьте: мы использовали set() для хранения списка узлов. Это нехитрый способ гарантировать, что при добавлении новых узлов будет соблюдаться индемпотентность — то есть сколько бы раз мы ни добавляли какой-то конкретный узел, он будет засчитан только единожды.

Внедряем алгоритм консенсуса

Как я уже упоминал, конфликт происходит тогда, когда цепочка одного узла отличается от цепочки другого. Чтобы его устранить, мы введем такое правило: прерогатива всегда у той цепочки, которая длиннее. Иными словами, самая длинная цепочка в системе рассматривается как фактическая. Используя такой алгоритм, мы достигаем консенсуса среди всех узлов системы:

...
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

Первый метод valid_chain() отвечает за проверку цепочек на валидность, проходя каждый блок и верифицируя и хэш, и доказательство.

resolve_conflicts() — метод, который прорабатывает все соседние узлы: скачивает их цепочки и проверяет их описанным выше способом. Если при этом найдена валидная цепочка длиннее, чем наша, производится замена.

Давайте введем в наш 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 /nodes/resolve в первом узле — и алгоритм консенсуса заменил его цепочку на цепочку второго.
Ну, вот и все. Теперь собирайте друзей и тестируйте вам блокчейн совместными усилиями.

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

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

habr.com

Как запустить свой блокчейн-стартап в 2018 году ? FAQ

Демозона Блокчейн новости О конференции Партнёры О нас Локация Контакты Итоги Итоги осень 2017 Итоги 2014 Итоги 2015 Итоги весна 2017 Итоги осень 2016 Итоги весна 2016 Итоги весна 2018 Итоги осень 2018 Ивенты Демозона Блокчейн новости О конференции Партнёры О нас Локация Контакты Итоги Итоги осень 2017 Итоги 2014 Итоги 2015

moscow.bc.events

Что такое блокчейн — как вывести деньги с блокчейн кошелька?

Развитие компьютерных технологий помогает человеку осуществлять огромное количество операций, не боясь, что информация будет украдена. Чтобы в этом убедиться, необходимо разобраться, что такое блокчейн, какие преимущества и недостатки он имеет и как правильно создать такую систему.

Что такое блокчейн-технологии?

Под этим термином понимают процесс распределения информации, которая может иметь отношение к разным жизненным вопросам, для ее хранения. Это определенные цепочки, которые связывают компьютеры по всему миру. Например, технология блокчейн может хранить данные о денежных переводах. Еще ее используют применительно к криптовалюте, так она гарантирует фиксирование информации про все финансовые переводы. Еще один интересный момент, касающийся того, кто придумал блокчейн – технология была разработана программистом российского происхождения Виталиком Бутериным.

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

Как работает блокчейн?

Технология основана на том, что все цифровые записи соединены в «блоки», которые связаны между собой криптографически и хронологически в определенную цепь. Для нее используются сложные математические алгоритмы. Блокчейн-схема новой экономики включает блоки, которые содержат в себе определенный набор записей. Новые блоки всегда присоединяются в конец цепочки.

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

Плюсы и минусы блокчейна

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

Преимущества блокчейн

Эксперты уверяют, что внедрение блокчейна по своему возможному эффекту не уступает открытию интернета, просто нужно еще немного времени для осознания этого.

1. Представленная технология помогает заниматься торговлей, внедрить разные сервисы в жизни и даже изменить работу банковской сферы.
2. Суть блокчейна базируется на прозрачности и безопасности, поэтому не стоит беспокоиться о возможных подводных камнях.
3. Используя систему можно избежать коррупции, которая часто становится существенной преградой для развития.
4. Можно создать свой блокчейн альянс, в который будут входить поставщики, партнеры и даже конкуренты.

Недостатки блокчейн

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

1. Производительность блокчейна ниже, если сравнивать ее с высоконагруженными системами.
2. Пока еще сложно найти разработчиков, которые бы быстро и без ошибок справились с работой. К тому же для поддержания системы необходимы специалисты, которых также мало.
3. Критика блокчейн касается и того, что необходимы большие инвестиции в инфраструктуру, то есть безопасность, систему хранения приватных ключей и так далее.

Как создать блокчейн систему?

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

Блокчейн – как заработать?

С каждым днем интерес к технологиям блокчейн растет и согласно исследованиям больше 50% мировых банков инвестируют или планируют инвестировать в эту систему. У частного вкладчика есть несколько возможностей стать частью этой инновационной технологии.

1. Акции. Инвестиции в блокчейн подразумевают покупку акций быстрорастущих публичных компаний, которые используют новомодные технологии. К ним относят: BTCS, Global Arena Holding, HashingSpace, DigitalX и другие.
2. Краудфандинг. Под этим термином понимают народно-общественное финансирование, благодаря которому начинающие компании могут создавать свои собственные валюты для продажи. Среди таких площадок можно выделить: BnkToTheFuture, QTUM и Waves

Как пополнить блокчейн-кошелек?

Есть несколько вариантов получения криптовалюты:

1. Можно купить биткоины у держателя, который хочет их продать. Здесь существует большой риск обмана, поэтому рекомендовать данный вариант не будем.
2. Транзакция блокчейн может быть осуществлена через обменники, количество которых в сети огромно. Сначала рекомендуется посетить мониторинг обменников, чтобы выбрать ресурс с лучшим курсом, например, хорошие отзывы о системе Bestchange.
3. Многие используют биржи, благодаря которым через электронные платежные системы можно пополнить кошелек. Надежными и удобными считаются следующие ресурсы: exmo.com, BTC-E.com.
4. Выясняя, что такое кошелек блокчейн и как его пополнить, стоит предложить еще один вариант – продажа услуг и товаров за криптовалюту. Этот вариант не является распространенным, но с каждым годом все больше переходят на торговлю через криптовалюту.

Как вывести деньги с блокчейн кошелька?

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

1. В собственном аккаунте необходимо в разделе «Тип транзакции» выбрать «Пользовательская». В появившемся окне активируйте свой кошелек из выпавшего списка, введите номер кошелька получателя, сумму и комиссию перевода. Последнее значение зависит от размера перевода и желаемой скорости, то есть чем она будет больше, тем быстрее деньги переведутся. Учтите, что комиссия снимается поверх суммы.
2. После этого кликните на кнопку «Просмотреть платеж», в результате чего будут представлены технические данные транзакции. На этом этапе можно отменить или же подтвердить платеж.

Лучшие книги по блокчейн

Люди, которые связаны с развивающейся системой блокчейн, делятся со всеми желающими информацией в своих книгах. Среди стоящих изданий можно выделить следующие произведения:

1. «Блокчейн: сценарий новой экономики» М. Свэн. Автор является основателем независимой организации, которая называется «Институт изучения блокчейна». Книга рассказывает о том, что блокчейн – рождение новой экономики, какие есть принципы работы технологии и как ее применять в реальной жизни.
2. «Революция блокчейна» Д. и А. Тапскотты. Авторы рассказывают о сценарии применения новой системы и возможности ее использования в жизни. В книге упоминаются и перспективы блокчейн.
3. «Наука о блокчейне» Р. Воттенхофер. Автор является преподавателем в институте, который длительное время изучал тему криптовалют. В книге он научным языком объясняет основные приемы, используемы при распределении систем.

 

womanadvice.ru

Как сделать свой блокчейн. Часть 1 — Создание, Хранение, Синхронизация, Отображение, Майнинг и Доказательная работа

Доброго всем! Мы тут потихоньку начали исследовать новое совсем для нас направление для обучения — блокчейны и нашли то, что оказалось интересным в рамках нашего курса по Python, в том числе. Чем, собственно, и хотим поделиться с вами.

Я могу узнать, когда у меня появился первый Bitcoin, из истории кошелька в моем аккаунте на Coinbase — входящая транзакция в 2012 году в подарок за регистрацию. Bitcoin в то время стоил около 6.50$. Если бы я сохранил те 0.1 BTC, на момент написания статьи это бы уже стоило более 500$. Если кому-то интересно, я продал их, когда Bitcoin стоил 2000$. Так что я получил только 200$ вместо ныне возможных 550$. Не стоило торопиться.

О существовании Bitcoin я знал, но особо не интересовался. Я видел взлеты и падения курса $/BTC. Я видел, как люди говорят, что за ним будущее, а видел статьи о его полной бессмысленности. Но личного мнения у меня не было — просто наблюдал со стороны.
Точно так же я почти не следил за блокчейнами. Но в последнее время мой отец несколько раз упоминал, что на CNBC и Bloomberg, которые он смотрит по утрам, часто рассказывают о блокчейнах, и он понятия не имеет, что это.

И тогда я внезапно понял, что нужно чуть глубже разобраться в этой теме. И начал с “исследования” — прочитал огромное количество статей в интернете, объясняющую их суть. Некоторые были хорошие, некоторые плохие, некоторые глубокие, а некоторые очень поверхностные.

Чтения оказалось недостаточно, а если существует одна вещь, которую я знаю наверняка, так это то, что чтение не объяснит и сотой доли того, что объяснит программирование. И так я понял, что стоит написать свой собственный локальный блокчейн.

Нужно учитывать, что есть большая разница между базовым блокчейном, который я описываю и “профессиональным” блокчейном. Эта цепь не создаст криптовалюту. Блокчейны не требуют производства монет, которые можно продавать и менять на физические деньги.
Блокчейны используются для хранения и подтверждения информации. Монеты помогают стимулирующим узлами участвовать в валидации, но они не обязаны существовать.
Я пишу пост по нескольким причинам: 1) Чтобы люди, прочитавшие его, смогли узнать больше о блокчейнах; 2) Чтобы я смог понять больше, объяснив код, а не просто написав его.
В этом посте я покажу способ хранения данных блокчейна и генерации начального блока, синхронизацию узла с локальными данными блокчейна, отображение блокчейна (что впоследствии будет использоваться для синхронизации с другими узлами), а затем, майнинг и создание валидных новых блоков. В первом посте не будет никаких других узлов. Никаких кошельков, пиров, важных данных. О них поговорим позднее.

В двух словах

Если вы не хотите углубляться в детали и читать код, или если вы наткнулись на этот пост, рассчитывая на статью, которая бы понятным языком объясняла блокчейны, я постараюсь кратко резюмировать, как они работают.

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

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

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

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

Если хотите изучить код, посмотрите ветку part 1 на Github. Смело присылайте мне любые вопросы, комментарии, правки и похвалы (если вы в настроении сделать что-то особо хорошее), или просто пишите в твиттер.

Шаг 1 — Классы и Файлы

Первый шаг — написание класса, обрабатывающего блоки при запуске узлов. Я назову этот класс Block. Честно говоря, много делать не придется. В функции __init__ мы будем верить, что вся необходимая информация уже представлена в словаре. Для производственного блокчейна — это не самое мудрое решение, но подходит в качестве примера, потому что код пишу только я. Также я напишу метод, запаковывающий важную информацию блока в словарь, а после заведу более удобный способ для отображения информации блока при его печати в терминал.

class Block(object):
  def __init__(self, dictionary):
  '''
    We're looking for index, timestamp, data, prev_hash, nonce
  '''
  for k, v in dictionary.items():
    setattr(self, k, v)
  if not hasattr(self, 'hash'): #in creating the first block, needs to be removed in future
    self.hash = self.create_self_hash()

  def __dict__(self):
    info = {}
    info['index'] = str(self.index)
    info['timestamp'] = str(self.timestamp)
    info['prev_hash'] = str(self.prev_hash)
    info['hash'] = str(self.hash)
    info['data'] = str(self.data)
    return info

  def __str__(self):
    return "Block<prev_hash: %s,hash: %s>" % (self.prev_hash, self.hash)

Чтобы создать первый блок, запустим этот простой код:

def create_first_block():
  # index zero and arbitrary previous hash
  block_data = {}
  block_data['index'] = 0
  block_data['timestamp'] = date.datetime.now()
  block_data['data'] = 'First block data'
  block_data['prev_hash'] = None
  block = Block(block_data)
  return block

Отлично. Последний вопрос в этой части — где хранить данные в файловой системе. Это необходимо, если мы не хотим потерять локальные данные блока при отключении узла.
Я назову папку с данными ‘chaindata’, в какой-то степени подражая схеме папок Etherium Mist. Каждому блоку теперь присвоен отдельный файл, названный по его индексу. Нужно убедиться, что имена файлов содержат в начале достаточное количество нулей, чтобы блоки перечислялись по порядку.

С учетом кода выше, нужно написать следующее для создание первого блока:

#check if chaindata folder exists.
chaindata_dir = 'chaindata'
if not os.path.exists(chaindata_dir):
  #make chaindata dir
  os.mkdir(chaindata_dir)
  #check if dir is empty from just creation, or empty before
if os.listdir(chaindata_dir) == []:
  #create first block
  first_block = create_first_block()
  first_block.self_save()

Шаг 2 — Синхронизация блокчейна, локально

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

def sync():
  node_blocks = []
  #We're assuming that the folder and at least initial block exists
  chaindata_dir = 'chaindata'
  if os.path.exists(chaindata_dir):
    for filename in os.listdir(chaindata_dir):
      if filename.endswith('.json'): #.DS_Store sometimes screws things up
        filepath = '%s/%s' % (chaindata_dir, filename)
        with open(filepath, 'r') as block_file:
          block_info = json.load(block_file)
          block_object = Block(block_info) #since we can init a Block object with just a dict
          node_blocks.append(block_object)
return node_blocks

Пока просто и красиво. Чтение строк из файлов их загрузка в структуры данных не требуют чрезмерно сложного кода. Пока это работает. Но в будущих постах, где я буду писать о возможностях коммуникации разных узлов, эта функция sync станет значительно сложнее.

Шаг 3 — Отображение блокчейна

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

Для этого я использую Flask — у него низкий порог вхождения, и я решил, что он подходит для наших целей.

Ниже представлен код для отображения json блокчейна. Я проигнорирую импорты для экономии места.

node = Flask(__name__)

node_blocks = sync.sync() #inital blocks that are synced

@node.route('/blockchain.json', methods=['GET'])
def blockchain():
  '''
  Shoots back the blockchain, which in our case, is a json list of hashes
  with the block information which is:
  index
  timestamp
  data
  hash
  prev_hash
  '''
  node_blocks = sync.sync() #regrab the nodes if they've changed
  # Convert our blocks into dictionaries
  # so we can send them as json objects later
  python_blocks = []
  for block in node_blocks:
    python_blocks.append(block.__dict__())
  json_blocks = json.dumps(python_blocks)
  return json_blocks

if __name__ == '__main__':
  node.run()

Запустите этот код, зайдите на localhost:3000/blockchain.json и увидите текущий блок.

Шаг 4 — “Майнинг”, также известный как создание блока

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

Сатоши описывает это следующим образом в Bitcoin whitepaper. Учтите, что “timestamp сервер” назван “узлом”.

“Начнем описание нашего решения с timestamp сервера. Его работа заключается в хэшировании блока данных, на который нужно поставить timestamp, и открытой публикации этого хэша… Timestamp показывает, что в данный момент конкретные данные существовали и потому попали в хэш блока. Каждый хэш включает в себя предыдущий timestamp: так выстраивается цепь, где очередное звено укрепляет все предыдущие.”

Скриншот изображения, прикрепленного под описанием:

Основная идея раздела — при необходимости соединить блоки, мы создаем хэш информации о новом блоке, включая время создания блока, хэш предыдущего блока и информацию в самом блоке. Я буду называть всю эту информацию “хедером” блока. Таким образом, мы можем проверить корректность блока, посчитав все хэши перед ним, подтвердив последовательность.

В данном случае хедер, который я создаю, объединяет значения строки в одну огромную строку. Я включил следующие данные:

1. Индекс, показывающий каким по счету является блок;
2. Хэш предыдущего блока;
3. Данные — просто случайные строки. Для bitcoin они называются Merkle root и содержат информацию о транзакциях;
4. Timestamp майнинга этого блока.

def generate_header(index, prev_hash, data, timestamp):
  return str(index) + prev_hash + data + str(timestamp)

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

Хедер Bitcoin значительно сложнее объединения строк. Он использует хэши данных и времени и завязан на то, как данные расположены в памяти. Но в нашем случае объединения строк достаточно.

Теперь у нас есть хедер и можно вычислить валидность хэша. Я буду использовать метод, отличающийся от метода Bitcoin, но все равно запущу хедер блока через функцию sha256.

def calculate_hash(index, prev_hash, data, timestamp, nonce):
  header_string = generate_header(index, prev_hash, data, timestamp, nonce)
  sha = hashlib.sha256()
  sha.update(header_string)
  return sha.hexdigest()

Для майнинга блока мы используем функцию выше, чтобы получить хэш, положить его в новый блок и сохранить этот блок в директории chaindata.

node_blocks = sync.sync()

def mine(last_block):
  index = int(last_block.index) + 1
  timestamp = date.datetime.now()
  data = "I block #%s" % (int(last_block.index) + 1) #random string for now, not transactions
  prev_hash = last_block.hash
  block_hash = calculate_hash(index, prev_hash, data, timestamp)

  block_data = {}
  block_data['index'] = int(last_block.index) + 1
  block_data['timestamp'] = date.datetime.now()
  block_data['data'] = "I block #%s" % last_block.index
  block_data['prev_hash'] = last_block.hash
  block_data['hash'] = block_hash
  return Block(block_data)

def save_block(block):
  chaindata_dir = 'chaindata'
  filename = '%s/%s.json' % (chaindata_dir, block.index)
  with open(filename, 'w') as block_file:
    print new_block.__dict__()
    json.dump(block.__dict__(), block_file)

if __name__ == '__main__':
  last_block = node_blocks[-1]
  new_block = mine(last_block)
  save_block(new_block)

Готово! Но при таком типе создания блока кто угодно с самым быстрым CPU сможет создавать самые длинные цепи, которые другие узлы посчитают корректными. Нужен способ снизить скорость создания блока и подтверждение до перехода к следующему блоку.

Шаг 5 — Доказательство выполнения работы

Для снижения скорость я использую Доказательство выполнения работы, как и Bitcoin. Доказательство доли владения — другой способ, используемый в блокчейнах для достижения консенсуса, но в этом случае я воспользуюсь работой.

Способ сделать это — установить требования к структуре хэша блока. Как и в случае с bitcoin, необходимо убедиться, что хэш начинается с определенного количества нулей, перед тем, как перейти к следующему. А для этого нужно добавить в хедер дополнительную информацию — случайно перебираемое число (nonce).

def generate_header(index, prev_hash, data, timestamp, nonce):
  return str(index) + prev_hash + data + str(timestamp) + str(nonce)

Теперь функция майнинга настроена для создания хэша, но если хэш блока не содержит достаточного количества нулей, мы увеличиваем значение nonce, создаем новый хедер, вычисляем новый хэш и проверяем хватает ли нулей.

NUM_ZEROS = 4

def mine(last_block):
  index = int(last_block.index) + 1
  timestamp = date.datetime.now()
  data = "I block #%s" % (int(last_block.index) + 1) #random string for now, not transactions
  prev_hash = last_block.hash
  nonce = 0

  block_hash = calculate_hash(index, prev_hash, data, timestamp, nonce)
  while str(block_hash[0:NUM_ZEROS]) != '0' * NUM_ZEROS:
    nonce += 1
    block_hash = calculate_hash(index, prev_hash, data, timestamp, nonce)
  block_data = {}
  block_data['index'] = int(last_block.index) + 1
  block_data['timestamp'] = date.datetime.now()
  block_data['data'] = "I block #%s" % last_block.index
  block_data['prev_hash'] = last_block.hash
  block_data['hash'] = block_hash
  block_data['nonce'] = nonce
  return Block(block_data)

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

Заключение

На этом все! Пока что. Осталось еще много вопросов и фичей в блокчейнах, которые я не объяснил.

Например, как задействовать другие узлы? Как узлы передают данные, когда включаются в блок? Существуют ли иные способы хранения данных кроме огромных строк данных?
Ответы на эти вопросы можно будет найти в следующих частях этой серии постов, как только я сам найду на них ответы. Пожелания по содержанию можно писать мне в твиттер, в комментарии к посту или через форму обратной связи!

Спасибо моей сестре Саре за уточняющие вопросы о блокчейнах и помощь в редактировании поста!

THE END

Комментарии, вопросы, как всегда, приветствуются и тут, и на дне открытых дверей.

Автор: MaxRokatansky

Источник

www.pvsm.ru

Теперь каждый сможет создать свой приватный блокчейн

Раньше, когда в Интернете еще не существовало соцсетей, каждый школьник мог создать свой сайт на Narod.ru (был такой популярный сервис бесплатного хостинга, принадлежавший «Яндексу»). Теперь собственные сайты уже неактуальны, поскольку у каждого школьника есть свои страницы в соцсетях. Зато, учитывая бум блокчейна и криптовалют в России, теперь каждый школьник может создать свой приватный блокчейн (и, конечно, может выпустить свою собственную криптовалюту, обеспеченную, например, мясом молодых бычков, силой Торы или вообще ничем не обеспеченную, как биткоин). Как сообщает Linux.org.ru, компания Bitfury Group представила фреймворк для создания приватных блокчейнов.

---

«Разработчики компании Bitfury Group представили свой собственный фреймворк для разработки приватных блокчейнов Exonum, который позволяет создавать свои безопасные и высокопроизводительные blockchain-решения.

Ключевые особенности

Exonum использует особый алгоритм византийского консенсуса, который гарантирует безопасность данных (даже в случае выхода узлов из строя из-за неисправности или зловредной деятельности) и не требует больших вычислительных затрат для генерации блоков. Алгоритм позволяет блокчейну обрабатывать порядка 3 тыс. транзакций в секунду.

Платформа предполагает работу с умными контрактами или сервисами в терминологии Exonum. Сервисы Exonum, как и умные контракты Ethereum или Fabric, представляют собой бизнес-логику, добавляемую в блокчейн, однако имеют большую производительность (и безопасность, благодаря особой работе Rust с памятью) по сравнению с конкурентами.

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

Встроенный в Exonum легкий клиент позволяет формировать и подписывать транзакции, а также проверять доказательства включения (или не включения) данных в блокчейн без необходимости скачивать его.

Exonum является полностью открытым решением, поэтому пользователям доступна не только вся библиотека кода, но и клиентское программное обеспечение для управления блокчейном.

Exonum написан на языке программирования Rust, который уделяет особое внимание вопросам безопасности кода, не жертвуя при этом его производительностью. С исходным кодом можно ознакомиться на гитхабе…»

Также по теме:

— Кто заразил Россию и Путина блокчейном
— В правительстве обсудили места размещения центров по майнингу криптовалют
— В России резко вырос спрос на специалистов по блокчейну и криптовалютам
— Почему Bitcoin — это пирамида, пузырь и секта
— Что такое майнинг и куда делиcь все видеокарты

news.softodrom.ru