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

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

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

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

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

Нужно учитывать, что есть большая разница между базовым блокчейном, который я описываю и “профессиональным” блокчейном. Эта цепь не создаст криптовалюту. Блокчейны не требуют производства монет, которые можно продавать и менять на физические деньги.
Блокчейны используются для хранения и подтверждения информации. Монеты побуждают узлы участвовать в валидации, но их наличие не обязательно.

Я пишу пост по нескольким причинам: 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
 

#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()

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

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 

Шаг 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()

Шаг 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()

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)

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

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

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

def generate_header(index, prev_hash, data, timestamp, nonce):
  return str(index) + prev_hash + data + str(timestamp) + str(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)

Заключение

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

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

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

THE END

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

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

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

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

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

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

Блокчейн с нуля

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

Написание с нуля кода блокчейн-ноды напоминает создание собственной базы данных с механизмом надежной сетевой репликации. Если вы поищете, сколько таких БД было создано за последние десятилетия, то найдете максимум сотню проектов. Огромной долей рынка владеют всего несколько компаний (Oracle, MS SQL Server, MySQL, PostgreSQL), а разработчики ядра таких систем ценятся крайне высоко.

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

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

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

Готовые блокчейн-движки

Я намеренно назвал раздел «движки», так как этот термин в области ПО часто используется для обозначения комплексов разнопланового ПО, предназначенного для решения конкретной задачи. Например, «поисковый движок» или «графический движок» — это не только код, но и вспомогательное ПО, дополнительные утилиты, описания алгоритмов и многое другое. Учитывая существование нескольких основных ядер блокчейнов, на базе которых построены уже существующие сети, будет удобно называть их движками (например, «построен на движке Ethereum»).

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

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

Ethereum

Этот комплекс ПО построен на базе ядра публичного блокчейна Ethereum. Публичный Ethereum использует консенсус типа Proof-of-Work, а его многочисленные тестовые сети — различные виды Proof-of-Authority и Proof-of-Stake консенсусов. ПО отвечает самым строгим критериям безопасности, проверено в десятках реально работающих сетей и, на мой взгляд, является наиболее развитым для создания блокчейнов с любыми видами консенсусов и полноценными, многофункциональными смарт-контрактами.

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

Код блокчейн-ноды и консенсус

Существуют две основных имплементации кода ноды Ethereum: на языке Rust (код, названия: poa-parity (старое) или openethereum(новое)) и на Go (код, название: geth).

На момент написания при построении PoA-сети на geth (Go) вам будет доступен только консенсус Clique — это простейший и небезопасный протокол без финализации, который можно использовать только в тестовых целях.

Консенсус, реализованный в poa-parity (Rust), состоит из двух алгоритмов: schedule валидаторов Aura и finality gadget GRANDPA. Именно этот вариант, проверенный и безопасный, работает в POA-сетях на базе Ethereum. POA Network работают также над имплементацией перспективного BFT-консенсуса HoneyBadger.

Отдельного упоминания заслуживает новая блокчейн-нода Nethermind, написанная на C# для платформы .NET Core. Она полностью поддерживает Ethereum, большое число операционных систем и является отличным выбором для компаний, которые используют .NET Core.

Смарт-контракты и управление сетью

POA Ethereum использует виртуальную машину EVM и смарт-контракты, которые лучше всего писать на языке Solidity. EVM давно стала стандартом для виртуальных машин с большим количеством готового кода и паттернов разработки. Код контрактов под EVM отвечает за большие суммы криптовалюты, и любая найденная уязвимость вызывает мощную реакцию сообщества и СМИ, поэтому безопасность контрактов EVM на текущий момент крайне высока.

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

Дополнительное ПО

С Ethereum можно использовать JavaScript-библиотеку web3.js, вне зависимости от консенсуса, валидаторов и ее расположения.

Для POA Ethereum существует репозитарий для автоматизации операций по развертыванию готовой сети — deployment-playbooks.

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

Готовая POA-сеть Ethereum присутствует в AWS, но я все же рекомендую контролировать запуск своими руками. Вы должны понимать, какие сервисы вы запускаете и как они работают.

EOS и его форки

Вторым по гарантиям работоспособности и безопасности будет EOS. “OS” в его названии появилась не случайно.

EOS можно запустить в качестве отдельной сети, в PoS- или PoA-варианте. Как и Ethereum, это ПО уже проверено в бою, обладает высокой безопасностью и функционалом, который позволяет запустить собственный блокчейн со смарт-контрактами для автоматизации любых сделок

Если Ethereum имеет простую систему адресов, то в EOS сразу же используется иерархическая система аккаунтов и права на различные действия. Все это делает EOS похожей по дизайну на операционную систему — «программу для запуска других программ».

В качестве межкорпоративной платформы EOS позволяет из коробки получить удобную систему управления аккаунтами и быстрый консенсус, а также легко интегрировать практически любой функционал при помощи плагинов на C++ и смарт-контрактов на C++/WebAssembly (например, можно добавить другую криптографию).

Дизайн консенсуса в EOS и быстрые блоки позволяют достичь очень быстрого времени ответа пользователю, что крайне важно для построения децентрализованных приложений со сложным функционалом (например, проекты Cyberway, Golos.io или соцсеть Commun). Cyberway недавно произвел сложнейшую миграцию всей бизнес-логики из предыдущего блокчейна прозрачно для пользователей, что лишний раз доказывает гибкость и универсальность EOS.

Код блокчейн-ноды и консенсус

Код EOS написан на C++ и развивался на основе опыта, полученного разработчиками при работе над движками Graphene, Bitshares, Steemit. Используется собственный вариант DPoS-консенсуса.

Сейчас почти все проекты, использующие DPoS, строят свои алгоритмы очень похожим на EOS образом: это аккаунты, «голосующие» балансом токена за топ валидаторов. Валидаторы подписывают блоки по одиночке, но каждый в назначенный квант времени, согласно расписанию. Затем они коллективно фиксируют так называемый Last Irreversible Block (LIB), на котором собирается 2/3 + 1 подписей от валидаторов.

Многие форки EOS пытаются улучшить это консенсус. Например, наш вариант Haya использует для фиксации LIB другой finality gadget — RANDPA, чтобы достичь времени финальности в 2-3 секунды.

Переход к корпоративному POA-консенсусу не вызывает затруднений, так как список валидаторов управляется системными смарт-контрактами.

Смарт-контракты и управление сетью

Смарт-контракты в EOS используют модифицированную виртуальную машину WebAssembly, обычно пишутся на языке C++ и могут создаваться и использоваться любым аккаунтом. Писать смарт-контракты не сложно, во многом они перекликаются с Solidity.

В EOS, как и в POA Ethereum, управление сетью, основной токен (или токены) и типы транзакций можно реализовать в системных смарт-контрактаx (вот, например, системный токен). Интересной особенностью контрактов EOS является использование абстракции table для хранения данных контракта. В Ethereum в основном используется mapping (ассоциативный массив).

Еще одна особенность смарт-контрактов в EOS — upgradeability. Владелец контракта может заменить его, обновив логику или исправив ошибку. Это сильно отличается от Ethereum, где неизменность контрактов — важное условие, гарантирующее, что логика контракта никогда уже не будет изменена, если не произойдет хардфорк.

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

В EOS возможно организовать «спонсорские» транзакции, оплачиваемые владельцами контракта, а не самими пользователями. Это мощнейшая возможность для привлечения новых пользователей. Вы ведь помните, что «бесплатных» транзакций без потери безопасности в блокчейнах не бывает?

Дополнительное ПО

BOSCore, Telos, Haya и еще десяток форков EOS доказывают, что это ПО интересно большому количеству проектов. Для EOS существует достаточно инструментов, и вам не придется с нуля реализовывать сопутствующее ПО.

Eosjs — аналог web3.js, позволяет работать с контрактами любой сети на базе EOS из браузера и любых приложений.

EOSTracker — обозреватель блоков с открытым кодом и децентрализованными приложениями для голосований за валидаторов.

У EOS нет одного большого и мощного интегратора, как POA Network для Ethereum, поэтому каждый проект строит собственное решение. Тем не менее, основной код ноды стабилен и работает под серьезными нагрузками без сбоев.

Parity Substrate

Substrate создается командой компании Parity. Разработано огромное количество ПО: кошельки, блокчейн-ноды, системы смарт-контрактов, компиляторы, виртуальные машины.

Parity Substrate позволяет разработчику достаточно легко создать свой вариант блокчейна из готовых модулей со сложным консенсусом и логикой обработки транзакций. Substrate — это конструктор блокчейнов, на котором, к примеру, можно сделать блокчейн-ноду Ethereum или биткоина.

Substrate — это часть крупного проекта Polkadot — системы, состоящей из основной цепочки и множества цепочек-шардов с индивидуальной логикой.

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

Код блокчейн-ноды и консенсус

Код Substrate написан на языке Rust. На мой взгляд, в структуре Substrate чувствуется большой опыт команды по созданию блокчейнов, так как все компоненты отлично структурированы, разделены на отдельные модули, а в коде присутствуют подробные комментарии. Доказательством гибкости этого движка является существование клиента для сети биткоина и ZCash на основе кода Substrate.

Что касается консенсуса, то можно выбрать из нескольких готовых вариантов или написать свой собственный. В большинстве случаев это PoA или DPoS, что в случае Substrate означает использование алгоритма Aura и GRANDPA.

Производительность блокчейнов на базе Substrate высока. Основная цепочка Polkadot была протестирована нами в конфигурации с 99 валидаторами, распределенными по трем континентам, и показала отличные результаты.

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

Смарт-контракты и управление сетью

Substrate, в отличие от Ethereum и EOS, обрабатывает транзакции при помощи кода, который размещается валидаторами, а не пользователями. Это код называется “runtime” и исполняется виртуальной машиной WebAssembly.

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

Особого упоминания заслуживают модули пользовательских смарт контрактов: WASM и EVM. Они дают возможность пользователям размещать свои смарт-контракты, поэтому запуск универсального блокчейна на Substrate тоже возможен.

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

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

Дополнительное ПО

Для Substrate есть ряд полезных решений: polkascan — обозреватель блоков и комплекс программ на JS для работы с Polkadot и сетями на базе Substrate. Возможно, вам пригодятся ansible-сценарии для развертывания готового кластера на базе Substrate, который мы использовали для тестирования Polkadot.

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

Cosmos SDK

Cosmos — это проект на базе одной основной цепочки и множества дочерних блокчейнов, называемых «zones». Дочерние цепочки строятся на основе Cosmos SDK — набора ПО для построения блокчейнов.

Cosmos — это продолжение проекта Tendermint, из которого ключевыми технологиями является надежный консенсус и концепция Application, сходная с runtime в Substrate.

Как и в случае Polkadot+Substrate, блокчейн, созданный с помощью Cosmos SDK, может жить отдельно или подключиться к экосистеме Cosmos как дочерняя цепочка.

Весь комплекс ПО Cosmos написан на Go и отлично структурирован и активно используется. На его основе уже работают несколько проектов, среди которых Binance Chain.

Если ваши разработчики пишут на Go — Cosmos SDK может вам подойти. Он работает и активно развивается в реальных проектах, чьи блокчейны и транзакции можно увидеть в публичных сетях.

Код блокчейн-ноды и консенсус

Главная концепция Cosmos называется Application. Любой блокчейн представляет собой машину состояний, и в Cosmos она вынесена в отдельную часть кода.

По сути, разработчик просто задает правила, по которым одни данные превращаются в другие при внешнем воздействии, программируя так называемую функцию state transition. Это сложно звучит, но по факту обработка транзакции — это state transition, которая меняет несколько балансов. Именно этим занимается Application — принимает некоторое воздействие извне (транзакцию) и меняет свое состояние (state). Получившиеся изменения фиксируются в блокчейне. При этом разработчик не должен решать проблемы консенсуса и сети — сеть сама договорится между собой и придет к консенсусу относительно результатов.

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

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

Смарт-контракты и управление сетью

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

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

Для ограничения транзакций в Cosmos, как в Ethereum, используется газ. Исполняя транзакцию, валидаторы вычисляют ее стоимость в условных единицах «gas». Отправляя транзакцию, пользователь указывает цену, которую он готов платить за единицу газа и лимит, который он готов потратить. Это является основанием для вычисления цены за транзакцию.

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

Дополнительное ПО

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

На JavaScript я нашел несколько полезных библиотек: js-cosmos, cosmosjs и универсальную js-abci, реализующую интерфейс ABCI. Их удобно использовать, если взаимодействие с вашим блокчейном планируется из браузера. ABCI позволяет создавать Application на разных языках, среди которых Java, C++, Python. Проект lotion, например, позволяет создать блокчейн полностью на Javascript.

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

Подписывайтесь на канал Forklog в YouTube!

Нашли ошибку в тексте? Выделите ее и нажмите CTRL+ENTER

Создаем Blockchain с нуля на Python

Самый быстрый способ узнать, как работает блокчейн — это создать его.

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

Однако, понимание блокчейн — не самое простое дело, по крайней мере, так было в моем случае. Я прошел через тонны видеороликов, изучал руководства и постоянно разочаровывался из-за слишком маленького количества примеров.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

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

Перед тем, как начать…

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

Если вы не знаете, что такое хеш, то вот вам статьи:

На кого нацелена данная статья?

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

Что нам нужно? Убедитесь, что у вас установлен Python 3.6+ (а также pip). Вам также нужно будет установить Flask и замечательную библиотеку Requests:

pip install Flask==0.12.2 requests==2.18.4

И да, вам также нужен будет HTTP клиент, такой как Postman или cURL. В целом, что-нибудь подойдет.

Исходный код статьи

Вот здесь вы можете ознакомиться с исходным: https://github.com/dvf/blockchain

Шаг 1: Создание блокчейна

Открывайте свой любимый редактор текста, или IDE, лично я предпочитаю PyCharm. Создайте новый файл под названием blockchain.py. Мы используем только один файл, но если вы запутаетесь, вы всегда можете пройтись по исходному коду.

Скелет блокчейна

Мы создадим класс блокчейна, чей конструктор создает начальный пустой лист (для хранения нашего блокчейна), и еще один — для хранения транзакций. Вот чертёж нашего класса:

class Blockchain(object): def __init__(self): self.chain = [] self.current_transactions = [] def new_block(self): # Создает новый блок и вносит его в цепь pass def new_transaction(self): # Вносит новую транзакцию в список транзакций pass @staticmethod def hash(block): # Хеширует блок pass @property def last_block(self): # Возвращает последний блок в цепочке 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): «»» Направляет новую транзакцию в следующий блок :param sender: <str> Адрес отправителя :param recipient: <str> Адрес получателя :param amount: <int> Сумма :return: <int> Индекс блока, который будет хранить эту транзакцию «»» self.current_transactions.append({ ‘sender’: sender, ‘recipient’: recipient, ‘amount’: amount, }) return self.last_block[‘index’] + 1

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

Создание новых блоков

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

В дополнению к созданию блока генезиса в конструкторе, мы также выкатим методы для new_block(), new_transaction() и hash():

import hashlib import json from time import time class Blockchain(object): def __init__(self): self.current_transactions = [] self.chain = [] # Создание блока генезиса self.new_block(previous_hash=1, proof=100) def new_block(self, proof, previous_hash=None): «»» Создание нового блока в блокчейне :param proof: <int> Доказательства проведенной работы :param previous_hash: (Опционально) хеш предыдущего блока :return: <dict> Новый блок «»» block = { ‘index’: len(self.chain) + 1, ‘timestamp’: time(), ‘transactions’: self.current_transactions, ‘proof’: proof, ‘previous_hash’: previous_hash or self.hash(self.chain[-1]), } # Перезагрузка текущего списка транзакций self.current_transactions = [] self.chain.append(block) return block def new_transaction(self, sender, recipient, amount): «»» Направляет новую транзакцию в следующий блок :param sender: <str> Адрес отправителя :param recipient: <str> Адрес получателя :param amount: <int> Сумма :return: <int> Индекс блока, который будет хранить эту транзакцию «»» 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): «»» Создает хэш SHA-256 блока :param block: <dict> Блок :return: <str> «»» # Мы должны убедиться в том, что словарь упорядочен, иначе у нас будут непоследовательные хеши block_string = json.dumps(block, sort_keys=True).encode() return hashlib.sha256(block_string).hexdigest()

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

Понимание подтверждения работы

Алгоритм пруфа работы (Proof of Work, PoW) — это то, как новые блоки созданы или майнятся в блокчейне. Цель PoW — это найти число, которое решает проблему. Число должно быть таким, чтобы его тяжело было найти, но легко подтвердить (говоря о вычислениях) кем угодно в интернете. Это главная задача алгоритма.

Рассмотрим простой пример, чтобы получить лучшее представление.

Скажем, что хеш того или иного числа х, умноженного на другое число должен заканчиваться нулем. Таким образом, hash(x * y) = ac23dc…0. Для этого упрощенного примера, представим что x = 5. Как это работает в Python:

from hashlib import sha256 x = 5 y = 0 # Мы еще не знаем, чему равен y… while sha256(f'{x*y}’.encode()).hexdigest()[-1] != «0»: y += 1 print(f’The solution is y = {y}’)

Решение здесь следующее: y = 21, так как созданный хеш заканчивается нулем:

hash(5 * 21) = 1253e9373e…5e3600155e860

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

Реализация базового PoW

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

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

import hashlib import json from time import time from uuid import uuid4 class Blockchain(object): … def proof_of_work(self, last_proof): «»» Простая проверка алгоритма: — Поиска числа p`, так как hash(pp`) содержит 4 заглавных нуля, где p — предыдущий — p является предыдущим доказательством, а p` — новым :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): «»» Подтверждение доказательства: Содержит ли hash(last_proof, proof) 4 заглавных нуля? :param last_proof: <int> Предыдущее доказательство :param proof: <int> Текущее доказательство :return: <bool> True, если правильно, False, если нет. «»» guess = f'{last_proof}{proof}’.encode() guess_hash = hashlib.sha256(guess).hexdigest() return guess_hash[:4] == «0000»

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

Наш класс практически готов, так что мы можем начать взаимодействовать с ним через HTTP запросы.

Шаг 2: Блокчейн как API

Здесь мы задействуем фреймворк под названием 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): … # Создаем экземпляр узла app = Flask(__name__) # Генерируем уникальный на глобальном уровне адрес для этого узла node_identifier = str(uuid4()).replace(‘-‘, ») # Создаем экземпляр блокчейна 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() # Убедитесь в том, что необходимые поля находятся среди POST-данных required = [‘sender’, ‘recipient’, ‘amount’] if not all(k in values for k in required): return ‘Missing values’, 400 # Создание новой транзакции index = blockchain.new_transaction(values[‘sender’], values[‘recipient’], values[‘amount’]) response = {‘message’: f’Transaction will be added to Block {index}’} return jsonify(response), 201

Конечная точка майнинга

Конечная точка майнинга — это часть, где происходит магия, и это просто! Для этого нужно сделать три вещи:

• Подсчитать PoW;
• Наградить майнера (нас), добавив транзакцию, дающую нам 1 коин;
• Слепить следующий блок, внеся его в цепь.

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(): # Мы запускаем алгоритм подтверждения работы, чтобы получить следующее подтверждение… last_block = blockchain.last_block last_proof = last_block[‘proof’] proof = blockchain.proof_of_work(last_proof) # Мы должны получить вознаграждение за найденное подтверждение # Отправитель “0” означает, что узел заработал крипто-монету blockchain.new_transaction( sender=»0″, recipient=node_identifier, amount=1, ) # Создаем новый блок, путем внесения его в цепь 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

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

Шаг 3: Взаимодействие с нашим блокчейном

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

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

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

Давайте попробуем майнить блок, создав GET-запрос к узлу http://localhost:5000/mine:

curl http://localhost:5000/mine

Теперь, давайте создадим новую транзакцию, отправив POST-запрос к узлу http://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»

Я перезапустил свой сервер и замайнил два блока, итого их количество 3. Давайте проверим всю цепочку, выполнив запрос к узлу http://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 }

Шаг 4: Консенсус

Пока всё идет очень здорово. У нас есть базовый blockchain, который принимает транзакции и дает возможность майнить новые блоки. Но вся суть блокчейна в том, что они должны быть децентрализованными. А если они децентрализованы, каким образом мы можем гарантировать, все они отображают одну цепочку?

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

Регистрация новых узлов

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

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

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

… from urllib.parse import urlparse … class Blockchain(object): def __init__(self): … self.nodes = set() … def register_node(self, address): «»» Вносим новый узел в список узлов :param address: <str> адрес узла , другими словами: ‘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): «»» Проверяем, является ли внесенный в блок хеш корректным :param chain: <list> blockchain :return: <bool> True если она действительна, False, если нет «»» 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») # Проверьте правильность хеша блока if block[‘previous_hash’] != self.hash(last_block): return False # Проверяем, является ли подтверждение работы корректным if not self.valid_proof(last_block[‘proof’], block[‘proof’]): return False last_block = block current_index += 1 return True def resolve_conflicts(self): «»» Это наш алгоритм Консенсуса, он разрешает конфликты, заменяя нашу цепь на самую длинную в цепи :return: <bool> True, если бы наша цепь была заменена, False, если нет. «»» neighbours = self.nodes new_chain = None # Ищем только цепи, длиннее нашей max_length = len(self.chain) # Захватываем и проверяем все цепи из всех узлов сети for node in neighbours: response = requests.get(f’http://{node}/chain’) if response.status_code == 200: length = response.json()[‘length’] chain = response.json()[‘chain’] # Проверяем, является ли длина самой длинной, а цепь — валидной if length > max_length and self.valid_chain(chain): max_length = length new_chain = chain # Заменяем нашу цепь, если найдем другую валидную и более длинную 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

Теперь вы можете сесть за другой компьютер (если хотите), и развернуть разные узлы в своей сети. Также вы можете развернуть процессы при помощи различных портов на одном и том же компьютере. Я развернул еще один узел на своем компьютере, но на другом порте и зарегистрировал его при помощи моего текущего узла. Таким образом, я получил два узла: http://localhost:5000 и http://localhost:5001.

После этого я получил два новых блока в узле 2, чтобы убедиться в том, что цепь была длиннее. После этого, я вызвал GET /nodes/resolve в узле 1, где цепь была заменена нашим алгоритмом консенсуса:

И это была обертка… Найдите друзей и вместе попробуйте протестировать ваш блокчейн!

Подведем итоги

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

Являюсь администратором нескольких порталов по обучению языков программирования Python, Golang и Kotlin. В составе небольшой команды единомышленников, мы занимаемся популяризацией языков программирования на русскоязычную аудиторию. Большая часть статей была адаптирована нами на русский язык и распространяется бесплатно.

E-mail: [email protected]

Образование
Universitatea Tehnică a Moldovei (utm.md)

• 2014 — 2018 Технический Университет Молдовы, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
• 2018 — 2020 Технический Университет Молдовы, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»

Пишем свой блокчейн

Самый быстрый способ изучить работу Блокчейнов – это создать свой блокчейн. Стоит лишь только попробовать!

Скорее всего вы здесь, также, как и я, потому что были недовольны резким подъемом Криптовалюты. И вы хотите узнать, как же работают Блокчейны – фундаментальная технология, которая стоит за всеми криптовалютами.

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

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

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

Если вы не уверены в том, что такое хэш, то вот объяснение.

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

Убедитесь в том, что у вас установлен Python 3.6+ (также как и pip). Вам также необходимо установить библиотеку Flask и прекрасную библиотеку Request:

pip install Flask==0.12.2 requests==2.18.4

О, вам также понадобится HTTP-клиент, наподобие Postman или cURL. Но все будет дальше.

Исходный код будет доступен здесь.

…

Запустите ваш любимый редактор кода или IDE, лично мне нравится PyCharm. Создайте новый файл с названием blockchain.py. Мы будем использовать только один файл, но если вы вдруг запутаетесь, то всегда можете обратиться к исходному коду.

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

 	
class Blockchain(object):	
    def __init__(self):
        self.chain = []
        self.current_transactions = []
 	
    def new_block(self):
        # Создает новый Блок и добавляет его к цепочке
        pass

 	
    def new_transaction(self):
        # Добавляет новую транзакцию к списку транзакций
        pass
 	
    @staticmethod	
    def hash(block):
        # Хэшируем блоки
        pass
 	

    @property
    def last_block(self):
        # Возвращает последний блок в цепочке
        pass

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

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

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

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):
        """
      Создает новую транзакцию для того чтобы перейти к следующему искомому Блоку

        :параметр sender: <str> Адрес отправителя
        :параметр recipient: <str> Адрес получателя	
        :параметр amount: <int> Количество
        :return: <int> Индекс Блока, в котором будет хранится данная транзакция
        """

        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })
 	
        return self.last_block['index'] + 1

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

После того, как мы создали экземпляр нашего Блокчейна, нам необходимо заполнить его исходным блоком – блок у которого нет предшественников. Также нам необходимо добавить «proof» в наш исходный блок, который является результатом анализа (или алгоритма «доказательство выполнения работы»). По поводу анализа мы поговорим позднее.

Кроме этого, для создания исходного блока в нашем конструкторе, нам также необходимо добавить следующие методы: 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):
        """
        Создаем новый блок в нашем Блокчейне

 	 	
        :параметр proof: <int> proof полученный после использования алгоритма «Доказательство выполнения работы»
        :параметр previous_hash: (Опциональный) <str> Хэш предыдущего Блока
        :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]),
        }

 	
        # Сбрасываем текущий список транзакций
        self.current_transactions = []

 	
        self.chain.append(block)
        return block
 	
    def new_transaction(self, sender, recipient, amount):
        """
        Создает новую транзакцию для перехода к следующему замайненному Блоку

        :param sender: <str> Address of the Sender
        :param recipient: <str> Address of the Recipient
        :param amount: <int> Amount
        :return: <int> Индекс блока который будет хранить в себе эту транзакцию
        """

        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):
        """
        Создает a SHA-256 хэш блока

        :параметр block: <dict> Блок
        :return: <str>
        """

        # Мы должны быть уверены что наш Словарь упорядочен, или мы можем непоследовательные хэши
        block_string = json.dumps(block, sort_keys=True).encode()	
        return hashlib.sha256(block_string).hexdigest()

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

Алгоритм «Доказательство выполнения работы» (PoW) – это то, как новые блоки создаются или майнятся в блокчейне. Целью алгоритма PoW является нахождение такого числа (метки), которое будет решать проблему. Число должно быть таким, чтобы его было сложно найти и легко проверить. Говоря в вычислительном отношении не важно кем в сети это может быть сделано. В этом и заключается основная идея данного алгоритма.

Итак, давайте взглянем на простой пример, которой поможет нам во всем разобраться.

Предположим, что хэш некоторого целочисленного числа x, умноженного на другое целочисленное число y, должен заканчиваться на 0. Следовательно, hash(x * y) = ac23dc…0. И для нашего упрощенного примера исправим x на 5. Реализуем это в Python:

from hashlib import sha256


x = 5
y = 0  # Пока мы не знаем каким должен быть y


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):
        """
        Простой алгоритм Proof of Work:
         - Ищем число p' такое, чтобы hash(pp') содержал в себе 4 лидирующих нуля, где p это предыдущий p'
         - p это предыдущий proof, а p' это новый proof

        :параметр 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):
        """
        Проверяем Proof: Содержит ли hash(last_proof, proof) 4 лидирующих нуля?

        :параметр last_proof: <int> предыдущий Proof
        :параметр proof: <int> Тукущий Proof
        :return: <bool> True если все верно, иначе False.
        """
	
        guess = f'{last_proof}{proof}'.encode()	
        guess_hash = hashlib.sha256(guess).hexdigest() 	
        return guess_hash[:4] == "0000"

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

Наш класс практически готов, и мы готовы начать взаимодействовать с ним посредствам HTTP-запросов.

…

Мы будем использовать фреймворк Flask. Данный микро-фреймворк упрощает размещение конечных точек (endpoints) в 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):	
    ...

 	
# Создаем экземпляр нашего узла	
app = Flask(__name__)
 	
# Генерируем уникальный глобальный адрес для этого узла	
node_identifier = str(uuid4()).replace('-', '')

# Создаем экземпляр 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: Создаем endpoint для метода /mine, который является GET-запросом;
• Строки 28-30: Создаем endpoint для метода /transactions/new, который является POST-запросом, поскольку мы будем отправлять сюда данные;
• Строки 32-38: Создаем endpoint для метода /chain, который будет возвращать весь Блокчейн;
• Строки 40-41: Запускаем наш сервер на порт 5000.

Endpoint для транзакций

Вот так будет выглядеть запрос транзакции. То есть, именно эту информацию пользователь отправляет на сервер:

{
 "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()


    # Проверяем, что обязательные поля переданы в POST-запрос
    required = ['sender', 'recipient', 'amount']
    if not all(k in values for k in required):
        return 'Missing values', 400

 	
    # Создаем новую транзакцию	
    index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])
 	
    response = {'message': f'Transaction will be added to Block {index}'}
    return jsonify(response), 201

Endpoint для майнинга

Наш endpoint майнинга – это то, где происходит магия, и в ней нет ничего сложного. Здесь совершаются три следующих вещи:

1. Расчет алгоритма PoW;
2. Майнер(ы) получают награду в виде транзакции, которая гарантируем им 1 биткойн;
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():
    # Мы запускаем алгоритм PoW для того чтобы найти следующий proof...
    last_block = blockchain.last_block	
    last_proof = last_block['proof']
    proof = blockchain.proof_of_work(last_proof)

 	
    # Мы должны получить награду за найденный proof.
    # Если sender = "0", то это означает что данный узел заработал биткойн.	
    blockchain.new_transaction(
        sender="0",	
        recipient=node_identifier,
        amount=1,
    )


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

Вы можете использовать простой, но уже устаревший cURL или Postman, для взаимодействия с нашим API через сеть.

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

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

Давайте попробуем смайнить блок. Для этого воспользуемся GET-запросом на http://localhost:5000/mine:

Создадим новую транзакцию с помощью POST-запроса на http://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"

Я перезагрузил свой сервер, и смайнил два блока, чтобы в итоге получилось три. Давайте проверим всю цепочку, с помощью запроса на http://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
}

Пока, все что мы делали, это круто. Мы получили базовый Блокчейн, который может принимать транзакции, тем самым позволяя нам майнить новые Блоки. Однако вся суть Блокчейнов заключается в том, что они должны быть децентрализованы. Но если блокчейны децентрализованы, то как мы можем гарантировать, что все они отражают одну и ту же цепочку? Данная проблема называется проблемой Консенсуса (конфликтов). Мы реализуем алгоритм Консенсуса, если мы конечно хотим, чтобы в нашей сети было больше одного узла.

Перед тем как мы сможем реализовать алгоритм Консенсуса, нам необходимо придумать способ, как наши узлы будут знать о своих «соседях» в сети. Каждый узел в нашей сети будет хранить в себе запись о других узлах в сети. Итак, нам необходимо еще некоторое количество endpoint-ов:

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):
        """
        Добавляем новый узел в список узлов

        :параметр address: <str> Адрес узла, например: '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):
        """
        Определяем, что данный блокчейн прошел проверку
 
        :параметр chain: <list> Блокчейн
        :return: <bool> True если прошел проверку, иначе False
        """

        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")
            # Проверяем, что хэш этого блока корректен
            if block['previous_hash'] != self.hash(last_block):
                return False

            # Проверяем, что алгоритм PoW корректен
            if not self.valid_proof(last_block['proof'], block['proof']):
                return False

 	
            last_block = block
 	
            current_index += 1

        return True

    def resolve_conflicts(self):
        """
        Это наш алгоритм Консенсуса, он разрешает конфликт путём
        замены нашей цепочки на самую длинную в нашей сети.

        :return: <bool> True если наша цепочка была заменена, False если это не так
        """

 	
        neighbours = self.nodes
        new_chain = None

        # Мы ищем цепочки длиннее наших
        max_length = len(self.chain)

        # Берем все цепочки со всех узлов нашей сети и проверяем их
        for node in neighbours:
            response = requests.get(f'http://{node}/chain')
 	
            if response.status_code == 200:
                length = response.json()['length']
                chain = response.json()['chain']

                # Проверяем, что цепочка имеет 
                # максимальную длину и она корректна
                if length > max_length and self.valid_chain(chain):
                    max_length = length
                    new_chain = chain

        # Заменяем нашу цепочку, если нашли другую, 
        # которая имеет большую длину и является корректной
        if new_chain:
            self.chain = new_chain
            return True
 	
        return False

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

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

Давайте зарегистрируем два endpoint-а в нашем 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

На этом этапе вы можете задействовать любое количество машин, по вашему усмотрению, и реализовать различные узлы в вашей сети. Или же реализовать все то же самое на одной машине, используя разные порты. Я это реализовал вторым способом, используя разные порты. То есть, я зарегистрировал другой узел, уже с имеющимся узлом. Итак, у меня есть два узла: http://localhost:5000 и http://localhost:5001.

После чего я замайнил новые блоки на узел 2, для того чтобы цепочка стала длиннее. Потом, я вызвал GET /nodes/resolve на узел 1, где цепочка была заменена по алгоритму Консенсуса:

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

…

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

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

Простейший блокчейн своими руками
10 полезных ресурсов по технологии blockchain

Ссылка на оригинальную статью
Перевод: Александр Давыдов

Как создать blockchain платформу — систему?

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

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

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

Непосредственно созданию сайта под ICO-проект предшествует ряд важных задач:

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

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

Кстати, создание сайта также делится на несколько частей: программная, маркетинговая части и оформление сайта.

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

Как создать blockchain-проект?

Обратившись в нашу компанию, вы плучите в свое пользование команду профессоналов, которые ссоздадут вам масштабный и прибыльный ICO-проект по приемлемым ценам. Также наши специалисты будут курировать ваш проект от начала и до конца.

Создание блокчейн проекта платформы и системы

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

Создание блокчейн проекта

Blockchain-проект обладает рядом преимуществ и решает обширный спектр задач:

• Отправка различной валюты.
• Документооборот.
• Надежное хранение файлов.
• Децентрализованная торговля.

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

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

Наша команда опытных веб-разработчиков выполняет весь необходимый комплекс работ связанных с блокчейн-программированием:

• Разработку смарт-контракта Etherium и токенов.
• Независимый аудит умного контракта.
• Разрабатываем бизнес-план.
• Делаем глубокую проработку документации WhitePaper.
• Разрабатываем Landing page.
• Создание электронных кошельков.
• Организовываем Pre-ICO.
• Оказываем помощь в проведении ICO.
• Аудит ICO компании.
• Создаем виртуальные валюты на платформе Etherium.
• Совершаем новостную рассылку на специализированных сайтах и в социальных сетях.

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

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

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

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

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

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

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

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

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

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

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

Наиболее популярные платформы:

• Ethereum — одна из самых известных и функциональных блокчейн-платформ с развитой инфраструктурой для создания смарт-контрактов и разработки децентрализованных приложений. Основной язык программирования — Solidity, внутренняя криптовалюта — Ether (ETH).
• Hyperledger Fabric — перспективная платформа для разработки решений на базе блокчейна, ориентированных на корпоративный сегмент. Появилась при поддержке IBM и в данный момент не имеет своей криптовалюты. Актуальные языки программирования: Go, Java, JavaScript.
• Cardano — действующая блокчейн-платформа нового типа; ключевое отличие от других платформ заключается в том, что в Cardano существует разделение вычислительных слоев: первый слой предназначен для работы с внутренней криптовалютой ADA, второй — для создания и обработки смарт-контрактов, написанных на языке программирования Haskell.

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

Для реализации блокчейна на платформе Etherium, необходимо создать новый смарт-контракт на высокоуровневом языке Solidity, чей синтаксис похож на JavaScript, и загрузить его в сеть Etherium, где уже есть свой API и все необходимое для быстрого запуска готового продукта.

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

Плюсы:

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

Минусы:

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

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

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

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

Плюсы:

• создание блокчейна на базе open-source платформы освобождает от уплаты комиссии за каждую проведенную транзакцию. Все ваши расходы будут ограничиваться статичной ежемесячной суммой на поддержание ваших серверов и инфраструктуры и не будут увеличиваться с ростом транзакций.   

Минусы:

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

Разработка приложения с созданием собственной блокчейн-сети занимает минимум 1 месяц.

Разработка блокчейна с нуля подразумевает создание приложения на одном из высокоуровневых языков программирования (С, С+, С#, Java) с использованием огромного количества криптографических алгоритмов. Криптографические алгоритмы — фундаментальная основа блокчейна. Для подписи и верификации любых данных внутри информационного блока проводятся различные процедуры, состоящие из сложных арифметических операций, что, по сути, переносит разработку блокчейна скорее в область математики, чем программирования.

Плюсы:

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

Минусы:

• долгий срок разработки;
• так же, как и при создании собственной сети на базе open-source платформы, разработка блокчейна с нуля требует создания полноценной инфраструктуры (включая настройку серверов, администрирование оборудования и подключением майнеров), которую вам придется мониторить и поддерживать самостоятельно.

Разработка собственного блокчейна занимает минимум 6 месяцев.

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

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

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

Архитектура нашего приложения выглядит так:

Эта архитектура универсальна и подходит для реализации в любой сфере и индустрии.

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

Закажите приложение с использованием блокчейна прямо сейчас!

# 8 шагов по созданию решения для цепочки блоков

сентябрь 9, 2017 Читать 5 мин

Мнения, высказанные предпринимателями. участников являются их собственными.

Вы читаете Entrepreneur India, международную франшизу Entrepreneur Media.

Когда в 2008 году Сатоши Накамото объявил о технологии блокчейн в документе под названием «Биткойн: одноранговая система электронных денег», это было инновационное сочетание криптографии с открытым ключом (изобретено в 1970-х годах) и криптографических хэш-функций (рожденных в 1970-е годы) и доказательство работы (изобретено в 1990-е годы).

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

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

Шаг 1. Определите подходящий вариант использования

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

Есть 3 вещи, которые блокчейны могут делать очень хорошо:

1. Аутентификация и проверка данных: это включает неизменяемое хранилище, цифровые подписи и шифрование. В блокчейне можно хранить данные практически в любом формате. Блокчейны могут создавать пары открытого и закрытого ключей, а также использоваться для генерации и проверки цифровых подписей.
2. Интеллектуальное управление активами: включает выпуск, оплату, обмен, условное депонирование и изъятие из обращения.Умный / криптоактив — это токенизированная версия реального актива, например золото, серебро, масло, земля.
3. Смарт-контракты: Этот термин чаще всего понимают неправильно, но об этом мы поговорим в другой раз.

Шаг 2: Определите наиболее подходящий механизм консенсуса

Исходный блокчейн, на котором работает криптовалюта биткойн, использовал доказательство работы в качестве механизма консенсуса. Но сегодня существует несколько систем распределенного реестра, которые предлагают множество механизмов консенсуса, таких как доказательство доли, византийская отказоустойчивость, консенсус на основе депозита, федеративное византийское соглашение, доказательство истекшего времени, производные PBFT, избыточная византийская отказоустойчивость, упрощенная византийская отказоустойчивость. , Федеративный консенсус, Раунд Робин и Делегированное подтверждение ставки.

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

Шаг 3. Определите наиболее подходящую платформу

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

Вот некоторые из наиболее популярных платформ в алфавитном порядке:

1.BigChainDB

2. Ядро цепочки

3. Corda

4. Кредиты

5. Блокчейн Domus Tower

6. Блокчейн-платформа Elements

7. Eris: db

8. Ethereum

9. HydraChain

10. Hyperledger Fabric

11. Hyperledger Iroha

12. Hyperledger Sawtooth Lake

13. Multichain

14. Openchain

15.Кворум

16. Stellar

17. Сборка Symbiont

Шаг 4: Проектирование узлов

Решения Blockchain могут быть разрешенными (например, государственный земельный кадастр) или без разрешения (например, Биткойн, где любой может стать майнер). Блокчейн-решения могут быть частными (например, система управления контрактами, реализованная в фармацевтической компании), публичными (например, криптовалюта, обеспеченная активами) или гибридными (например, группа банков, использующих общую платформу KYC).

Еще один фактор, который следует учитывать на этом этапе, — будут ли узлы работать в облаке, локально или и там, и там. Затем возникают проблемы с конфигурацией оборудования, такие как процессоры, память и размер диска. Вам также необходимо определиться с базовыми операционными системами (обычно Ubuntu, CentOS, Debian, Fedora, Red Hat или Windows).

Шаг 5: Разработка экземпляра блокчейна

Большинство платформ блокчейнов требуют очень тщательно спланированной конфигурации следующих элементов:

1.Разрешения

2. Выпуск активов

3. Перевыпуск активов

4. Атомарные обмены

5. Управление ключами

6. Множественные подписи

7. Параметры

8. Собственные активы

9. Форматы адресов

10. Форматы ключей

11. Сигнатуры блоков

12. Встряхивание рук

Некоторые параметры можно изменить во время выполнения, а некоторые нет, поэтому это очень важный шаг.

Шаг 6. Создание API

Некоторые платформы блокчейнов поставляются с готовыми API, а некоторые — нет. Основные категории API-интерфейсов, которые вам могут понадобиться:

• Создание пар ключей и адресов
• Выполнение функций, связанных с аудитом
• Проверка подлинности данных с помощью цифровых подписей и хэшей
• Хранение и извлечение данных
• Управление жизненным циклом интеллектуальных активов — выпуск , оплата, обмен, условное депонирование и вывод на пенсию
• Смарт-контракты

Шаг 7: Разработка интерфейса администратора и пользователя

На этом этапе вам нужно будет выбрать интерфейс пользователя и языки программирования (например.грамм. HTML5, CSS, PHP, C #, Java, Javascript, Python, Ruby, Golang, Solidity, Angular JS Nodejs). Вам также нужно будет выбрать внешние базы данных (например, MySQL, MongoDB), а также серверы (включая веб-серверы, FTP-серверы, почтовые серверы).

Шаг 8: Добавление Future Tech

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

Изучите блокчейны, построив один

Самый быстрый способ узнать, как работают блокчейны, — это построить один

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

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

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

Прежде чем начать…

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

Если вы не знаете, что такое хеш, вот объяснение.

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

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

  pip install Flask == 0.12.2 requests == 2.18.4  

О, вам также понадобится HTTP-клиент, например Postman или cURL. Но все подойдет.

Где последний код? Исходный код доступен здесь.

Шаг 1. Создание блокчейна

Откройте свой любимый текстовый редактор или IDE, лично я ❤️ PyCharm. Создайте новый файл с именем

  blockchain.py  

Представление цепочки блоков

Мы создадим класс цепочки блоков

  class Blockchain (object):
    def __init __ (сам):
        self.chain = []
        self.current_transactions = []
        
    def new_block (сам):
        # Создает новый блок и добавляет его в цепочку
        проходить
    
    def new_transaction (сам):
        # Добавляет новую транзакцию в список транзакций
        проходить
    
    @staticmethod
    def хэш (блок):
        # Хеширует блок
        проходить

    @имущество
    def last_block (сам):
        # Возвращает последний блок в цепочке
        pass  

(Blueprint нашего класса Blockchain)

Наш

  Blockchain  

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

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

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

  block = {
    'index': 1,
    'отметка времени': 1506057125.
5, г.
    'транзакции': [
        {
            'отправитель': "8527147fe1f5426f9dd545de4b27ee00",
            'получатель': "a77f5cdfa2934df3954a5c7c7da5df1f",
            'amount': 5,
        }
    ],
    «доказательство»: 324984774000,
    'previous_hash': "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
}  

( Пример блока в нашей цепочке блоков)

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

Есть ли в этом смысл? Если этого не происходит, подождите некоторое время, чтобы дать понять — это основная идея блокчейнов.

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

Нам понадобится способ добавления транзакций в блок. За это отвечает наш метод

  new_transaction ()  

  class Blockchain (object):
    ...
    
    def new_transaction (я, отправитель, получатель, сумма):
        "" "
        Создает новую транзакцию для перехода в следующий добытый блок
        : param sender:  Адрес отправителя
        : param recipient:  Адрес Получателя
        : param amount:  Amount
        : return:  Индекс блока, который будет содержать эту транзакцию
        "" "

        self.current_transactions.append ({
            "отправитель": отправитель,
            "получатель": получатель,
            'amount': количество,
        })

        вернуть себя.last_block ['index'] + 1  

После того, как

  new_transaction ()  

Создание новых блоков

Когда будет создан экземпляр нашей цепочки блоков

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

  new_block ()  

  new_transaction ()  

  hash ()  

  импортировать хэш-библиотеку
импортировать json
от времени импорта времени


класс Blockchain (объект):
    def __init __ (сам):
        себя.current_transactions = []
        self.chain = []

        # Создаем генезисный блок
        self.new_block (previous_hash = 1, proof = 100)

    def new_block (self, proof, previous_hash = None):
        "" "
        Создайте новый блок в цепочке блоков.
        : param proof:  Доказательство алгоритма Proof of Work
        : param previous_hash: (Необязательно)  Хеш предыдущего блока
        : return:  Новый блок
        "" "

        block = {
            'index': len (self.цепочка) + 1,
            'отметка времени': время (),
            'транзакции': self.current_transactions,
            'proof': доказательство,
            'previous_hash': previous_hash или self.hash (self.chain [-1]),
        }

        # Сбросить текущий список транзакций
        self.current_transactions = []

        self.chain.append (блок)
        блок возврата

    def new_transaction (я, отправитель, получатель, сумма):
        "" "
        Создает новую транзакцию для перехода в следующий добытый блок
        : param sender:  Адрес отправителя
        : param recipient:  Адрес Получателя
        : param amount:  Amount
        : return:  Индекс блока, который будет содержать эту транзакцию
        "" "
        себя.current_transactions.append ({
            "отправитель": отправитель,
            "получатель": получатель,
            'amount': количество,
        })

        return self.last_block ['index'] + 1

    @имущество
    def last_block (сам):
        вернуть self.chain [-1]

    @staticmethod
    def хэш (блок):
        "" "
        Создает хэш SHA-256 блока
        : param block:  Блок
        : return: 
        "" "

        # Мы должны убедиться, что словарь упорядочен, иначе у нас будут несогласованные хэши
        block_string = json.дампы (блок, sort_keys = True) .encode ()
        return hashlib.sha256 (block_string) .hexdigest ()  

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

Понимание Proof of Work

Алгоритм Proof of Work (PoW) — это то, как создаются новые блоки или добывается в цепочке блоков . Цель PoW — найти число, которое решает проблему. Номер должен быть , который трудно найти , но легко проверить — с точки зрения вычислений — кем угодно в сети. Это основная идея Proof of Work.

Мы рассмотрим очень простой пример, который поможет этому усвоить.

Давайте решим, что хэш некоторого целого числа x, умноженного на другое y, должен заканчиваться на 0. Итак,

  hash (x * y) = ac23dc ... 0  

  x = 5  

  из hashlib import sha256
х = 5
y = 0 # Мы еще не знаем, каким должно быть y ...
а sha256 (f '{x * y}'. encode ()). hexdigest () [- 1]! = "0":
    у + = 1
print (f 'Решение: y = {y}')  

Здесь решение:

  y = 21  

  hash (5 * 21) = 1253e9373e ... 5e3600155e860  

В Биткойне алгоритм Proof of Work называется Hashcash . И он не слишком отличается от нашего базового примера выше.Это алгоритм, который майнеры пытаются решить, чтобы создать новый блок. Как правило, сложность определяется количеством символов, которые ищутся в строке. Затем майнеры награждаются за свое решение получением монеты — в транзакции.

Сеть может легко проверить свое решение.

Реализация базового Proof of Work

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

Найдите число p , которое при хешировании с помощью решения предыдущего блока получится хеш с 4 ведущими

   0s   

.

  импорт hashlib
импортировать json

от времени импорта времени
из uuid import uuid4


класс Blockchain (объект):
    ...
        
    def proof_of_work (self, last_proof):
        "" "
        Простой алгоритм доказательства работы:
         - Найдите число p 'такое, что hash (pp') содержит четыре ведущих нуля, где p - предыдущий p '
         - p - предыдущее доказательство, а p '- новое доказательство.
        : param last_proof: 
        : return: 
        "" "

        доказательство = 0
        пока сам.valid_proof (last_proof, proof) ложно:
            доказательство + = 1

        подтверждение возврата

    @staticmethod
    def valid_proof (last_proof, доказательство):
        "" "
        Проверяет доказательство: содержит ли хэш (last_proof, proof) 4 ведущих нуля?
        : param last_proof:  Предыдущее доказательство
        : param proof:  Текущее доказательство
        : return:  Истинно, если верно, если нет.
        "" "

        guess = f '{last_proof} {доказательство}'. encode ()
        guess_hash = hashlib.sha256 (угадать).hexdigest ()
        return guess_hash [: 4] == "0000"  

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

Наш класс почти готов, и мы готовы начать с ним взаимодействовать с помощью HTTP-запросов.

Шаг 2. Наш блокчейн как API

Мы собираемся использовать Python Flask Framework.Это микро-фреймворк, который упрощает сопоставление конечных точек с функциями Python. Это позволяет нам общаться с нашей цепочкой блоков через Интернет, используя HTTP-запросы.

Мы создадим три метода:

•   / transaction / new  

  , чтобы создать новую транзакцию в блоке

•   / mine  

  , чтобы сообщить нашему серверу майнить новый блок.

•   / chain  

  для возврата всей цепочки блоков

Настройка Flask

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

  import hashlib
импортировать json
from textwrap import dedent
от времени импорта времени
из uuid import uuid4

из фляги импорт фляги


класс Blockchain (объект):
    ...


# Создайте экземпляр нашего узла
app = Flask (__ имя__)

# Сгенерировать глобально уникальный адрес для этого узла
node_identifier = str (uuid4 ()). replace ('-', '')

# Создать блокчейн
blockchain = Блокчейн ()


@ app.route ('/ mine', methods = ['GET'])
def mine ():
    return "Мы будем добывать новый блок"
  
@приложение.маршрут ('/ транзакции / новый', методы = ['POST'])
def new_transaction ():
    return "Мы добавим новую транзакцию"

@ app.route ('/ chain', methods = ['GET'])
def full_chain ():
    response = {
        'цепочка': blockchain.chain,
        'длина': len (blockchain.chain),
    }
    вернуть jsonify (ответ), 200

если __name__ == '__main__':
    app.run (host = '0.0.0.0', port = 5000)  

Краткое объяснение того, что мы добавили выше:

• Строка 15: Создает экземпляр нашего Node. Узнайте больше о Flask здесь.
• Строка 18: Создайте случайное имя для нашего узла.
• Строка 21: Создайте экземпляр класса

    Blockchain  

  .
• Строка 24–26: Создайте конечную точку

    / mine  

  , которая представляет собой запрос

    GET  

  .
• Строка 28–30: Создайте конечную точку

    / transaction / new  

  , которая представляет собой запрос POST

   , поскольку мы будем отправлять на нее данные.

• Строка 32–38: Создайте конечную точку

    / chain  

  , которая возвращает полную цепочку блоков.
• Строка 40–41: Запускает сервер на порту 5000.

Конечная точка транзакций

Вот как будет выглядеть запрос на транзакцию. Это то, что пользователь отправляет на сервер:

  {
 "отправитель": "мой адрес",
 "получатель": "чужой адрес",
 «количество»: 5
}  

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

  import hashlib
импортировать json
from textwrap import dedent
от времени импорта времени
из uuid import uuid4

из флакона импорт Flask, jsonify, запрос

...

@ app.route ('/ transaction / new', methods = ['POST'])
def new_transaction ():
    значения = request.get_json ()

    # Убедитесь, что обязательные поля находятся в POST-данных
    required = ['отправитель', 'получатель', 'сумма']
    если не все (требуется k в значениях для k):
        return 'Missing values', 400

    # Создать новую транзакцию
    index = блокчейн.new_transaction (значения ['отправитель'], значения ['получатель'], значения ['количество'])

    response = {'message': f'Транзакция будет добавлена ​​в блок {index} '}
    return jsonify (response), 201  

( Метод создания транзакций)

Конечная точка майнинга

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

• Рассчитать Proof of Work
• Наградить майнера (нас), добавив транзакцию, дающую нам 1 монету
• Создать новый блок, добавив его в цепочку

  import hashlib
импортировать json

от времени импорта времени
из uuid import uuid4

из флакона импорт Flask, jsonify, запрос

...

@ app.route ('/ mine', methods = ['GET'])
def mine ():
    # Мы запускаем алгоритм доказательства работы, чтобы получить следующее доказательство ...
    last_block = blockchain.last_block
    last_proof = last_block ['доказательство']
    proof = blockchain.proof_of_work (last_proof)

    # Мы должны получить награду за доказательство.
    # Отправитель "0" означает, что этот узел добыл новую монету.
    blockchain.new_transaction (
        отправитель = "0",
        получатель = идентификатор_узла,
        сумма = 1,
    )

    # Создайте новый блок, добавив его в цепочку
    previous_hash = блокчейн.хеш (последний_блок)
    block = blockchain.new_block (доказательство, предыдущий_хэш)

    response = {
        'message': "Новый блок подделан",
        'index': блок ['index'],
        'транзакции': блок ['транзакции'],
        'proof': block ['proof'],
        'previous_hash': блок ['previous_hash'],
    }
    return jsonify (response), 200  

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

Шаг 3. Взаимодействие с нашей цепочкой блоков

Вы можете использовать старый простой cURL или Postman для взаимодействия с нашим API по сети.

Запустите сервер:

  $ python blockchain.py
* Запуск на http://127.0.0.1:5000/ (нажмите CTRL + C для выхода)  

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

  GET  

  http: // localhost: 5000 / mine  

Давайте создадим новую транзакцию, сделав запрос POST

  на адрес 
  http: // localhost: 5000 / transaction / new  
с тело, содержащее нашу структуру транзакции:
 ( Использование Postman для выполнения запроса POST) 
 Если вы не используете Postman, вы можете сделать эквивалентный запрос, используя cURL:
  $ curl -X POST -H " Content-Type: application / json "-d '{
 "отправитель": "d4ee26eee15148ee92c6cd394edd974e",
 "получатель": "адрес другого человека",
 «количество»: 5
} '"http: // localhost: 5000 / transaction / new"  
 Я перезапустил свой сервер и добыл два блока, в итоге получилось 3.Давайте проверим всю цепочку, запросив
  http: // localhost: 5000 / chain  
  {
  "цепь": [
    {
      «индекс»: 1,
      "previous_hash": 1,
      «доказательство»: 100,
      "отметка времени": 1506280650.770839,
      "транзакции": []
    },
    {
      «индекс»: 2,
      "previous_hash": "c099bc ... bfb7",
      «пруф»: 35293,
      "отметка времени": 1506280664.717925,
      "транзакции": [
        {
          «количество»: 1,
          "получатель": "8bbcb347e0634905b0cac7955bae152b",
          "отправитель": "0"
        }
      ]
    },
    {
      «индекс»: 3,
      "previous_hash": "eff91a...10f2 ",
      «пруф»: 35089,
      "отметка времени": 1506280666.1086972,
      "транзакции": [
        {
          «количество»: 1,
          "получатель": "8bbcb347e0634905b0cac7955bae152b",
          "отправитель": "0"
        }
      ]
    }
  ],
  «длина»: 3
}  
 Шаг 4: Консенсус 
 Это очень круто. У нас есть базовая цепочка блоков, которая принимает транзакции и позволяет нам добывать новые блоки. Но весь смысл блокчейнов в том, что они должны быть  децентрализованными . А если они децентрализованы, как мы можем гарантировать, что все они отражают одну и ту же цепочку? Это называется проблемой  Consensus , и нам придется реализовать алгоритм консенсуса, если мы хотим, чтобы в нашей сети было более одного узла.
  Регистрация новых узлов 
 Прежде чем мы сможем реализовать алгоритм консенсуса, нам нужен способ сообщить узлу о соседних узлах в сети. Каждый узел в нашей сети должен вести реестр других узлов в сети. Таким образом, нам понадобится еще несколько конечных точек:
  / nodes / register  
, чтобы принять список новых узлов в виде URL-адресов.
  / nodes / resolve  
для реализации нашего алгоритма консенсуса, который разрешает любые конфликты, чтобы гарантировать, что узел имеет правильную цепочку.
 Нам нужно будет изменить конструктор нашей цепочки блоков и предоставить метод для регистрации узлов:
  ...
из urllib.parse импорт urlparse
...


класс Blockchain (объект):
    def __init __ (сам):
        ...
        self.nodes = set ()
        ...

    def register_node (сам, адрес):
        "" "
        Добавить новый узел в список узлов
        : param address:  Адрес узла. Например. 'http://192.168.0.5:5000'
        : return: Нет
        "" "

        parsed_url = urlparse (адрес)
        себя.node.add (parsed_url.netloc)  
 Обратите внимание, что мы использовали набор
  set ()  
для хранения списка узлов. Это дешевый способ гарантировать, что добавление новых узлов идемпотентно - это означает, что независимо от того, сколько раз мы добавляем конкретный узел, он появляется только один раз.
  Реализация алгоритма консенсуса 
 Как уже упоминалось, конфликт возникает, когда один узел имеет цепочку, отличную от другой. Чтобы решить эту проблему, мы сделаем правило, что  - самая длинная допустимая цепочка - является авторитетной. Другими словами, самая длинная цепочка в сети - это , де-факто . Используя этот алгоритм, мы достигаем  Консенсуса  среди узлов в нашей сети.
  ...
запросы на импорт


класс Blockchain (объект)
    ...
    
    def valid_chain (self, цепочка):
        "" "
        Определите, действителен ли данный блокчейн
        : param chain: <список> Блокчейн
        : return:  Истина, если действительна, ложь, если нет
        "" "

        last_block = цепочка [0]
        current_index = 1

        в то время как current_index  Истина, если наша цепочка была заменена, Ложь, если нет
        "" "

        соседи = я.узлы
        new_chain = Нет

        # Мы ищем только цепи длиннее, чем наша
        max_length = len (self.chain)

        # Возьмите и проверьте цепочки со всех узлов в нашей сети
        для узла в соседях:
            response = requests.get (f'http: // {узел} / цепочка ')

            если response.status_code == 200:
                length = response.json () ['длина']
                цепочка = response.json () ['цепочка']

                # Проверяем, длиннее ли длина и действительна ли цепочка
                если длина> max_length и self.valid_chain (цепочка):
                    max_length = длина
                    new_chain = цепочка

        # Замените нашу цепочку, если мы обнаружили новую действующую цепочку длиннее нашей
        если new_chain:
            self.chain = new_chain
            вернуть True

        return False  
 Первый метод
  valid_chain ()  
отвечает за проверку правильности цепочки путем обхода каждого блока и проверки как хэша, так и доказательства.
  resolve_conflicts ()  
- это метод, который проходит через все наши соседние узлы,  загружает  их цепочек и проверяет их, используя вышеуказанный метод. Если найдена действующая цепочка, длина которой больше нашей, мы заменяем нашу. 
 Давайте зарегистрируем две конечные точки в нашем API, одну для добавления соседних узлов, а другую для разрешения конфликтов:
  @ app.route ('/ nodes / register', methods = ['POST'])
def register_nodes ():
    значения = request.get_json ()

    узлы = значения.get ('узлы')
    если узлов нет:
        return "Ошибка: укажите допустимый список узлов", 400

    для узла в узлах:
        блокчейн.register_node (узел)

    response = {
        'message': 'Добавлены новые узлы',
        'total_nodes': список (blockchain.nodes),
    }
    вернуть jsonify (ответ), 201


@ app.route ('/ nodes / resolve', methods = ['GET'])
def консенсус ():
    заменено = blockchain.resolve_conflicts ()

    при замене:
        response = {
            'message': 'Наша цепочка была заменена',
            'new_chain': blockchain.chain
        }
    еще:
        response = {
            'message': 'Наша сеть авторитетна',
            'цепочка': блокчейн.цепь
        }

    return jsonify (response), 200  
 На этом этапе вы можете взять другую машину, если хотите, и развернуть разные узлы в вашей сети. Или раскрутите процессы, используя разные порты на одной машине. Я развернул еще один узел на своей машине, на другом порту, и зарегистрировал его на моем текущем узле. Таким образом, у меня есть два узла:
  http: // localhost: 5000  
и
  http: // localhost: 5001  
.
 ( Регистрация нового узла) 
 Затем я добыл несколько новых блоков на узле 2, чтобы убедиться, что цепочка была длиннее.После этого я позвонил
  GET / nodes / resolve  
на узле 1, где цепочка была заменена алгоритмом консенсуса:
 ( алгоритм консенсуса в работе) 
 И это конец ... вместе, чтобы помочь протестировать ваш блокчейн.
 Надеюсь, это вдохновило вас на создание чего-то нового. Я в восторге от криптовалют, потому что считаю, что блокчейны быстро изменят наше представление об экономике, правительстве и ведении учета.
  Обновление:  Я планирую продолжить часть 2, в которой мы расширим нашу цепочку блоков, добавив в нее механизм проверки транзакций, а также обсудим некоторые способы, которыми вы можете создать свою цепочку блоков.
  Если вам понравилось это руководство, или у вас есть предложения или вопросы, дайте мне знать в комментариях. И если вы заметили какие-либо ошибки, не стесняйтесь вносить свой вклад в код   здесь  ! 
 Согласны или не согласны с некоторыми идеями, представленными в этой статье? Сообщите 
 нам, что вы думаете о Digg.
 Ищете еще  статей о блокчейне ? Подпишитесь на нашу рассылку в нижнем колонтитуле!
 Истории по теме
 Теги 
 Присоединяйтесь к хакеру полдень 
 Создайте бесплатную учетную запись, чтобы разблокировать свой собственный опыт чтения.
 Трудно ли построить блокчейн с нуля? | пользователя Sinai Nday | The Startup 
 Та же самая цепочка затем распределяется по всем узлам сети через P2P-сеть . 
 By Nday Sinai
 Таким образом, вместо централизованной базы данных все транзакции (данные), которые совместно используются узлами, содержатся в блоках , которые объединяются в цепочку  для создания реестра.Этот реестр представляет все данные в цепочке блоков. Все данные в реестре защищены криптографическим хешированием и цифровой подписью и проверяются согласованным алгоритмом  . Узлы в сети участвуют, чтобы гарантировать, что все копии данных, распределенные по сети , одинаковы. 
 5 ключевых концепций, которые следует помнить в экосистеме блокчейна:
  Криптографический хэш и цифровая подпись 
  Неизменяемый реестр 
  P2P-сеть 
  Алгоритм консенсуса (PoW, PoS, PBFT, ETc) 
  Проверка блока (горное дело, ковка и т. Д.) 
 По мере продвижения я объясню эти концепции более подробно.
  Преимущества использования блокчейна: 
 Удаление организаций-посредников
 Неизменяемый реестр
 Прозрачность
 безопасность
  Когда использовать блокчейн? 
 блокчейн не является серебряной пулей, поэтому используйте его, когда:
 Сохраненные данные не должны быть изменены (доказательство существования)
 Данные не могут быть отклонены их владельцем (неотказуемость)
 Вы хотите децентрализация
 Вам нужен один источник истины
 Вам нужен высокий уровень безопасности
 Вам наплевать на скорость (например,Биткойн в среднем занимает 10 минут для проверки блока транзакций). Но некоторые блокчейны быстрее, потому что они используют другие алгоритмы консенсуса, отличные от PoW. Об этом мы поговорим позже.
  Варианты использования блокчейна 
 Блокчейн выходит за рамки криптовалюты и биткойнов, блокчейн может использоваться в разных секторах:
 Недвижимость: землевладение
 Здравоохранение: надежно записывать данные пациента
 Финансы: снизить налоги и посредники, борьба с отмыванием денег, трансграничные платежи
 Цепочка поставок: отслеживание статей от поставщиков до клиентов (аутентичность, создание оригинального контента)
 Кибербезопасность: DDOS-атаки
 Возвращение полномочий пользователю: владение своими данными и делитесь им безопасно, с кем хотите (DID)
 Обмен криптовалюты
 Механизм голосования
  Платформы и приложения Blockchain 
 Биткойн
 Ethereum
 Fabric
 EOS
 Chainlink
 Cardano
 И т.д.…
  Типы цепочек блоков 
 Частное: использовать только для внутреннего пользования и тогда, когда мы лучше знаем пользователей (например,Hyperledger Fabric)
 Public: все могут видеть, что происходит (Биткойн, Ethereum)
 Hybrid: если вы хотите объединить первые два.
  «Разговоры дешевы. Покажи мне код ».  😄
  Есть два способа построить блокчейн: 
 Самый простой - использовать существующие готовые открытые источники блокчейна, такие как Ethereum, Fabric, EOS и т. Д. (Возможно, я напишу одну статью на этом тоже)
 Если ни один из них не соответствует вашим требованиям, создайте свой с нуля
 В этой серии мы создадим его с нуля, чтобы вы могли полностью понять конечный автомат блокчейна .
  2. Как построить? 
 Хорошо, давайте теперь создадим первую детскую цепочку блоков на трех разных языках программирования:  Go, Python и Javascript . Эти прототипы могут помочь вам понять концепции, которые мы описали ранее.
 Во-первых, мы  создадим блок , во-вторых, мы  добавим к нему данные (заголовок и тело) , в-третьих, мы будем хешировать  блок , и последнее, но не менее важное, мы  объединим в цепочку все блокируется.
 Блок содержит информацию, упомянутую ранее, но для упрощения мы собираемся удалить некоторые из них. давайте углубимся в специфику!
  In Go 
 Надеюсь, вы знакомы с программированием на Go, как я упоминал ранее, если не попытаетесь изучить основы: функции, методы, типы данных, структуры, элементы управления потоком, итерации и т. Д.
 Создайте папку и добавьте к нему 2 файла,  main.go и block.go 
 Структура папки:
 go // папка 
 main.go // файл 1 
 block.go // файл 2 
  main.go 
 // использовать основной пакет 
 package main // импортировать fmt packageimport ("fmt") func main () {fmt.Println («Я создаю свой первый блокчейн») // выводим thisCreateBlock («Здесь будет показан слуховой аппарат», «здесь будет показано тело») // вызовем функцию, которая создаст блок и передаст в него некоторые параметры. } 
 Если вы запустите эту программу, она покажет ошибку, потому что функция  CreateBlock  еще не определена, поэтому создайте ее в блоке .go 
  block.go 
 package mainimport ("fmt" // это поможет нам печатать на экране) func CreateBlock (Header, Body string) {fmt.Println (Header, "\ n", Body ) // Покажите мне содержимое блока} 
 Прелесть Go в том, что вам не нужно импортировать или экспортировать функции, просто объявляйте их заглавными буквами, и Go найдет их для вас😃. теперь откройте терминал и перейдите в созданную папку, и  запустите go build , затем запустите . \ go  в Windows, ./ go  в Linux и Macbook.
 Nday Kabulo Sinai
 Мы только что создали простую программу Go, которая вызывает функцию и передает некоторые строковые данные. Давай, займемся еще приятными делами. давайте добавим еще 2 файла,  blockchain.go  и  structure.go , так что теперь у нас есть 4 файла:  main.go, block.go, structure.go и blockchain.go 
  Я добавлю к каждому строка кода несколько комментариев, чтобы вы поняли, что я делаю. 
 строений.go
 block.go
 blockchain.go
 main.go
 Давайте запустим его сейчас,  go build , затем . \ go 
 Результат: by Nday Sinai
 Voila! Легко, правда?
 К сожалению, наши блоки в цепочке блоков не имеют идентификаторов и временных меток, поэтому давайте добавим эту информацию, изменив файл  main.go , добавив эти две строки в цикл  for :
 fmt.Printf ( «Идентификатор блока:% d \ n», i) fmt.Printf ("Timestamp:% d \ n", block.Timestamp + int64 (i)) 
 Давайте сохраним код и запустим его снова,  go build , затем  ./go 
 Окончательный результат: Nday Sinai
 As Как видите, блокчейн хорошо структурирован. За исключением блока генезиса, каждый блок содержит свой хэш и хэш предыдущего блока, что делает его неизменяемым. Если данные в блоке изменяются, хеш автоматически изменится, и блок будет отброшен. У блока генезиса нет предыдущего хеша, потому что он первый, предыдущего блока нет.
 Готово! Поздравляем, вы только что создали свой детский блокчейн  в Go  😉
 В следующих эпизодах мы будем постепенно выполнять требования блокчейна. Блокчейн - это шедевр, который нужно спроектировать так, как должно быть.
  Знаете ли вы, что вы можете щелкнуть в 50 раз больше, чем средняя кнопка? так что продолжайте и разбейте его, если вам понравился этот пост. 
 Нажмите   здесь   для версии  Javascript.
 Как создать собственный блокчейн криптовалюты на Python 
 Криптовалюты
 и лежащая в их основе технология блокчейнов захватили мир врасплох - от их скромного начала несколько лет назад до сегодняшних повседневных разговоров.
 Обычно под блокчейном понимается технология распределенного реестра, которая представляет собой «цепочку блоков». Каждый блок в цепочке блоков имеет хэш предыдущего блока, временную метку и данные транзакции, что делает его защищенным от несанкционированного доступа.
 По словам Эллиота Миннса, который имеет более чем шестилетний опыт разработки программного обеспечения и использует практические проекты, чтобы научить людей создавать криптовалюты: «Изучение того, как создавать блокчейн, поможет вам понять, как работают цифровые валюты, такие как Биткойн и Эфириум, и как вы можете экстраполировать технологию, чтобы ускорить возможности ваших приложений ».
 В этой статье мы собираемся объяснить, как создать простой блокчейн с помощью языка программирования Python.
 Вот базовый план класса Python, который мы будем использовать для создания цепочки блоков:
  Блок (объект) класса:

    def __init __ ():

        проходить

    # начальная структура класса блока

    def compute_hash ():

        проходить

    # создание криптографического хеша каждого блока

  класс BlockChain (объект):

    def __init __ (сам):

    # построение сети

    def build_genesis (сам):

        проходить

    # создание начального блока

    def build_block (self, proof_number, previous_hash):

        проходить

    # строит новый блок и добавляет в цепочку

   @staticmethod

    def confirm_validity (блок, предыдущий_блок):

        проходить

    # проверяет, действителен ли блокчейн

    def get_data (я, отправитель, получатель, сумма):

        проходить

    # объявляет данные транзакций

    @staticmethod

    def proof_of_work (last_proof):

        проходить

    # добавляет к безопасности блокчейна

    @имущество

    def latest_block (сам):

        проходить

    # возвращает последний блок в цепочке  
 Теперь давайте объясним, как работает класс цепочки блоков.
 Начальная структура блока класса 
 Вот код для нашего начального класса блока:
  импорт hashlib

время импорта

Класс Блок (объект):

    def __init __ (self, index, proof_number, previous_hash, data, timestamp = None):

        self.index = index

        self.proof_number = proof_number

        self.previous_hash = previous_hash

        self.data = данные

        self.timestamp = отметка времени или time.time ()

    @имущество

    def compute_hash (сам):

        string_block = "{} {} {} {} {}".формат (self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)

        вернуть hashlib.sha256 (string_block.encode ()). hexdigest ()  
 Как вы можете видеть выше, конструктор класса или метод запуска ( __init __ () ) выше принимает следующие параметры:
  self  - как и любой другой класс Python, этот параметр используется для ссылки на сам класс. С его помощью можно получить доступ к любой переменной, связанной с классом. 
  index  - используется для отслеживания позиции блока в цепочке блоков.
  previous_hash  - используется для ссылки на хэш предыдущего блока в цепочке блоков. 
  данные  - подробные сведения о проведенных транзакциях, например, купленная сумма. 
  timestamp  - вставляет временную метку для всех выполненных транзакций. 
 Второй метод в классе  compute_hash  используется для создания криптографического хеша каждого блока на основе вышеуказанных значений.
 Как видите, мы импортировали алгоритм SHA-256 в проект цепочки блоков криптовалюты, чтобы помочь в получении хэшей блоков.
 После того, как значения будут помещены в модуль хеширования, алгоритм вернет 256-битную строку, обозначающую содержимое блока.
 Итак, это то, что дает неизменяемость блокчейна. Поскольку каждый блок будет представлен хешем, который будет вычисляться из хеша предыдущего блока, повреждение любого блока в цепочке приведет к тому, что другие блоки будут иметь недопустимые хеши, что приведет к поломке всей сети блокчейна.
 Построение цепочки 
 Вся концепция цепочки блоков основана на том факте, что блоки «связаны» друг с другом. Теперь мы создадим класс цепочки блоков, который будет играть важную роль в управлении всей цепочкой.
 Он будет хранить данные транзакций и включать другие вспомогательные методы для выполнения различных ролей, таких как добавление новых блоков.
 Давайте поговорим о вспомогательных методах.
 Добавление метода конструктора 
 Вот код:
  класс BlockChain (объект):

    def __init __ (сам):

        себя.цепь = []

        self.current_data = []

        self.nodes = set ()

        self.build_genesis ()  
 Метод конструктора  __init __ ()  - это то, что создает экземпляр цепочки блоков.
 Вот роли его атрибутов:
  self.chain  - в этой переменной хранятся все блоки. 
  self.current_data  - в этой переменной хранится информация о транзакциях в блоке. 
  сам.build_genesis ()  - этот метод используется для создания начального блока в цепочке.
 Создание блока Бытия 
 Метод  build_genesis ()  используется для создания начального блока в цепочке, то есть блока без каких-либо предшественников. Блок генезиса - это то, что представляет собой начало блокчейна.
 Чтобы создать его, мы вызовем метод  build_block ()  и зададим ему некоторые значения по умолчанию. Параметрам  proof_number  и  previous_hash  присваивается нулевое значение, хотя вы можете дать им любое значение, которое пожелаете.
 Вот код:
  def build_genesis (сам):

        self.build_block (proof_number = 0, previous_hash = 0)

 def build_block (self, proof_number, previous_hash):

        block = Заблокировать (

            index = len (self.chain),

            proof_number = proof_number,

            previous_hash = предыдущий_хэш,

            data = self.current_data

        )

        self.current_data = []

        self.chain.append (блок)

        возвратный блок  
 Подтверждение действительности блокчейна 
 Метод  confirm_validity  имеет решающее значение для проверки целостности цепочки блоков и проверки отсутствия несоответствий.
 Как объяснялось ранее, хэши имеют решающее значение для обеспечения безопасности блокчейна криптовалюты, потому что любое небольшое изменение в объекте приведет к созданию совершенно другого хэша.
 Таким образом, метод  confirm_validity  использует серию операторов if для оценки того, был ли скомпрометирован хэш каждого блока.
 Кроме того, он также сравнивает хеш-значения каждых двух последовательных блоков для выявления любых аномалий. Если цепочка работает правильно, возвращается истина; в противном случае возвращается false.
 Вот код:
  def confirm_validity (блок, предыдущий_блок):

        если previous_block.index + 1! = block.index:

            вернуть ложь

        elif previous_block.compute_hash! = block.previous_hash:

            вернуть ложь

        elif block.timestamp <= previous_block.timestamp:

            вернуть ложь

        вернуть True  
 Объявление данных транзакций 
 Метод  get_data  важен при объявлении данных транзакций в блоке.Этот метод принимает три параметра (информацию об отправителе, информацию о получателе и сумму) и добавляет данные транзакции в список  self.current_data .
 Вот код:
  def get_data (self, отправитель, получатель, сумма):

        self.current_data.append ({

            "отправитель": отправитель,

            'Receiver': получатель,

            'amount': количество

        })

        вернуть True  
 Выполнение доказательства работы 
 В технологии блокчейн Proof of Work (PoW) относится к сложности, связанной с майнингом или генерацией новых блоков в блокчейне.
 Например, PoW может быть реализован путем определения номера, который решает проблему всякий раз, когда пользователь завершает некоторую вычислительную работу. Любой в сети блокчейн должен найти номер сложным для идентификации, но легким для проверки - это основная концепция PoW.
 Таким образом предотвращается рассылка спама и нарушение целостности сети.
 В этой статье мы покажем, как включить алгоритм Proof of Work в проект криптовалюты на блокчейне.
 Завершение с последним блоком 
 Наконец, вспомогательный метод  latest_block ()  используется для получения последнего блока в сети, который на самом деле является текущим блоком.
 Вот код:
  def latest_block (self):

        return self.chain [-1]  
 Реализация майнинга блокчейн 
 Итак, это самый интересный раздел!
 Изначально транзакции хранятся в списке непроверенных транзакций.Майнинг относится к процессу размещения непроверенных транзакций в блоке и решения проблемы PoW. Это можно назвать вычислительной работой, связанной с проверкой транзакций.
 Если все было выяснено правильно, блок создается или добывается и объединяется вместе с другими в цепочке блоков. Если пользователи успешно добыли блок, они часто получают вознаграждение за использование своих вычислительных ресурсов для решения проблемы PoW.
 Вот метод майнинга в этом простом проекте блокчейна криптовалюты:
  def block_mining (self, details_miner):

            себя.получить данные(

            sender = "0", # это означает, что этот узел создал новый блок

            Receiver = details_miner,

            amount = 1, # создание нового блока (или определение номера доказательства) получает 1

        )

        last_block = self.latest_block

        last_proof_number = last_block.proof_number

        proof_number = self.proof_of_work (last_proof_number)



        last_hash = last_block.compute_hash

        block = self.build_block (номер_проверки, last_hash)



        вернуть вары (блок)

  
 Сводка 
 Вот весь код нашего класса криптоблокчейна на Python:
  импорт hashlib

время импорта

Класс Блок (объект):

    def __init __ (self, index, proof_number, previous_hash, data, timestamp = None):

        себя.index = индекс

        self.proof_number = proof_number

        self.previous_hash = previous_hash

        self.data = данные

        self.timestamp = отметка времени или time.time ()

    @имущество

    def compute_hash (сам):

        string_block = "{} {} {} {} {}". формат (self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)

        вернуть hashlib.sha256 (string_block.encode ()). hexdigest ()

    def __repr __ (сам):

        вернуть "{} - {} - {} - {} - {}". формат (self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)

класс BlockChain (объект):

    def __init __ (сам):

        self.chain = []

        self.current_data = []

        self.nodes = set ()

        self.build_genesis ()

    def build_genesis (сам):

        self.build_block (proof_number = 0, previous_hash = 0)

    def build_block (self, proof_number, previous_hash):

        block = Заблокировать (

            index = len (self.chain),

            proof_number = proof_number,

            previous_hash = предыдущий_хэш,

            данные = себя.текущие данные

        )

        self.current_data = []

        self.chain.append (блок)

        блок возврата

    @staticmethod

    def confirm_validity (блок, предыдущий_блок):

        если previous_block.index + 1! = block.index:

            вернуть ложь

        elif previous_block.compute_hash! = block.previous_hash:

            вернуть ложь

        elif block.timestamp <= previous_block.timestamp:

            вернуть ложь

        вернуть True

    def get_data (я, отправитель, получатель, сумма):

        себя.current_data.append ({

            "отправитель": отправитель,

            'Receiver': получатель,

            'amount': количество

        })

        вернуть True

    @staticmethod

    def proof_of_work (last_proof):

        проходить

    @имущество

    def latest_block (сам):

        вернуть self.chain [-1]

    def chain_validity (сам):

        проходить

    def block_mining (self, details_miner):

        self.get_data (

            sender = "0", # это означает, что этот узел создал новый блок

            Receiver = details_miner,

            amount = 1, # создание нового блока (или определение номера доказательства) обозначается 1

        )

        last_block = сам.latest_block

        last_proof_number = last_block.proof_number

        proof_number = self.proof_of_work (last_proof_number)

        last_hash = last_block.compute_hash

        block = self.build_block (номер_проверки, last_hash)

        вернуть вары (блок)

    def create_node (self, адрес):

        self.nodes.add (адрес)

        вернуть True

    @staticmethod

    def get_block_object (block_data):

        возвратный блок (

            block_data ['индекс'],

            block_data ['proof_number'],

            block_data ['предыдущий_хэш'],

            block_data ['данные'],

            timestamp = block_data ['временная метка']

        )

blockchain = BlockChain ()

print («ПОДГОТОВЬТЕ МАЙНИНГ О НАЧАЛЕ»)

печать (блокчейн.цепь)

last_block = blockchain.latest_block

last_proof_number = last_block.proof_number

proof_number = blockchain.proof_of_work (last_proof_number)

blockchain.get_data (

    sender = "0", # это означает, что этот узел построил другой блок

    Receiver = "LiveEdu.tv",

    amount = 1, # построение нового блока (или вычисление номера доказательства) получает 1

)

last_hash = last_block.compute_hash

block = blockchain.build_block (номер_проверки, last_hash)

print ("Вау, ДОБАВЛЕНИЕ УСПЕШНО!")

печать (блокчейн.цепь)  
 Теперь давайте попробуем запустить наш код, чтобы посмотреть, сможем ли мы сгенерировать несколько цифровых монет ...
 Ого, заработало!
 Заключение 
 Вот и все!
 Мы надеемся, что эта статья помогла вам понять базовую технологию, на которой работают такие криптовалюты, как Биткойн и Эфириум.
 Мы только что проиллюстрировали основные идеи, как сделать ваши ноги мокрыми в инновационной технологии блокчейн. Вышеупомянутый проект все еще можно улучшить, добавив другие функции, чтобы сделать его более полезным и надежным.
 Конечно, если вам нужно что-то продвинутое, вы всегда можете взять учебник и полностью погрузиться в мир криптографии.
 У вас есть вопросы или комментарии? Пожалуйста, поделитесь ими ниже.
 Как построить собственный блокчейн для финансового продукта 
 Технологии быстро меняются; люди нет. 
 -   Якоб Нильсен  
 Блокчейн - это относительно новая технология, которая, по мнению многих, используется только для покупки биткойнов.Его стараются внедрить в любой сфере, которая приходит в голову, будь то мода, образование или здравоохранение. Я бы сказал, что это нормально - прошло слишком мало времени, чтобы определить, какая область человеческой деятельности может получить наибольшую выгоду от применения этой технологии. Чтобы понять практическое применение блокчейна, мы должны сначала определить, почему он появился, а затем изучить случаи, когда блокчейн может иметь существенное значение.
  Примечание:  В этой статье не объясняются концепции блокчейна; вместо этого он фокусируется на разработке финтех-приложения с использованием этой технологии.Я объясню, почему финтех уже может принять блокчейн, и, что наиболее важно, сосредоточиться на разработке децентрализованного приложения с использованием этой технологии.
 Оглавление 
 Дон Норман однажды написал, что многие продукты терпят неудачу, потому что они были выпущены в неподходящее время. Я могу переделать это утверждение и сказать: многие технологии не находят практического применения. Когда в начале 90-х Интернет стал широко доступным, каждая сфера попыталась применить его в своем бизнесе.Это была катастрофа, и ее последствия до сих пор видны на тысячах никогда не посещаемых веб-сайтов с ужасными интерфейсами, неуклюже созданными любым, у кого был компьютер. В настоящее время мы наблюдаем практически такую ​​же ситуацию - наиболее перспективная технология десятилетия связана со спекуляциями на криптобиржах. Он широко используется для финансовых махинаций, хотя изначально создавался наоборот.
 
  Источник: Microsoft Azure 
 Попытка исключить человеческий фактор из бизнеса была одной из причин появления блокчейна.Вот почему отрасли, в которых может быть успешно реализован блокчейн, - это те, которые (1) сильно зависят от человеческой деятельности и (2) больше всего страдают от человеческих ошибок, например, финансы.
  Важно:  Блокчейн применяется к различным продуктам из разных отраслей; нам просто нужно больше смелых предпринимателей, которые готовы многое поставить на карту.
 Финтех занимается очень непростым делом - деньгами. Именно здесь происходит большинство мошенничества. Желание стать богаче - это один из основных механизмов, который заставляет людей делать что-то, часто плохое.Финтех-стартапы стремятся улучшить традиционные финансовые институты, например, исключив человеческий фактор из финансовой деятельности.
 Использование блокчейна исключает третьи стороны из финансовых транзакций, например банк, который проверяет лицо, между которым совершается транзакция. Его можно использовать для управления запасами и логистикой, торговли товарами, оптимизации идентификации людей, отслеживания транзакций и многого другого. 
 Окончательное руководство о том, что нужно учитывать перед созданием финтех-продукта
 Что мне нравится в финансах, так это то, что эта отрасль стара как век - и все же мало кто осмеливается войти в нее.К счастью, технологии помогают облегчить повседневное участие людей в финансовой деятельности. Финансовые технологии, также известные как финтех, являются популярным сектором стартапов для предпринимателей, поскольку все больше и больше людей стремятся к финансовой грамотности. Переход к более разумному обращению с финансами привел к тому, что создатели применили ...
 -8 Это не означает, что каждый финтех-продукт может легко внедрить блокчейн. Вот несколько случаев, когда вы можете захотеть использовать блокчейн:
  Вы хотите привлечь инвестиции. Нравится вам это или нет, но блокчейн по-прежнему остается модным словом. Он привлекает больше инвестиций, чем обычный рабочий продукт. Хотя, чтобы получить эти средства, вы должны подготовить убедительное инвестиционное предложение, но решение блокчейна может изменить правила игры для вашего продукта.
  Вы хотите повысить свою конкурентоспособность на рынке.  Если вам удастся успешно построить продукт на блокчейне, вы моментально продемонстрируете свой профессионализм и тем самым станете более привлекательным для инвесторов и клиентов.
  Вы готовы экспериментировать.  Да, любой продукт на основе блокчейна - это эксперимент, потому что немногие знают, на что способна эта технология. Если вы готовы совершить прорыв в своей отрасли, блокчейн может стать правильным выбором.
 Я не предлагаю внедрять блокчейн в следующих случаях:
  Вы ограничены в ресурсах.  Это способ создания продукта с высоким риском, потому что (1) есть несколько инженеров по блокчейну и (2) иметь их в команде дорого.
  Вы не готовы к существенным изменениям.  Изменения касаются оперативного управления и человеческих ресурсов. Если вы являетесь банком, который внедрил блокчейн, вам, скорее всего, придется уволить многих сотрудников, поскольку у людей будет меньше работы.
  У вас краткосрочное видение.  Блокчейн - это долгосрочная перспектива. Это не может быть реализовано за месяц или около того. Если у вас нет долгосрочного плана развития продукта, не беспокойтесь о мечтах о том, чтобы завтра все изменить.
 Что вы можете сделать завтра, даже читая эту статью, - это построить простой блокчейн. Этому посвящена часть 2. Я расскажу вам об основных компонентах, которые требуются для построения блокчейна для финтех-продуктов, предложу некоторые инструменты и покажу реальные фрагменты кода с пояснениями. 
 Разрушить 
 финансовый рынок  
 сильным продуктом
 CryptoNote 
 CryptoNote - это проект с открытым исходным кодом, который позволяет создавать крипто-монеты.У них есть простое пошаговое руководство по созданию криптовалюты. Для его запуска вам понадобятся два узла, которые будут использоваться для запуска сервера Monero.
  Полезные ссылки: 
 Как создать монету
 Как создать кошелек
 Ethereum 
 Популярная открытая программная платформа для создания децентрализованных приложений. Его основное внимание уделяется запуску программного кода вашего приложения на основе блокчейна. Цитата с веб-сайта Ethereum:  «Ethereum - это децентрализованная платформа, на которой работают смарт-контракты: приложения, которые работают точно так, как запрограммировано, без какой-либо возможности простоя, цензуры, мошенничества или вмешательства третьих лиц.”
 ZeroNet 
 ZeroNet используется для создания децентрализованных веб-сайтов. Он использует механизмы адресации и проверки биткойнов, а также распределенную сеть доставки контента BitTorrent для создания сайтов, которые не могут быть подвергнуты цензуре, подделке или блокированию.
 Теперь, когда вы знаете инструменты - Cryptonote, Ethereum и ZeroNet - мы переходим к созданию собственного базового блокчейна. В этом примере я буду использовать Python, но если это не ваш основной язык программирования, вы все равно поймете логику и сможете написать ее на другом языке.
 Сначала я объясню основные элементы, необходимые для построения блока. Я начну с даты создания, одноразового номера, контрольной суммы и данных транзакции. Данные транзакции в нашем случае могут быть просто строкой для упрощения кода.
 Дата создания 
 Текущее и время в формате unix. Это необходимо для будущего развития вашего блокчейна; когда есть много работающих узлов и вы добавляете новый блок в свою ветку, узел будет решать, какой блок использовать, в зависимости от даты создания.
 Nonce 
 Это уникальный набор символов, который нам нужно добавить в блок, чтобы построить контрольную сумму, соответствующую требованиям. Например, если значение nonce равно 5, то мы должны добавить 5 нулей (00000) к блоку данных, чтобы вычислить правильную контрольную сумму.
 Контрольная сумма 
 Также иногда называется хеш-значением, хеш-кодом или просто хеш-кодом. Это данные блока с одноразовым номером плюс контрольная сумма предыдущего блока. SHA256 защищает цепочку бухгалтерской книги от перезаписи. 
 Как это работает: Узел вычисляет контрольную сумму и сравнивает ее с контрольной суммой нового блока; если они совпадают, блок добавляется в цепочку блоков.
 Данные 
 Это набор данных, которые будут храниться в блоках и подписаны. Он может содержать любые данные: например, биткойн хранит список транзакций, а не только последнюю транзакцию; или вы можете сохранить информацию о компьютере, который создал блок, например, его MAC-адрес; или вы можете указать более подробную дату создания, скажем, добавив часовой пояс.
 Доказательство работы 
 Доказательство работы (PoW) - это уникальный алгоритм консенсуса в сети блокчейн. Он используется для проверки операций и создания новых цепочек в сети цепочек блоков.Основная идея PoW - усложнить построение блока на стороне клиента и снизить нагрузку на сервер. Например, я говорю, что контрольная сумма должна иметь 5 ведущих нулей; это означает, что мы будем увеличивать nonce до тех пор, пока контрольная сумма не будет иметь 5 нулей отведения.
 Прежде всего, я создам класс для блока. Это будет очень простой класс с конструктором, методом вычисления контрольной суммы и свойством проверки правильности блока. У нас будет две константы: одна для количества ведущих нулей в контрольной сумме, а вторая для определения того, какой символ мы будем использовать с одноразовым номером.
  время импорта
из hashlib import sha256

блок класса:
    CHECKSUM_LEAD_ZEROS = 5
    NONCE_SYMBOL = 'Z'

    def __init __ (self, prev_block, data):
        self._prev_block = prev_block
        self.data = данные
        self.checksum = Нет
        self.nonce = 0
        self.timestamp = time.time ()

    @имущество
    def is_valid (self):
        контрольная сумма = self.calculate_checksum ()

        возвращаться (
            контрольная сумма [: self.CHECKSUM_LEAD_ZEROS] == '0' * self.CHECKSUM_LEAD_ZEROS
            и контрольная сумма == self.checksum
        )

    def calculate_checksum (самостоятельно):
        data = '|' .join ([
            str (self.timestamp),
            self.data,
            self._prev_block.checksum,
        ])
        данные + = self.NONCE_SYMBOL * self.nonce

        вернуть sha256 (байты (данные, 'utf-8')). hexdigest ()
  
 Конструктор 
 Конструктор принимает только два параметра; первый - это предыдущий блок, а второй - данные текущего блока.Кроме того, конструктор создает метку времени и устанавливает значение nonce равным нулю в качестве начального значения.
 Действителен 
 Свойство, которое вычисляет контрольную сумму и сравнивает, совпадает ли текущая с вычисленной и имеет ли нужное количество нулей.
 Подсчитать контрольную сумму 
 Самый сложный метод в нашем коде. Этот метод упаковывает метку времени, данные и контрольную сумму предыдущего блока в одну строку. Затем мы добавляем строку nonce; в нашем случае это будет список «Z».Затем он вычисляет контрольную сумму строки результата.
 Теперь у нас есть простой, но полностью функциональный блок. Перейду к созданию цепочки блоков. Пока это будет простая цепочка без возможности хранить и загружать данные, но она передаст основную идею.
  импорт json

цепочка классов:

    def __init __ (сам):
        self._chain = [
            self._get_genesis_block (),
        ]

    def is_valid (self):
        prev_block = self._chain [0]
        для блока в self._chain [1:]:
            assert prev_block.checksum == self._prev_block.checksum
            утверждать block.is_valid ()
            prev_block = блок

    def add_block (self, data):
        block = Блок (self._chain [-1], данные)
        block = self._find_nonce (блок)
        self._chain.append (блок)

        блок возврата

    @staticmethod
    def _get_genesis_block ():
        genesis_block = Блокировать (Нет, Нет)
        genesis_block.контрольная сумма = '00000453880b6f9179c0661bdf8ea06135f1575aa372e0e70a19b04de0d4cbc7'

        вернуть genesis_block

    @staticmethod
    def _find_nonce (блок):
        начало = '0' * Блок. CHECKSUM_LEAD_ZEROS
        в то время как True:
            контрольная сумма = block.calculate_checksum ()
            если контрольная сумма [: Block.CHECKSUM_LEAD_ZEROS] == начало:
                перерыв
            block.nonce + = 1

        block.checksum = контрольная сумма

        блок возврата
  
  Давайте посмотрим на методы в нашем классе цепочки: 
 Конструктор 
 Я только что создал цепочку только с одним блоком - генезис-блоком.Блок Genesis - это первый блок в цепочке, имеющий только контрольную сумму. Этот блок необходим для добавления первого реального блока в цепочку, потому что настоящий блок требует контрольной суммы последнего блока в цепочке.
 Добавление нового блока 
 Имеет только один параметр - данные для нового блока. Этот метод создает новый блок с заданными данными и запускает метод, чтобы найти правильное значение nonce. Только тогда он добавит в цепочку новый блок.
 Найти одноразовый номер 
 Этот метод направлен на поиск правильного одноразового номера для блока.Он имеет бесконечный цикл, в котором я увеличиваю одноразовый номер и вычисляю новую контрольную сумму. Затем он сравнивает контрольную сумму с правилами - пока это только количество нулей.
 Проверить цепочку 
 Этот метод сообщает нам, действительна ли цепочка. Он просматривает все блоки в цепочке и проверяет, действителен ли каждый блок.
 В этой статье я попытался доказать, что построить простой, но работающий блокчейн не так сложно, как может показаться. Мой общий совет - взять урок, который вы усвоили здесь, и начать играть с блокчейном, экспериментируя с блоками и данными.Все замечательные продукты, включая блокчейн, когда-то были экспериментами.
 Если вы работаете в индустрии финансовых технологий, я предлагаю вам больше узнать о продуктах, использующих блокчейн. Некоторые вещи о них известны; они более безопасны, более привлекательны для инвестиций и, если они добьются успеха на мировом рынке, будут названы кардинальными изменениями. Сделан первый шаг по адаптации новой технологии. Следующим шагом является распространение знаний и обучение людей особенностям блокчейна.
 Следите за обновлениями в следующей части о блокчейне и финтехе, скорее всего, с более сложными фрагментами кода и предложениями по его практическому применению в финтехе от нашей компании, занимающейся разработкой Python.
 Полное руководство по разработке цепочки блоков 
 В этом разделе мы объяснили процесс создания приложения на основе блокчейна. Давайте разберемся, как начать разработку приложения на основе блокчейна и какие шаги необходимы для успешной разработки приложения.
  1.Определите проблемы, которые вы хотите решить с помощью блокчейна 
 Прежде всего, важно разработать формулировку проблемы и понять все проблемы, которые вы хотите решить с помощью предлагаемого решения. Убедитесь, что решение блокчейн принесет пользу вашему бизнесу. Проанализируйте, нужно ли вам перенести текущее решение на блокчейн или вам нужно разработать новое приложение с нуля.
 Например, предположим, что вы - поставщик медицинских услуг, который хочет разработать приложение для обмена медицинскими записями на основе блокчейна.В этом случае вы должны знать различные варианты использования приложений и их преимущества для пользователей.
 После того, как вы решите, что вам нужно решение на основе блокчейна для ваших бизнес-операций, следующим шагом будет выбор правильной платформы блокчейна и инструментов разработки блокчейна для вашего проекта.
  2. Выберите правильную платформу блокчейн 
 Как упоминалось выше в статье, построение блокчейна с нуля требует тщательного исследования, а для его успешного развития требуются месяцы или годы.Следовательно, вы должны создать приложение блокчейн поверх платформы блокчейна, которая соответствует вашим бизнес-требованиям. Вы должны определить правильную платформу блокчейна для своего приложения на основе таких факторов, как механизм консенсуса и проблемы, которые вы хотите решить. Например, вы можете создать приложение на основе Ethereum для разработки децентрализованного общедоступного приложения со смарт-контрактами. Когда платформа блокчейн определена, вы должны провести мозговой штурм и понять точные потребности бизнеса.
  3. Мозговой штурм и формирование идей блокчейна 
 После того, как вы определите платформу блокчейна для разработки приложения блокчейн, вам следует сосредоточиться на разработке бизнес-требований и мозговом штурме. Узнайте, какие технологические компоненты следует добавить в экосистему блокчейна в качестве объектов вне сети или в цепочке. Создайте дорожную карту продукта, которая поможет вам создать приложение в установленные сроки. Вы должны придумать модель блокчейна и концептуальный рабочий процесс приложения блокчейн.
 Также решите, нужно ли разрабатывать приложение в разрешенной или неразрешенной сети блокчейнов. Было бы полезно, если бы вы также приняли решение о языках программирования, серверах и внешних базах данных, которые будут использоваться на этом этапе.
  4. Подтверждение концепции 
 Доказательство концепции сделано, чтобы представить практическую применимость проекта блокчейн. Это может быть либо проектный образец, либо теоретическая надстройка. В «Теоретической сборке» каждый проект требует теоретических примеров, чтобы пользователи могли понять применимость и жизнеспособность продукта.Предложения могут быть созданы для объяснения параметров проекта. После создания теоретической базы и получения обратной связи разработан прототип, который включает:
 эскизов
 мокапов
 протестированный продукт
 дизайнов
 информационная архитектура
 Когда клиент утверждает PoC, следующим шагом является подготовка технического и визуального дизайна для приложения.
  5. Визуальный и технический дизайн 
 Поскольку на этом этапе вы спланировали все приложение, начните создавать пользовательские интерфейсы для каждого программного компонента.Разрабатывает API-интерфейсы, которые будут интегрированы с пользовательскими интерфейсами для запуска приложения в серверной части. Визуальный дизайн создается для того, чтобы придать внешний вид приложению, тогда как технический дизайн представляет собой технологическую архитектуру приложения.
 После разработки консолей администратора и пользовательских интерфейсов приложение готовится к разработке.
  6. Развитие 
 Разработка - это важный этап процесса разработки блокчейна, на котором вы должны быть готовы создать приложение блокчейн.На этом конкретном этапе вам необходимо разработать или интегрировать API-интерфейсы для конкретных вариантов использования приложения. Приложение создано для нескольких версий.
 Во-первых, приложение, которое не проходит формальное тестирование, является пре-альфа-версией приложения.
 После того, как клиент одобряет его, приложение переходит к следующему этапу, то есть альфа-версии, где разработчики тестируют программное обеспечение с помощью методов белого ящика. Но на данном этапе программное обеспечение может не включать в себя все функции.
 После выпуска альфа-версии приложение готово к бета-версии. На этапе бета-тестирования программное приложение имеет полный набор функций, но с некоторыми неизвестными ошибками. Разработчики делятся бета-версией с определенной группой людей за пределами организации, чтобы проверить ее функциональность.
 После утверждения и тестирования бета-версии приложение переходит к версии Release Candidate, которая является расширенной бета-версией, готовой стать окончательной версией приложения и может быть запущена.
 После тщательного тестирования приложение переходит в стадию производства и готово к отправке.
 Перед запуском приложения необходимо развернуть его в тестовой сети, чтобы тщательно протестировать его функциональность.
 При развертывании приложения администраторы также могут управлять тем, какие версии приложения необходимо развернуть на различных ресурсах с подготовкой.
 После инициализации приложение должно быть размещено в основной цепочке. Если ваше блокчейн-приложение представляет собой гибридное решение, т.е.е., он содержит бизнес-объекты как вне сети, так и внутри сети, вам необходимо развернуть его на облачном сервере и в магазине приложений / магазине игр. Приложение должно иметь возможность обновляться в соответствии с любыми новыми бизнес-потребностями и приоритетами.
 Например, если вам нужно обновить смарт-контракт, позже вы сможете без труда развернуть новые контракты.
 Разработка и развертывание приложения не означает, что вы закончили. Вместо этого программное обеспечение необходимо поддерживать после разработки, чтобы гарантировать, что оно будет работать со всеми типами обновлений в будущем.
 7 основных шагов для создания решения на базе блокчейна 
  В хаосе постоянно возникающих проектов блокчейна единственный способ выжить и добиться успеха - это найти хорошо спланированное и технически безупречное решение. Это не волшебство - это вопрос кропотливой работы и продуманной стратегии. 
 В октябре 2017 года на GitHub, крупнейшей программной платформе для совместной работы, объединяющей более 24 миллионов пользователей, было  86 034 связанных с блокчейном проектов .Компания Deloittec сообщила, что с апреля 2009 года, когда был опубликован код Биткойна, на GitHub ежегодно появляется в среднем 8603 новых проекта, основанных на технологии блокчейн. Но только  из них 8% остались на плаву  через год после спуска на воду. Таким образом, большинство было заброшено и не принесло существенных результатов.
 В 2017 году авторитетный трекер ICO Tokendataa перечислил  902 проекта ICO . К началу 2018 года 46% из них уже вышли из строя.
 Эти цифры показывают, что  интерес к технологии растет , но только избранным проектам удается создать блокчейн-решение, достаточно устойчивое, чтобы пережить начальные этапы разработки и продвинуться вперед.
 Мы придумали 7 шагов, необходимых для разработки продуманного решения блокчейн.
 Пошаговое руководство 
 Найдите свою нишу 
 Довольно сложно найти креативное и разумное  приложение для технологии блокчейн . Если вы посмотрите на возможные варианты использования, может показаться, что вы можете внедрить распределенный реестр практически в любую отрасль - банковское дело, права интеллектуальной собственности, страхование и т. Д. Однако вы должны провести глубокий анализ существующих проектов, прежде чем приступить к созданию своего.Тот факт, что логистика может извлечь выгоду из возможностей, предоставляемых блокчейном, не означает, что миру нужны 100 идентичных проектов, решающих одну и ту же проблему.
 Следовательно, не слишком в восторге от идеи, которая у вас возникла, пока вы не убедились, что ее стоит воплотить в жизнь.
 Разработка рабочего процесса для интеграции блокчейна 
 Если вы нашли нишу, в которой реализация блокчейна, вероятно, будет полезна для общественности и принесет вам прибыль, остановитесь на секунду и проанализируйте , нужен ли вам блокчейн  или есть другие способы решить существующую проблему.
 Часто в проектах пишутся впечатляющие и подробные технические документы с потрясающими визуальными эффектами. «Ух ты, это круто», - думают авторы, журналисты и все остальные заинтересованные стороны. Но через два-три месяца проект терпит крах. Тайна? Не совсем. Оказывается, инициаторам не удалось обосновать, почему они используют блокчейн.
 Единственная причина для применения блокчейна в бизнесе -  неэффективность существующего централизованного решения , которое работает медленно, дорого и не имеет прозрачности и надежности.В других случаях блокчейн избыточен. Поэтому, пожалуйста, дважды подумайте о том, как вы интегрируете эту технологию в свою стратегию развития, и убедитесь, что она имеет решающее значение для воплощения вашей идеи в жизнь.
 Выберите между новым и существующим блокчейном 
 Если вы уверены, что блокчейн - единственный, самый быстрый и дешевый способ решения острой проблемы, тогда создавайте сеть блокчейнов.
 Первый выбор, который вы должны сделать, - это создать собственный блокчейн или использовать существующий.Прежде чем выбрать первый вариант и с энтузиазмом спросить, как создать блокчейн, просто приготовьтесь к тому, что  потратят месяцы на его разработку . Вам нужно будет спроектировать узлы и экземпляр блокчейна, а также спланировать конфигурацию для множества элементов, таких как выпуск и перевыпуск активов, подписи блоков и многие другие. Кроме того, вам нужно будет создать API и интерфейсы для пользователей и администраторов. Кроме того, вам необходимо выбрать языки программирования (например, Java, Javascript, Python, Node.js и др.), внешние базы данных и серверы.
 Если вы не хотите заморачиваться со всеми этими нюансами, вам лучше выбрать один из существующих блокчейнов. С этого момента мы предполагаем, что вы отдали предпочтение этому варианту, вместо того чтобы тратить месяцы на разработку своей цепочки блоков.
 Выбор между частным и публичным блокчейном 
 Когда вы имеете дело с существующим решением, вам не нужно тратить огромное количество времени на программирование блокчейна. Что вам нужно сделать, так это решить, какой тип блокчейна лучше всего соответствует вашим потребностям - частный или общедоступный.
 Они существенно различаются, и ваш выбор должен основываться на ваших потребностях.  Публичные цепочки блоков  работают довольно медленно: в случае с биткойнами для подтверждения транзакции требуется до 10 минут. К тому же их использование дорогое и ресурсоемкое. Но эти недостатки ничего не значат, если для вас важна прозрачность, а все члены вашей сети независимы и не доверяют.
 Частный блокчейн   быстрее и дешевле в использовании, но он не позволяет никому подключаться к сети, проверять историю транзакций или генерировать новый блок.Он не такой прозрачный и анонимный, как публичный блокчейн.
 Следовательно, вы выбираете между открытостью и прозрачностью публичной сети и быстротой и низкой стоимостью частной. Для получения дополнительной информации ознакомьтесь с нашим сравнением блокчейнов.
 Выберите соответствующий механизм консенсуса 
 Если вы решили использовать общедоступную сеть для разработки решения на основе блокчейна, вы должны выбрать предпочтительный механизм консенсуса. Это алгоритм, позволяющий независимым участникам доверять друг другу.
 Наиболее широко используемым протоколом консенсуса является  Proof-of-Work , присущий блокчейну Биткойн. Когда определенный пользователь (узел) создает новый блок и хочет добавить его в цепочку блоков, другие участники сети могут легко проверить, разумно ли добавить этот конкретный блок. Если все в порядке, в цепочке блоков появляется новый блок, и все участники соглашаются, что содержащаяся в нем информация действительна.
 Помимо Proof-of-Work, вы можете отдать предпочтение:
 Proof-of-Stake
 Delegated Proof-of-Stake
 Proof-of-Authority
 Также существует множество других консенсусов такие механизмы, как консенсус на основе депозита, византийская отказоустойчивость, подтверждение прошедшего времени и другие.Но они используются редко, и это скорее исключение, чем правило, когда блокчейн основан на таких протоколах. Поэтому мы не будем останавливаться на особенностях каждого механизма. Несмотря на то, что Proof-of-Work - это трудоемкое и дорогое решение, оно по-прежнему является наиболее широко используемым.
 Ваш выбор механизма консенсуса определяет список платформ, из которых вы можете выбрать.
 Выберите подходящую платформу 
 Чтобы проанализировать, какая платформа соответствует вашим потребностям, вы можете начать с просмотра тех, которые имеют наибольшую капитализацию на рынке:
 Биткойн
 Ethereum
 Ripple
 Bitcoin Cash
 Litecoin
 Cardano
 Stellar
 NEO
 IOTA
 Monero
 Dash
 NEM
 Все платформы с самым высоким рейтингом, кроме Ripple, являются общедоступными и основаны на протоколе Proof-of-Work.Это не означает, что вы обязаны выбирать одну из них - это просто означает, что выбор таких платформ намного шире, чем у других.
 В любом случае вы должны основывать свой проект на платформе, которая соответствует вашим целям. Обычно блокчейны имеют открытый исходный код и бесплатны для использования, поэтому вы практически не сталкиваетесь с ограничениями с технологической или финансовой точки зрения.
 Решите, нужны ли вам смарт-контракты 
 И последний аспект, который вы должны принять во внимание при создании решения на основе блокчейна, - это планируете ли вы использовать смарт-контракты.Последние представляют собой компьютерные протоколы, которые позволяют  выпускать собственные активы, передавать их или запускать определенные процессы автоматически.  Допустим, вы решили внедрить блокчейн в страховании. Вы хотите оборудовать умные дома устройствами IoT, которые отслеживают температуру, обнаруживают утечки газа и т. Д. Эти устройства связаны со страховыми соглашениями, которые определяют возмещение, которое жители умного дома получат в случае пожара. Следовательно, когда в таком доме происходит пожар и трекеры IoT регистрируют утечку газа в доме, владелец получает автоматическое возмещение, инициированное смарт-контрактом.Таким образом, они позволяют избавиться от посредников, ускорить процесс и выполнить их по более низкой цене.
 Первоначально смарт-контракты предлагал блокчейн Ethereum, но теперь это делают несколько других блокчейнов (EOS, Lisk, Ethereum Classic). Если вы считаете, что возможности, предоставляемые смарт-контрактами, - это именно то, что вам нужно, вам следует искать платформу, поддерживающую этот вариант.
 Принятие окончательного решения 
 Выполнив эти шаги, вы получите решение, соответствующее вашему проекту.Решение, которое вы принимаете на каждом этапе, должно основываться на цели, которую вы хотите достичь, и на структуре сети, которую вы хотите построить. Если вы планируете собрать независимых участников, то ваш выбор - общедоступный блокчейн на основе Proof-of-Work. Если вы хотите шокировать мир новым лучшим биткойном, не торопитесь и создайте совершенно новый блокчейн. Если вы хотите повысить эффективность трансграничной логистической компании, выберите частный блокчейн, дополненный смарт-контрактами.