Как создать свою криптовалюту на python

Как с нуля построить свою блокчейн сеть

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

Какие задачи решает блокчейн

Технологию активно внедряют, потому что она решает несколько задач:

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

• обеспечение безопасности — данные сохраняются на всех блоках в цепи, поэтому полностью удалить или изменить какую-либо запись в системе невозможно;

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

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

Как самостоятельно сделать блокчейн

Чтобы разработать собственный блокчейн, потребуется:

• Python 3.6 или новее;

• библиотека Flask;

• HTTP-клиент (Postman, cURL).

Пишем скелет

Начать работу можно в любом совместимом с Python редакторе, т. е. Integrated Development Environment, например: PyCharm, PyDev, WingWare, Komodo IDE. Создадим файл под названием «Blockchain», чтобы потом не потерять код.

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

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

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

Создаем первый блок

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

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

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

def create_first_block(): 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

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

Назовем новую папку «blockchaindata» и допишем программный код:

chaindata_dir = 'chaindata' if not os.path.exists(blockchaindata_dir): os.mkdir(blockchaindata_dir) if os.listdir(blockchaindata_dir) == []: first_block = create_first_block() first_block.self_save()

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

Синхронизируем блокчейн

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

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

def sync(): node_blocks = [] chaindata_dir = 'chaindata' if os.path.exists(blocchaindata_dir): for filename in os.listdir(blockchaindata_dir): if filename.endswith('.json'): filepath = '%s/%s' % (blockchaindata_dir, filename) with open(filepath, 'r') as block_file: block_info = json.load(block_file) block_object = Block(block_info) node_blocks.append(block_object) return node_blocks

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

Прописываем отображение через браузер

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

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

Код для отображения блокчейна:

node = Flask(__name__) node_blocks = sync.sync() #inital blocks that are synced @node.route('/blockchain.json', methods=['GET']) def blockchain(): node_blocks = sync.sync() #regrab the nodes if they've changed python_blocks = [] for block in node_blocks: python_blocks.append(block.__dict__()) json_blocks = json.dumps(python_blocks) return json_blocks if __name__ == '__main__': node.run()

Проигнорируем импорты для экономии места.

Теперь вы можете посмотреть имеющийся блок, запустив программный код и перейдя в localhost:3000/blockchain.json .

Создание цепочки блоков

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

Сатоши Накамото, создавший Bitcoin, придумал, какой должна быть цепочка в блокчейне: timestamp-сервер (узел) хэширует блок данных и показывает, что информация существовала и потому сохранилась. Каждый хэш состоит не только из новых данных, но и предыдущих. Таким образом, образуется цепь, в которой новые звенья укрепляют предыдущие.

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

• порядковый номер;

• хэш предшественника;

• данные;

• timestamp майнинга.

Для этого нужно прописать команду:

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

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

Для вычисления валидности хэша будем использовать метод, немного отличающийся от использованного Сатоши Накамото, но запустим хедер посредством функции 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()

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

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)

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

Настройка алгоритма подтверждения

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

• Proof of Work (PoW) — подтверждение работы;

• Proof of Stake (PoS) — доказательство доли владения.

Первый вариант считают более безопасным с точки зрения уязвимости, однако актуальность вопроса децентрализации для PoW блокчейнов ежегодно растет. Постепенно майнить становится сложнее, поэтому пользователи объединяются в пулы. В 2021 году было зафиксировано, что 50% мощности сети Bitcoin принадлежит 4 пулам, то есть постепенно происходит стягивание всех процессов к нескольким крупным серверам.

Proof of Stake появился позже. Сейчас его в основном используют в проектах альткоинов. Его особенность в том, что пользователям не нужны огромные мощности, так как PoS не подразумевает майнинг. Приоритеты участников зависят от количества криптовалюты, хранящейся на балансе.

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

Рассмотрим все существенные различия механизмов:

Кто участвует в майнинге/валидации

Владельцы компьютеров с наибольшей вычислительной мощностью

Пользователи с большим количеством заблокированных монет

Оборудование, заточенное под добычу криптовалюты

Любое устройство с постоянным выходом в интернет

Их забирают пользователи, добывшие блок первыми

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

Чем больше хэш, тем защищеннее система

Смарт-контракты блокируют валюту участников

В нашем случае использован Proof of Work, как у Биткоина. Чтобы настроить механизм, необходимо поставить требования к структуре хэша.

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

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

NUM_ZEROS = 4 def mine(last_block): index = int(last_block.index) + 1 timestamp = date.datetime.now() data = "I block #%s" % (int(last_block.index) + 1) #random string for now, not transactions prev_hash = last_block.hash nonce = 0 block_hash = calculate_hash(index, prev_hash, data, timestamp, nonce) while str(block_hash[0:NUM_ZEROS]) != '0' * NUM_ZEROS: nonce += 1 block_hash = calculate_hash(index, prev_hash, data, timestamp, nonce) block_data = <> block_data['index'] = int(last_block.index) + 1 block_data['timestamp'] = date.datetime.now() block_data['data'] = "I block #%s" % last_block.index block_data['prev_hash'] = last_block.hash block_data['hash'] = block_hash block_data['nonce'] = nonce return Block(block_data)

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

Как создать пару ключей

Чтобы зашифровать данные, стоит воспользоваться RSA. В результате вы получите пару ключей: публичный и приватный.

from Crypto.PublicKey import RSA code = 'nooneknows' key = RSA.generate(2048) encrypted_key = key.exportKey( passphrase=code, pkcs=8, protection="scryptAndAES128-CBC" ) with open('my_private_rsa_key.bin', 'wb') as f: f.write(encrypted_key) with open('my_rsa_public.pem', 'wb') as f: f.write(key.publickey().exportKey())

Сначала нужно импортировать RSA из Crypto.PublicKey, а затем создать простой код доступа и сгенерировать ключ RSA на 2048 битов. Чтобы создать приватный ключ, необходимо вызвать метод exportKey и отдать ему код доступа. Последний будет использован стандартом PKCS, схема шифровки которого подходит для защиты конфиденциальной информации.

Полученный файл следует записать на диск. Остается создать приватный ключ через метод publickey, связав его с вызовом exportKey.

Реализация подписей

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

• хэши открытых ключей в разблокированных выходах, чтобы идентифицировать отправителя;

• хэши открытых ключей в новых выходах для подтверждения получателя;

• значения новых выходов.

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

Алгоритм проверки транзакции:

1. Получение информации и ЭЦП из новой транзакции.

1. Сбор хэша.

1. Расшифровка подписи и открытого ключа с помощью RSA Decode.

1. Сравнение хэшей, полученных на втором и третьем этапе.

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

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

Как создать свою криптовалюту?

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

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

Изначально стоит определить и понять в чём суть создания монет в цифровой сфере. Всего программист преследует 3 цели при создании криптовалюты:

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

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

Алгоритм создания криптовалюты

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

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

После получения изначального кода криптовалютной программы следует перейти к некоторому углублению в свойства ПК. Сейчас необходимо подготовить компьютер, загрузив подходящие библиотеки для нормального функционирования программного обеспечения. Чаще всего подобные системы строятся на Linux, подготовка системы относительно простая, для неё потребуется — boost , db48 , qt4-mac и подобные. После закрытия текущего вопроса сразу можно переходить к вводу команд и инициировать процесс.

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

Во всём коде программы необходимо изменить устаревшие наименования на только что выдуманное имя. Вручную изменять все фрагменты – это очень долго, так как в коде присутствует свыше 10 тысяч упоминаний . Честно говоря, это бесполезно, так как существуют специальные программные средства, которые позволяют достичь цели за 1 раз. Как альтернатива – это воспользоваться встроенной функцией редакторов, запустить её можно нажав Ctrl + H , но после процедуры стоит проверить, возможно были произведены нежелательные изменения, которые нарушили работу программы. Сейчас же, вы завершили первый этап создания своей криптовалюты.

Следующая сложность, с которой столкнётся каждый программист и владелец своей криптовалюты – это техническая реализация кода, то есть придётся подбирать должные настройки сети и создавать открытые сетевые порты. В процессе процедуры нужно указывать все порты с выходом в сеть, которые будут служить для выполнения ключевых процедур. Дополнительно нужно выбрать 4 порта, они в последующем будут необходимы для других целей. Чаще предпочитают RPC , P2P и т.д. Нередко пользователи сталкиваются с проблемами в данной сфере, так как выбор падает на занятые порты, тогда придётся их либо освободить, либо использовать другие. После выбора ряда портов следует произвести изменения в подготовленном коде.

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

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

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

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

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

Підписуйтесь на нашу групу в Телеграмі ����

Собственная криптовалюта: реализация блокчейна на Python

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

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

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

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

Внедряем ООП

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

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

import datetime import math import pprint class Block: def __init__(self, data): self.next = None self.data = data def append(self, val): end = Block(val) n = self while (n.next): n = n.next n.next = end

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

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

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

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

def get_data(self): return self.__data

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

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

def __init__(self, prev_hash, transactor, amount): self.next = None self.__data =

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

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

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

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

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

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

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

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

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

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

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

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

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

temp = self while(temp.next):

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

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

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

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

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

Проверяем

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

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

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

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

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

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

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

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

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

chain.next.set_amount(700) print("UPDATE:") print_chain(chain)

UPDATE: < 'amount': 120.0, 'hash': 1423, 'prev_hash': 0, 'time': datetime.time(0, 11, 46, 849539), 'transactor': 'Tim'> < 'amount': 700, 'hash': 20051, 'prev_hash': 1423, 'time': datetime.time(0, 11, 46, 849608), 'transactor': 'Jamil'> < 'amount': 123.45, 'hash': 21512, 'prev_hash': 20051, 'time': datetime.time(0, 11, 46, 849617), 'transactor': 'Carla'>

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

Создаём первый блокчейн на Python за 3 дня

Заявка не отправлена! Похоже произошла ошибка. Попробуйте отправить снова или перезагрузите страницу.

Вы разберётесь, как работают блокчейн и криптовалюты. Создадите свой первый смарт-контракт на языке Solidity и напишете простейший блокчейн на Python. Поймёте, как построить карьеру Python-разработчика и развиваться в ней.

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

Python-разработчики востребованы на рынке. 6532 вакансии для разных уровней открыто на рынке труда.

• от 45 000 ₽ Без опыта
• до 250 000 ₽ 1–3 года опыта
• до 350 000 ₽ 3–6 лет опыта

По данным сайта hh.ru

Кому подойдёт интенсив

Новички в IT

Начинающие программисты

Вы научитесь

• Различать криптовалюты и блокчейн
• Писать простые программы на Python
• Создавать смарт-контракты на Solidity
• Защищать данные с помощью криптографии
• Разбираться в процессе майнинга
• Применять Python в разных сферах блокчейна
• Создавать криптовалюту

Программа

Изучаем основы блокчейна и программирования на Python

• Биткоин и первые блокчейны.
• Перспективы рынка для Python-специалистов.
• Краткое введение в Python.
• Принципы распределенного хранения. Структуры данных, хэш-функции и Computer Science.
• Не только криптовалюты: где ещё нужен блокчейн.

Криптовалютные технологии: создаём смарт-контракты

• Основы криптографии.
• Ключевые различия криптовалют и их блокчейнов.
• Etherium, смарт-контракты на Solidity.
• Процесс майнинга, CPU, ASIC, GPU.
• Как создать собственную криптовалюту.

Блокчейн и криптовалюты: подводим итоги

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

Подарки и призы

• 

Сертификат на обучение в Skillbox

Все, кто сделает домашнее задание, получат сертификат на 15 000 рублей на любой курс.

«Век живи — век учись» Кей Петерсон и Дэвида Колба

Преподаватель

Михаил Овчинников

• Экс-руководитель команды разработки систем машинного обучения и антиспама в Badoo.
• Занимается разработкой ПО последние 17 лет.
• Докладчик крупнейших IT-конференций России.
• Специалист в области разработки высоконагруженных систем, обработки больших данных и машинного обучения.

Что вас ждёт

Мощная программа

Реальные задачи

Комьюнити

Кейс в портфолио

Получить доступ к записи бесплатного интенсива

Заявка не отправлена!

Похоже произошла ошибка. Попробуйте отправить снова или перезагрузите страницу.

Спасибо!

Ваша заявка успешно отправлена

Получайте расписание новых интенсивов каждую неделю

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

Заявка не отправлена!

Похоже произошла ошибка. Попробуйте отправить снова или перезагрузите страницу.

Спасибо за подписку!

Данные успешно отправлены.

Прежде чем вы уйдёте… Загляните на распродажу

Профессии с трудоустройством и топовые курсы. Для вас — со скидками до 50%.

До конца распродажи:

• +7 800 222‒65‒21 Контактный центр
• +7 499 444‒90‒36 Отдел заботы о пользователях

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

Образовательные услуги оказываются ЧОУ ДПО «Образовательные технологии «Скилбокс (Коробка навыков)» на основании Лицензии № Л035-01298-77/00179609 от 19 января 2022 года.

Правообладатель ПО LMS «Skillbox 2.0» ООО «Скилбокс».