Создание криптовалюты «КИБЕРКОИН» на Python в Google Colab (12–14 лет)

Что такое блокчейн и как работает криптовалюта

Зачем нам это в курсе про «КИБЕРКОИН»

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

В этом курсе мы будем создавать учебную криптовалюту «КИБЕРКОИН» на Python в Google Colab. Для начала разберёмся, из каких идей она состоит:

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

как записываются транзакции (переводы)

почему историю переводов сложно подделать

Блокчейн простыми словами

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

хранится не у одного учителя, а сразу у многих ребят

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

устроен так, что старые записи почти невозможно незаметно исправить

Этот «журнал» и есть блокчейн.

Блокчейн — это цепочка блоков, где каждый блок хранит набор записей (обычно транзакций) и «ссылается» на предыдущий блок.

!Цепочка блоков: каждый следующий блок хранит ссылку на предыдущий

Что такое блок

Блок — это «страница» в нашем журнале. В блоке обычно есть:

список транзакций (кто кому и сколько перевёл)

время создания

специальная «цифровая подпись блока» — хеш

хеш предыдущего блока (чтобы получилась цепочка)

Важно: в учебных проектах (как наш «КИБЕРКОИН») структуру блока можно упростить, но идея остаётся той же.

Хеш: «отпечаток пальца» для данных

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

Свойства хеша, которые важны для блокчейна:

если изменить данные хотя бы на один символ, хеш сильно изменится

по самому хешу сложно восстановить исходные данные

Зачем это нужно:

хеш помогает заметить подделку

хеш связывает блоки в цепочку: каждый блок хранит хеш предыдущего

Почему цепочку сложно подделать

Если кто-то попробует поменять старую транзакцию в прошлом блоке:

изменятся данные в блоке

изменится его хеш

следующий блок уже содержит старый хеш предыдущего — связь «сломается»

придётся пересчитать не один блок, а много блоков подряд

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

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

Участники сети, которые хранят копию блокчейна и обмениваются данными, называются узлами (или ноды, от английского nodes).

Узлы делают две важные вещи:

проверяют, что новые транзакции выглядят правильно

договариваются, какой новый блок добавить следующим

Как сеть «договаривается»: идея консенсуса

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

Существуют разные алгоритмы консенсуса. Самый известный исторически — Proof of Work (доказательство работы), который использовался в Bitcoin.

Идея Proof of Work (упрощённо, по-школьному):

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

решить задачу сложно, а проверить ответ легко

тот, кто первым нашёл решение, предлагает новый блок

> «The system is secure as long as honest nodes collectively control more CPU power than any cooperating group of attacker nodes.» — Satoshi Nakamoto, Bitcoin Whitepaper (Bitcoin: A Peer-to-Peer Electronic Cash System)

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

Что такое транзакция в криптовалюте

Транзакция — это запись вида «кто отправил», «кому», «сколько».

В реальных криптовалютах транзакции устроены сложнее, но нам важно понять основу:

транзакции собираются в блок

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

после добавления историю уже очень сложно переписать

!Путь транзакции: от отправителя до добавления в блокчейн

Кошелёк и ключи: как доказать, что монеты твои

В криптовалютах обычно используют пару ключей:

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

приватный ключ — секрет, который доказывает, что именно ты можешь тратить монеты

Очень важно:

приватный ключ нельзя отдавать никому

потерял приватный ключ — потерял доступ к средствам

В нашем учебном «КИБЕРКОИНЕ» мы будем использовать упрощённые идеи, но обсудим, почему в настоящих системах безопасность ключей — это главное.

Почему криптовалюта вообще имеет ценность

Ценность появляется, когда люди согласны, что:

эти «монеты» можно передавать

правила честные и понятные

историю переводов нельзя легко подделать

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

Чем блокчейн отличается от обычной базы данных

| Признак | Обычная база данных (например, у сайта) | Блокчейн | |---|---|---| | Кто управляет | один владелец/компания | сеть участников | | Можно ли тихо переписать историю | иногда да (у владельца есть доступ) | очень сложно (нужно «переделать» цепочку и убедить сеть) | | Где хранится | обычно на одном/нескольких серверах | копии у многих узлов | | Как добавляются записи | по решению владельца | по правилам сети и консенсусу |

Как это пригодится в «КИБЕРКОИНЕ»

В следующих уроках мы начнём собирать учебную версию блокчейна:

научимся хранить блоки как структуры данных в Python

сделаем хеширование блока

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

смоделируем создание новых блоков (упрощённый «майнинг»)

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

Важное правило безопасности и честности

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

не используем реальные деньги

не пытаемся взламывать чужие кошельки

изучаем технологии для обучения и проектов

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

Подготовка Google Colab и базовый Python для проекта

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

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

Чтобы начать писать учебную криптовалюту «КИБЕРКОИН», нам нужна среда, где:

можно быстро запускать Python-код

ничего не нужно устанавливать на компьютер

удобно хранить код и результаты

Для этого идеально подходит Google Colab.

Что такое Google Colab

Google Colab (или просто Colab) — это онлайн-блокнот, где можно писать код на Python прямо в браузере.

Главные плюсы для нашего курса:

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

код запускается на серверах Google

можно сохранять проект на Google Drive

Официальная страница: Google Colaboratory.

!Схема, показывающая основные части интерфейса Colab

Как создать и настроить ноутбук для «КИБЕРКОИНА»

Создаём ноутбук

Сделай так:

Открой Google Colaboratory

Нажми New Notebook (или Новый блокнот)

Переименуй файл, например в KIBERCOIN.ipynb

Где хранится файл

Обычно Colab предлагает сохранить ноутбук на Google Drive. Это удобно, потому что:

файл не потеряется, если закрыть вкладку

можно открыть проект с другого компьютера

Важно про «сессию» Colab

Colab работает как «временный компьютер» в облаке.

Что полезно помнить:

если долго ничего не делать, сессия может завершиться

после перезапуска сессии нужно заново запускать код (особенно тот, который что-то загружает или настраивает)

Ячейки в Colab: текст и код

В ноутбуке есть два основных типа ячеек.

Текстовая ячейка (Markdown) — для объяснений и заметок

Ячейка кода — для Python

Как запускать код:

нажми кнопку запуска слева от ячейки

или используй сочетание клавиш Shift+Enter

Минимальный набор правил «аккуратного ноутбука»

Чтобы проект «КИБЕРКОИН» было легко читать и проверять:

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

не удаляй важный вывод, если он помогает понять результат

если что-то не работает, пробуй: Runtime → Restart runtime и запусти всё заново сверху вниз

Базовый Python, который пригодится для блокчейна

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

Переменные и типы данных

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

Примеры:

Списки и словари (главные структуры для нашего проекта)

Список — когда данных много и порядок важен (например, список транзакций).

Словарь — когда есть «ключ → значение» (например, данные одного блока).

Условия: проверяем правила

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

Циклы: делаем повторения

Циклы нужны, например, чтобы:

перебрать все блоки в цепочке

перебрать все транзакции в блоке

повторять попытки при упрощённом «майнинге»

Функции: чтобы код был понятным

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

Импорты: берём готовые инструменты из Python

Нам понадобятся стандартные библиотеки Python.

hashlib — чтобы делать хеши (это «отпечатки данных»)

json — чтобы аккуратно превращать словари в строку

time или datetime — чтобы ставить время блоку

Документация:

hashlib — Secure hashes and message digests

json — JSON encoder and decoder

Пример импорта:

Первый важный шаг для блокчейна: делаем хеш строки

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

Что здесь происходит:

sha256 — популярный алгоритм хеширования

encode() превращает строку в байты (так нужно для хеш-функции)

hexdigest() превращает результат в удобную строку из символов

Важно: если изменить text хотя бы на один символ, хеш будет совсем другим.

Как хешировать «данные блока», если это словарь

Хеш-функция не умеет хешировать словарь напрямую. Поэтому обычно делают так:

превращают словарь в строку (часто в JSON)

хешируют эту строку

Зачем sort_keys=True:

чтобы ключи в JSON шли в одном и том же порядке

чтобы один и тот же блок давал один и тот же хеш

Печать и отладка: как понимать, что делает программа

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

Если что-то пошло не так:

прочитай текст ошибки (обычно там написано, что именно не найдено)

проверь опечатки в ключах словаря, например "prev_hash"

убедись, что запустил ячейки сверху вниз

Установка дополнительных библиотек (если понадобится)

В этом курсе мы постараемся использовать стандартные библиотеки. Но иногда в Colab нужно установить пакет.

Пример команды установки:

Важно:

знак ! означает, что это команда системы, а не чистый Python

после перезапуска сессии Colab установку иногда нужно повторять

Мини-план: что мы будем делать дальше

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

В следующих уроках мы начнём собирать «КИБЕРКОИН» по шагам:

создадим структуру блока

сделаем цепочку блоков (blockchain)

добавим проверку корректности цепочки

смоделируем упрощённый «майнинг»

Главная идея: мы не делаем «настоящие деньги», мы учимся строить систему, где история переводов связана хешами и её сложно подделать.

Блоки и цепочка: структура данных КИБЕРКОИНА

Как этот урок связан с предыдущими

В прошлых уроках мы разобрали:

что блокчейн похож на общий журнал

что блоки связываются хешами

как в Google Colab писать Python и считать хеши через hashlib

Теперь мы сделаем следующий практический шаг: договоримся, как именно хранить блоки и всю цепочку в нашем учебном проекте «КИБЕРКОИН».

Главная идея урока

Чтобы сделать блокчейн на Python, нам нужны всего две структуры данных:

блок как словарь dict

цепочка как список list из блоков

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

!Схема: каждый блок хранит хеш прошлого блока, а вся цепочка — это список блоков

Что мы будем хранить в одном блоке

В учебном «КИБЕРКОИНЕ» блок будет словарём. Внутри будут такие поля:

index — номер блока в цепочке

timestamp — время создания блока

transactions — список переводов внутри блока

prev_hash — хеш предыдущего блока (связь в цепочке)

nonce — число для упрощённого «майнинга» (подбор хеша)

hash — хеш этого блока (его «отпечаток»)

Почему нужно и prev_hash, и hash:

prev_hash говорит, на какой блок мы опираемся

hash позволяет проверить, что блок не меняли после создания

Как выглядит транзакция в нашем проекте

Транзакция — это тоже словарь. Мы начнём с трёх полей:

from — кто отправил

to — кому отправили

amount — сколько монет

Пример списка транзакций (пока без настоящих подписей и ключей, это будет позже):

Цепочка блоков: что такое blockchain в коде

В Python цепочку удобно хранить как список:

Почему список подходит:

блоки идут по порядку

легко взять последний блок через blockchain[-1]

легко перебрать все блоки циклом for

Генезис-блок: самый первый блок

Первый блок в цепочке называют генезис-блоком (genesis block). Он особенный:

у него нет настоящего предыдущего блока

поэтому prev_hash задают как фиксированное значение, например строку из нулей

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

Считаем хеш блока правильно: одинаковые данные → одинаковый хеш

Хеш блока мы будем считать так:

соберём данные блока в словарь

превратим словарь в строку JSON с sort_keys=True

посчитаем sha256

Почему важно sort_keys=True:

словарь сам по себе не гарантирует «одинаковый порядок ключей»

а хеш зависит от каждого символа строки

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

Ссылки на документацию Python:

hashlib — Secure hashes and message digests

json — JSON encoder and decoder

Код: функция хеширования блока

Скопируй это в Google Colab в одну ячейку и запусти:

Пояснения к коду:

ensure_ascii=False нужно, чтобы русские буквы сохранялись нормально

hexdigest() делает красивую строку из символов (её удобно хранить)

Код: создаём генезис-блок

Теперь создадим первый блок и положим его в цепочку.

Обрати внимание: при подсчёте хеша мы не включаем поле hash внутрь данных, иначе получится «хеш самого себя», и это будет путать.

Что такое "0" * 64:

хеш SHA-256 обычно выглядит как 64 символа в шестнадцатеричном виде

для первого блока мы делаем «предыдущий хеш» из 64 нулей

Код: создаём следующий блок на основе предыдущего

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

Как проверить, что цепочка не сломана

Мы уже можем сделать простую проверку корректности. Логика такая:

у каждого блока (кроме первого) поле prev_hash должно совпадать с hash предыдущего блока

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

Код проверки:

Важное замечание про «учебность» нашего блокчейна

Сейчас наш «КИБЕРКОИН» ещё не защищён так, как настоящие криптовалюты. Пока нет важных частей:

цифровых подписей (чтобы доказать, кто отправитель)

правил баланса (чтобы нельзя было отправить больше, чем есть)

сети узлов (пока всё работает в одном ноутбуке)

настоящего консенсуса (как договариваться, какой блок правильный)

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

Что дальше по курсу

Дальше мы будем делать «КИБЕРКОИН» более похожим на криптовалюту:

добавим упрощённый «майнинг» через nonce и условие сложности (например, хеш должен начинаться с 0000)

сделаем очередь неподтверждённых транзакций (мемпул)

научимся проверять правила перед добавлением блока

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

Хэширование: создаём цифровой «отпечаток» блока

Как этот урок связан с предыдущими

В прошлых уроках мы:

узнали, что блокчейн — это цепочка блоков, связанных хешами

настроили Google Colab и вспомнили базовый Python

собрали структуру блока и цепочки для учебного проекта «КИБЕРКОИН»

Теперь разберём ключевую «магию» блокчейна: хэширование. Именно хеш делает так, что блок становится похож на страницу в журнале, которую сложно незаметно переписать.

Что такое хеш простыми словами

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

Удобная аналогия:

данные блока — это «текст на странице»

хеш — это цифровой «отпечаток пальца» этой страницы

Если страницу чуть-чуть изменить, «отпечаток» станет совсем другим.

!Схема показывает, что даже маленькое изменение данных сильно меняет хеш

Какие свойства хеша нам важны в «КИБЕРКОИНЕ»

Для учебного блокчейна нам достаточно понимать 4 свойства.

Одинаковые данные → одинаковый хеш

Маленькое изменение данных → большой скачок в хеше

Хеш удобно проверять: пересчитал — сравнил

Данные «прятать» в хеше нельзя: по хешу нельзя просто взять и восстановить исходный текст

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

Почему в блокчейне хеш нужен именно блоку

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

блок хранит hash — отпечаток своих данных

следующий блок хранит prev_hash — отпечаток предыдущего блока

Если кто-то изменит старый блок (например, сумму перевода), его hash поменяется, а значит, у следующего блока prev_hash уже будет «не тот». Цепочка начнёт «ломаться» при проверке.

Какой хеш мы используем

В «КИБЕРКОИНЕ» мы используем SHA-256 из стандартной библиотеки Python hashlib.

Полезные источники:

Документация Python: hashlib

Статья Википедии: SHA-2

Почему хеш SHA-256 выглядит как 64 символа

sha256 выдаёт 256 бит информации. В Python мы обычно выводим хеш в шестнадцатеричном виде (через hexdigest()), и тогда получается 64 символа.

Нам не обязательно считать биты — важно лишь запомнить:

hexdigest() даёт длинную строку

она выглядит как набор цифр и букв a-f

Практика в Colab: хешируем строку

Эта часть закрепляет то, что уже встречалось раньше, но теперь мы смотрим на это как на основу «отпечатка».

Что здесь важно понять

encode() превращает строку в байты, потому что хеш-функции работают с байтами

hexdigest() превращает результат в удобную строку

длина строки для sha256 обычно равна 64

Хеширование блока: почему нельзя хешировать словарь напрямую

В прошлом уроке блок был словарём dict. Но sha256 не умеет принимать словарь.

Поэтому делаем так:

превращаем данные блока в строку (удобно — в JSON)

хешируем эту строку

Для JSON нам понадобится стандартная библиотека json.

Документация Python: json

Самая частая ошибка: хешировать блок вместе с полем hash

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

Правило проекта:

считаем хеш от данных блока без поля hash

потом записываем результат в block["hash"]

Код: делаем данные блока «хешируемыми»

Ниже — удобный шаблон для «КИБЕРКОИНА». Он делает два шага:

собирает данные, которые должны влиять на хеш

считает хеш от этих данных

Зачем sort_keys=True

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

sort_keys=True фиксирует порядок ключей и делает результат стабильным.

Зачем ensure_ascii=False

Чтобы русские буквы не превращались в набор \u041a\u0418.... В учебном проекте так проще читать данные.

Код: создаём блок и проверяем, что хеш меняется при изменении данных

Что мы ожидаем увидеть:

блоки почти одинаковые

хеши — разные

Именно это свойство помогает блокчейну замечать «подмену истории».

Как хеш связан с упрощённым «майнингом»

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

Пример учебного правила сложности:

хеш должен начинаться с "0000"

Тогда компьютер перебирает nonce:

меняется nonce

меняется JSON-строка

меняется хеш

иногда (редко) хеш совпадает с правилом

Это и будет наш упрощённый «майнинг» в следующих уроках.

!Схема показывает подбор nonce для получения хеша нужного вида

Мини-итог урока

Теперь у нас есть понятное правило для «КИБЕРКОИНА»:

хеш блока считаем через sha256 от JSON-строки

JSON делаем стабильным с sort_keys=True

в хеширование включаем только важные поля блока и не включаем hash

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

Транзакции и кошельки: отправляем и получаем КИБЕРКОИН

Связь с предыдущими уроками

Раньше мы уже сделали самое важное для блокчейна:

придумали структуру блока

научились считать хеш блока

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

Теперь добавим в наш учебный КИБЕРКОИН смысл: переводы монет между людьми. Для этого нам нужны две идеи:

кошелёк (чтобы понимать, кому принадлежат монеты)

транзакция (чтобы записывать переводы)

!Путь транзакции: от кошелька до блока и изменения баланса

Что такое кошелёк в нашем проекте

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

В учебном КИБЕРКОИНЕ мы сделаем проще:

адрес кошелька будет случайной строкой

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

Важно понимать идею:

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

приватный ключ нельзя никому отдавать

Если хочешь почитать про настоящую идею ключей, вот справка:

Публичный ключ

Как мы будем хранить балансы

Чтобы понимать, у кого сколько КИБЕРКОИНов, нам нужна простая таблица:

ключ: адрес кошелька

значение: сколько монет у этого адреса

В Python это удобно хранить в словаре dict:

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

Что такое транзакция

Транзакция в нашем проекте будет словарём с полями:

from — адрес отправителя

to — адрес получателя

amount — сколько монет

timestamp — время

tx_id — уникальный номер транзакции

Пример:

Очередь неподтверждённых транзакций

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

это называется мемпул (от английского mempool)

Правила честных переводов в учебном КИБЕРКОИНЕ

Чтобы не было хаоса, введём простые правила проверки транзакций:

сумма amount должна быть числом больше нуля

адреса from и to должны быть строками

у отправителя должно хватать монет

особое правило: адрес SYSTEM может создавать новые монеты (это наш учебный способ “выпустить” КИБЕРКОИН)

Почему нужен SYSTEM:

иначе мы не сможем выдать первые монеты никому

Практика в Google Colab

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

Код: кошельки, транзакции, мемпул и добавление блока

Что важно заметить после запуска

После первой транзакции от SYSTEM:

у Алисы появляется стартовый баланс

транзакция попадает в блок, и это видно в истории

После второй транзакции:

баланс Алисы уменьшается

баланс Боба увеличивается

И главное:

пока транзакция лежит в pending_transactions, она ещё не в блокчейне

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

Почему мы пока не делаем настоящие подписи

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

цифровые подписи

проверка подписи по публичному ключу

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

Мини-итог урока

Теперь наш КИБЕРКОИН умеет самое “денежное”:

создавать кошельки с адресами

делать транзакции “кто кому сколько”

класть транзакции в мемпул

добавлять блок с транзакциями

обновлять балансы по истории

Следующий логичный шаг для усиления честности: сделать так, чтобы блок нельзя было легко “нарисовать” слишком быстро. Для этого обычно добавляют упрощённый майнинг: подбор nonce, чтобы хеш блока начинался, например, с 0000.

Майнинг и Proof-of-Work: добавляем новые блоки

Зачем нам майнинг в «КИБЕРКОИНЕ»

В прошлых уроках наш «КИБЕРКОИН» уже умеет:

хранить блоки в цепочке

считать хеш блока

записывать транзакции и обновлять балансы

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

Чтобы добавить честное правило, мы вводим майнинг и идею Proof-of-Work.

Что такое Proof-of-Work простыми словами

Proof-of-Work (PoW) переводится как доказательство работы.

Идея такая:

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

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

В Bitcoin это устроено очень серьёзно и энергозатратно. Мы сделаем учебную версию, чтобы понять принцип.

> "Proof-of-work is essentially one-CPU-one-vote." — Satoshi Nakamoto, Bitcoin Whitepaper (Bitcoin: A Peer-to-Peer Electronic Cash System)

Сложность: какое правило должен выполнить майнер

Мы введём простое правило сложности:

хеш блока должен начинаться с нескольких нулей, например с "000"

Чем больше нулей в начале, тем сложнее найти подходящий хеш.

Почему это работает:

хеш выглядит как «случайная» строка

угадать, что он начнётся с "000", трудно

иногда повезёт, но обычно нужно много попыток

!Диаграмма показывает, как перебор nonce помогает найти хеш нужного вида

Nonce: что это такое и зачем

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

Важно:

данные блока почти не меняются

мы меняем только nonce

из-за этого меняется хеш

мы перебираем nonce, пока хеш не станет подходящим

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

Когда майнер говорит: «Я нашёл новый блок!», другие должны легко проверить:

prev_hash совпадает с хешем предыдущего блока

хеш блока действительно считается из данных блока

хеш начинается с нужного префикса сложности (например, "000")

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

Пишем майнинг в Google Colab

Ниже код, который можно вставить в Colab. Он объединяет наши прошлые идеи (блоки, транзакции, мемпул) и добавляет майнинг.

Настройки сложности и награды

Мы добавим две настройки:

DIFFICULTY_PREFIX — правило сложности

MINING_REWARD — награда майнеру (учебное правило)

Совет для Colab:

начни с DIFFICULTY_PREFIX = "000"

если слишком быстро, попробуй "0000"

если слишком медленно, сделай "00"

Полный пример кода

Что здесь происходит шаг за шагом

Мы создаём кандидат-блок из мемпула.

Вставляем в транзакции награду майнеру SYSTEM -> miner.

Запускаем mine_block.

Внутри майнинга меняется nonce и пересчитывается хеш.

Как только хеш начинается с DIFFICULTY_PREFIX, блок считается найденным.

Другие участники могут проверить блок функцией is_block_valid.

Почему это считается «доказательством»

Потому что:

майнеру пришлось потратить время на перебор nonce

любой другой может проверить правильность за один пересчёт хеша

Это и есть главная идея Proof-of-Work.

Что будет, если попытаться подделать старую транзакцию

Если в уже добавленном блоке поменять сумму перевода:

изменятся данные блока

изменится его хеш

блок перестанет проходить проверку сложности или перестанет совпадать с пересчётом

а следующий блок будет ссылаться на старый хеш, и цепочка «сломается»

Полезные ссылки

Документация Python: hashlib

Bitcoin: A Peer-to-Peer Electronic Cash System

Wikipedia: Proof of work

Мини-итог урока

Теперь наш «КИБЕРКОИН» умеет добавлять блоки так, чтобы это требовало работы:

мы ввели nonce и сложность через префикс хеша

написали майнинг (перебор nonce)

добавили проверку блока и всей цепочки

сделали награду майнеру как учебную транзакцию от SYSTEM

Дальше (если развивать проект) обычно добавляют более строгие правила транзакций и способ хранения баланса только через историю блоков.

Тестирование, защита от ошибок и финальная демонстрация

Зачем этот урок, если блоки уже майнятся

Мы уже сделали учебный блокчейн «КИБЕРКОИН»:

есть блоки и цепочка

есть транзакции, мемпул и балансы

есть майнинг (Proof-of-Work) и награда майнеру

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

Устойчивость — это когда:

код не ломается от странных данных

ошибки понятные (а не «ничего не работает»)

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

Что такое тестирование простыми словами

Тестирование — это проверка, что программа работает по правилам.

В нашем проекте это особенно важно, потому что блокчейн — это «журнал», которому должны доверять.

В этом уроке мы сделаем:

проверки (валидацию) транзакций и блоков

понятные сообщения об ошибках

мини-набор тестов

финальную демонстрацию: создаём кошельки, делаем переводы, майним блоки, пробуем «подделку» и убеждаемся, что цепочка это заметит

!Путь данных в КИБЕРКОИНЕ и как проверка ловит подделку

Главные места, где обычно появляются ошибки

Ошибки данных

amount не число

amount меньше или равно нулю

пустой адрес получателя

попытка отправить больше монет, чем есть

Ошибки логики блокчейна

блок ссылается не на тот prev_hash

у блока неправильный hash (данные поменяли)

блок не проходит по сложности (не начинается с нужных нулей)

Ошибки из-за «не того порядка ячеек» в Colab

запустили ячейку с майнингом, но не запустили ячейку с функциями

перезапустили среду и забыли заново создать blockchain, balances, pending_transactions

Правило для проекта в Colab:

если что-то странное происходит, делай Runtime → Restart runtime и запускай ноутбук сверху вниз

Защита от ошибок: три простых техники

Понятные функции проверки

Мы не просто делаем if, а возвращаем:

ok (True/False)

reason (почему не ок)

Так легче понимать, что именно сломалось.

Проверки до действия

Сначала проверяем транзакцию и блок, и только потом:

добавляем транзакцию в мемпул

добавляем блок в цепочку

меняем балансы

Маленькие тесты

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

что плохие транзакции отклоняются

что правильные блоки принимаются

что подделка ломает проверку цепочки

Финальный «КИБЕРКОИН» в одной ячейке: код + тесты + демонстрация

Скопируй код ниже в Google Colab в одну ячейку и запусти.

Что считать успехом после запуска

У тебя должно получиться увидеть:

строку Тесты пройдены!

майнинг двух блоков (будет число попыток и хеш)

изменение балансов Алисы, Боба и Майнера

проверку Цепочка корректна? True OK

после подделки — Цепочка корректна после подделки? False ...

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

Почему подделка ловится проверкой

Когда мы меняем транзакцию в старом блоке:

меняются данные блока

пересчитанный хеш становится другим

функция проверки видит, что hash не совпадает с пересчётом

И цепочка объявляется неправильной.

Как сделать проект ещё аккуратнее (идеи на будущее)

Если продолжать развивать КИБЕРКОИН, обычно добавляют:

подписи транзакций (чтобы точно доказать, кто отправитель)

вычисление баланса только из истории блоков, без отдельного balances

сеть из нескольких «узлов», которые обмениваются блоками

Про подписи можно почитать в справке по криптографии и ключам:

Цифровая подпись

SHA-2

Итог урока

Теперь у тебя есть финальная версия учебного КИБЕРКОИНА, которая:

проверяет транзакции до добавления

проверяет блоки и всю цепочку

умеет находить попытку подделки

запускается как готовая демонстрация в Google Colab