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

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

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

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

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

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

что такое криптовалюта;

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

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

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

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

«Аня отправила 2 монеты Боре»

«Боря отправил 1 монету Диме»

Если журнал хранится на одном компьютере, тот, у кого есть доступ, может:

стереть запись;

подделать запись;

сказать: «а у меня другая версия журнала».

Нужен способ, чтобы журнал был:

общим для всех;

защищённым от тихой подмены;

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

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

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

Блок простыми словами

Блок — это «страница журнала», в которой лежат:

список записей (например, переводов монет);

специальная «контрольная метка» (её часто называют хеш);

ссылка на контрольную метку предыдущего блока.

Главная идея: если кто-то попробует подделать старую страницу, у неё изменится контрольная метка, и цепочка «сломается».

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

Что такое хеш (без сложной математики)

Хеш — это результат работы «цифрового отпечатка пальца» для данных.

У такого отпечатка есть удобные свойства:

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

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

одинаковые данные дают одинаковый отпечаток.

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

Почему блокчейн считается «распределённым»

Распределённая сеть означает, что копия журнала хранится сразу у многих участников (компьютеров).

Это похоже на ситуацию, когда:

у каждого ученика есть копия журнала;

когда появляется новая запись, она рассылается всем;

все проверяют запись по правилам.

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

Кто такие узлы

Узел (по-английски node) — это компьютер или программа, которая хранит копию блокчейна и участвует в его обновлении.

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

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

Обычно транзакция содержит:

кто отправляет;

кому отправляет;

сколько;

доказательство, что отправитель имеет право тратить эти монеты.

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

Что такое криптовалюта

Криптовалюта — это цифровые деньги, где:

переводы записываются в блокчейн;

правила проверки одинаковые для всех;

никто один не может просто так переписать историю.

Криптовалюта обычно отвечает на вопросы:

как появляются новые монеты;

как проверять переводы;

что считается правильной историей.

Откуда берётся «правильная версия» блокчейна

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

Такой способ называют механизм консенсуса — «правило, по которому сеть решает, какая цепочка правильная».

Пример: Proof of Work (идея на пальцах)

Один из известных механизмов — Proof of Work (доказательство работы). Его идея:

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

это делает подделку истории дорогой и сложной;

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

В реальной сети это связано с процессом, который называют майнинг.

> «The proof-of-work also solves the problem of determining representation in majority decision making.» — Satoshi Nakamoto > > Источник: Bitcoin: A Peer-to-Peer Electronic Cash System

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

Чем криптовалюта отличается от банковских денег

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

Важно: криптовалюта — это не «волшебные деньги», а программная система со строгими правилами.

Что мы будем строить в этом курсе

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

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

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

добавим проверку целостности цепочки (чтобы было видно подмену);

сделаем простой механизм «добычи» блока (учебный вариант);

соберём всё в маленький проект «КИБЕРКОИН» в Google Colab.

Главное запомнить

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

Хеш помогает быстро заметить, что данные кто-то поменял.

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

Транзакции — это записи о переводах.

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

Подготовка Google Colab и основы Python для проекта

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

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

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

Что такое Google Colab

Google Colab — это онлайн-тетрадь для кода на Python.

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

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

код запускается прямо в браузере;

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

Официальная справка: Google Colab

!Схема, где в Colab находятся ячейки кода и вывод результата

Создаём тетрадь Colab для «КИБЕРКОИНА»

Открой Colab по ссылке: Google Colab

Нажми File → New notebook (Новый ноутбук).

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

Проверь, что выбран Python (обычно так и есть).

Как работают ячейки в Colab

В Colab есть ячейки двух основных видов:

ячейка кода (там мы пишем Python);

ячейка текста (пояснения, план, заметки).

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

кнопкой Play слева от ячейки;

или клавишами Shift + Enter.

Важно запомнить:

Colab выполняет код сверху вниз.

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

Сохранение и доступ к файлу

Варианты:

сохранить в Google Drive (обычно Colab делает это автоматически, если ты вошёл в аккаунт);

скачать на компьютер через File → Download.

Если что-то пошло не так, полезно знать, где сброс:

Runtime → Restart runtime (перезапуск).

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

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

Переменные и простые типы

int — целое число

float — число с точкой

str — текст

bool — правда/ложь (True или False)

Списки: хранить много элементов

Список — это упорядоченная коллекция.

В «КИБЕРКОИНЕ» список будет хранить транзакции, которые попадут в следующий блок.

Словари: хранить данные по ключам

Словарь — это «ключ → значение».

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

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

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

Циклы: повторяем действия

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

Функции: упаковываем шаги в понятные команды

Функция помогает не повторять один и тот же код.

Мы сделаем функции вроде calculate_hash(...) (посчитать хеш) и is_chain_valid(...) (проверить цепочку).

Импорт библиотек: как подключать готовые инструменты

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

Хеширование: hashlib

Для учебного блокчейна нам нужен хеш. Мы будем использовать SHA-256.

Официальная документация: hashlib — Secure hashes and message digests

Пример:

Разберём по шагам:

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

sha256(...) считает хеш.

hexdigest() делает красивую строку из цифр и букв, чтобы её можно было хранить и показывать.

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

Время и даты: time или datetime

Блоки обычно хранят время создания.

Официальная документация: time — Time access and conversions

Пример:

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

Перевод данных в текст для хеша: json

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

Официальная документация: json — JSON encoder and decoder

Зачем тут параметры:

ensure_ascii=False — чтобы русские буквы не превращались в странные коды.

sort_keys=True — чтобы ключи шли в одном и том же порядке (это важно для стабильного хеша).

Стиль работы в этом курсе: как вести проект аккуратно

Чтобы «КИБЕРКОИН» был понятным:

подписывай ячейки текста: что делает следующий кусок кода;

давай переменным ясные имена (transactions, previous_hash, timestamp);

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

Мини-подготовка к следующим урокам

Скоро мы начнём собирать структуру блоков и цепочки. Тебе пригодится понимание:

список транзакций (списки и словари);

«цифровой отпечаток» (хеш через hashlib);

одинаковый способ превращать данные в строку (json.dumps).

В следующей статье мы начнём писать первые классы и создадим самый первый (нулевой) блок — «генезис-блок» для учебной цепочки.

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

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

В прошлых статьях мы узнали:

блокчейн — это цепочка блоков, где каждый новый блок ссылается на предыдущий;

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

в Google Colab удобно писать и запускать Python-код для проекта «КИБЕРКОИН».

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

!Схема показывает, какие поля есть у блока и как блоки связываются в цепочку.

Что такое хеширование в нашем проекте

Хеширование — это процесс, когда мы берём данные (например, текст) и получаем из них длинную строку из букв и цифр — хеш.

В «КИБЕРКОИНЕ» хеш нужен, чтобы:

заметить, если кто-то поменял данные внутри блока;

связать блоки в цепочку через previous_hash.

Мы будем использовать алгоритм SHA-256 из стандартной библиотеки Python hashlib.

Документация Python: hashlib — Secure hashes and message digests

Главное правило про хеш

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

изменили данные хоть чуть-чуть → хеш станет совсем другим.

Почему нельзя хешировать словарь «как попало»

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

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

Документация Python: json — JSON encoder and decoder

Идея такая:

берём данные блока;

превращаем в JSON-строку одинаковым способом (sort_keys=True);

кодируем в байты (encode("utf-8"));

считаем SHA-256.

Пишем функцию вычисления хеша

Открой Google Colab (наш файл, например KIBERCOIN.ipynb) и создай ячейку с кодом.

Обрати внимание:

sort_keys=True нужен, чтобы ключи всегда шли в одном порядке;

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

мы убираем поле hash, если оно есть, чтобы не получился «хеш самого себя».

Из чего состоит блок в «КИБЕРКОИНЕ»

Сделаем простую структуру блока (учебную, но похожую на настоящую):

index — номер блока (0, 1, 2, ...)

timestamp — время создания (число)

transactions — список транзакций (каждая — словарь)

previous_hash — хеш прошлого блока

hash — хеш текущего блока

Создаём класс Block

Теперь упакуем всё в класс. Так будет удобно создавать блоки и хранить логику вместе.

Документация Python про время: time — Time access and conversions

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

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

Сделаем простой генезис-блок для «КИБЕРКОИНА»:

Важно: в нашем учебном проекте transactions — это просто данные. Позже мы добавим правила: кто имеет право отправлять монеты и как проверять переводы.

Эксперимент: как хеш «ловит» подмену

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

Если всё сделано правильно, ты увидишь, что хеши разные.

Что мы сделали и что будет дальше

Теперь у нас есть основа:

мы умеем вычислять хеш данных через SHA-256;

мы описали, из каких полей состоит блок;

мы сделали класс Block, который хранит данные и считает хеш;

мы создали генезис-блок.

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

Цепочка блоков: связываем блоки и проверяем целостность

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

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

Теперь соберём из кирпичиков настоящую цепочку: научимся:

хранить блоки в правильном порядке;

добавлять новый блок так, чтобы он ссылался на прошлый;

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

!Схема, как блоки связаны через previous_hash

Зачем вообще нужна цепочка

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

Эта ссылка и делает подмену заметной:

изменил кто-то старую страницу → меняется её хеш;

следующий блок всё ещё хранит старый previous_hash → цепочка становится некорректной.

Правило связи блоков

Мы будем использовать простое правило:

у нового блока поле previous_hash должно быть равно hash предыдущего блока.

То есть:

chain[i].previous_hash == chain[i-1].hash

Если это не так — цепочка сломана.

Что значит проверить целостность

Мы проверим сразу две важные вещи:

Честность блока: его hash действительно соответствует его данным.

- Мы пересчитаем хеш заново и сравним с тем, что записано в блоке.

Связь блоков: у каждого блока (кроме первого) previous_hash совпадает с hash прошлого блока.

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

Пишем класс Blockchain

Ниже код, который можно вставить в одну ячейку Google Colab. Он включает и Block, и Blockchain, чтобы было удобнее запускать с нуля.

Почему мы копируем transactions

Списки и словари в Python можно изменить после создания блока. Если не сделать копию, может получиться так:

блок уже создан, hash уже записан;

кто-то поменял список транзакций в этом блоке;

данные блока изменились, но hash остался старым.

Это не ломает блокчейн (проверка как раз поймает подмену), но может запутать при экспериментах. Поэтому мы делаем копию через json.

Создаём цепочку и добавляем блоки

Теперь проверим, что всё работает.

Если всё правильно, в конце будет Цепочка валидна? True.

Эксперимент: ловим подмену

Представим, что кто-то попытался поменять старую транзакцию: например, вместо 2 монет сделать 200.

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

данные блока изменились;

current.calculate_hash() пересчитает новый хеш;

а current.hash хранит старый хеш, который был при создании.

Эксперимент: даже если пересчитать хеш, цепочка всё равно сломана

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

Проверка всё равно должна вернуть False, потому что:

блок 2 хранит previous_hash, который равен старому хешу блока 1;

а мы только что сделали у блока 1 новый hash;

значит связь previous_hash == hash между блоками 1 и 2 больше не совпадает.

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

Главное запомнить

Blockchain (цепочка) — это список блоков в правильном порядке.

previous_hash — это ссылка на прошлый блок, она связывает цепочку.

Проверка целостности обычно включает:

- пересчёт хеша каждого блока; - проверку, что previous_hash совпадает с hash прошлого блока.

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

Что будет дальше

Мы уже умеем:

создавать блоки;

связывать их в цепочку;

проверять, что никто не подменил историю.

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

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

Связь с прошлой темой

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

сделали класс Block (блок хранит данные и свой хеш)

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

Но пока в блоках лежали просто словари с переводами, и у нас не было ответа на важный вопрос:

кто именно отправляет монеты?

как понять, сколько монет у каждого?

как добавить перевод так, чтобы он был “правильным”?

В этой статье мы добавим две идеи для учебного «КИБЕРКОИНА»:

кошелёк (это “имя” или “адрес” участника)

транзакция (это запись “кто кому и сколько отправил”)

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

!Как перевод монет превращается в запись в блоке

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

Кошелёк в «КИБЕРКОИНЕ» будет очень простым:

у каждого участника есть адрес кошелька (строка)

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

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

адрес это как никнейм, только лучше делать его уникальным

Делаем адрес кошелька в Google Colab

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

Документация Python: secrets — Generate secure random numbers for managing secrets

Мы добавили prefix, чтобы в выводе было легче отличать участников. В настоящих сетях обычно нет “имён”, только адрес.

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

Транзакция — это запись в стиле:

отправитель

получатель

сумма

В нашем учебном формате транзакция будет словарём dict.

Минимальный формат транзакции

Вот простой и понятный вариант:

Добавим метку времени и идентификатор транзакции

Чтобы транзакции было проще отличать, добавим:

timestamp — когда транзакция создана

tx_id — хеш транзакции (как “номер”)

Почему мы делаем tx_id через хеш:

одинаковая транзакция даст одинаковый tx_id

если кто-то поменяет сумму или получателя, tx_id станет другим

Откуда берутся монеты и что такое баланс

Вопрос, без которого криптовалюта не работает:

если Аня отправляет 2 монеты, как понять, что они у неё есть?

Для этого вводят понятие баланс.

Баланс кошелька — это сколько монет сейчас принадлежит этому адресу.

Как мы посчитаем баланс в учебном «КИБЕРКОИНЕ»

Самый понятный учебный способ:

берём весь блокчейн

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

считаем:

- если адрес получал монеты, прибавляем - если адрес отправлял монеты, вычитаем

Это похоже на выписку по карте:

входящие операции увеличивают баланс

исходящие операции уменьшают баланс

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

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

Сейчас наша цепочка умеет добавлять блоки сразу через add_block(transactions). Но в жизни обычно так:

сначала транзакции “ожидают” добавления в блок

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

Мы сделаем список ожидающих транзакций:

pending_transactions

Код: Blockchain с кошельками, балансом и ожидающими транзакциями

Ниже код одной ячейкой. Он включает:

Block как раньше

Blockchain с методами:

- add_transaction(...) - get_balance(address) - mine_pending_transactions(...) (у нас это будет просто “создать новый блок”, без настоящего майнинга)

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

Сделаем учебный сценарий:

система начисляет Ане 10 монет

Аня отправляет Боре 3 монеты

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

смотрим балансы

Что важно заметить

монеты “появились” только потому, что мы разрешили SYSTEM создавать монеты

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

баланс считается по истории в блоках, а не хранится в одном месте как “переменная в базе”

Частая ошибка: транзакции ещё не в блоке

Если транзакция добавлена через add_transaction, она попадает в pending_transactions и ещё не влияет на баланс, потому что балансы мы считаем по блокам.

Чтобы транзакция стала частью истории:

нужно вызвать mine_pending_transactions()

Это похоже на ситуацию:

вы написали перевод в черновик

но он станет “официальной записью” только когда попадёт на страницу журнала (в блок)

Главное запомнить

Кошелёк в нашем проекте это адрес (строка), по которому мы понимаем, кто участвует в переводе.

Транзакция это словарь с полями from, to, amount и полезными добавками timestamp, tx_id.

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

Транзакции удобнее сначала копить в pending_transactions, а потом добавлять в блок.

Что будет дальше

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

если кто-то узнает адрес Ани, он может “притвориться Аней” и создать транзакцию от её имени

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

Майнинг и Proof-of-Work: добываем монеты честно

Связь с прошлыми темами

Раньше мы уже сделали важные части «КИБЕРКОИНА»:

блоки с хешем (цифровым отпечатком)

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

транзакции, кошельки и баланс

Но у нашей учебной цепочки всё ещё есть слабое место.

Если злоумышленник поменяет старый блок, он может:

пересчитать хеш этого блока

пересчитать хеши всех следующих блоков

И тогда простая проверка «ссылки совпали» снова станет истинной.

Чтобы сделать подделку дорогой по времени, в реальных криптовалютах используют Proof-of-Work (PoW), то есть доказательство работы.

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

Proof-of-Work — это правило:

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

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

Это похоже на задачу:

решить сложную головоломку (много попыток)

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

Идею PoW популярно описывает оригинальная статья про Bitcoin:

> “The proof-of-work also solves the problem of determining representation in majority decision making.” — Satoshi Nakamoto (Bitcoin: A Peer-to-Peer Electronic Cash System)

Что такое «майнинг» в нашем проекте

Майнинг — это процесс создания нового блока, который проходит проверку Proof-of-Work.

Майнер (программа-участник) делает две вещи:

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

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

А ещё майнер обычно получает награду (новые монеты). В «КИБЕРКОИНЕ» мы сделаем это учебно.

!Перебор nonce для получения хеша с нужным количеством нулей

Главная идея PoW: подбор nonce

Мы добавим в блок поле nonce.

Nonce — это число, которое мы можем менять, чтобы менять хеш блока, не изменяя транзакции.

Дальше вводим условие (учебное):

хеш блока должен начинаться с нескольких нулей

Пример:

сложность 2: хеш начинается с 00

сложность 4: хеш начинается с 0000

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

Что такое сложность (difficulty)

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

маленькая сложность (например, 2) находится быстро

большая сложность (например, 5–6) может быть очень медленной, особенно в Google Colab

В нашем курсе мы будем использовать небольшие значения (обычно 3 или 4), чтобы всё успевало считаться.

Обновляем блок: добавляем nonce

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

Пишем Proof-of-Work: ищем nonce

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

мы начинаем с nonce = 0

пересчитываем хеш

если условие не выполнено, увеличиваем nonce и пробуем снова

Почему это похоже на «работу»:

заранее неизвестно, какой nonce подойдёт

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

но проверка очень простая: просто посмотреть на начало хеша

Добавляем майнинг в Blockchain

Мы обновим блокчейн так, чтобы он умел:

хранить pending_transactions

добывать (майнить) новый блок с PoW

выдавать награду майнеру

Важно: награда — это специальная транзакция от SYSTEM.

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

hashlib — Secure hashes and message digests

json — JSON encoder and decoder

time — Time access and conversions

Пример: майним блоки и смотрим балансы

Запусти следующий код после ячейки с классами.

Что должно быть видно:

после каждого майнинга у майнера растёт баланс на mining_reward

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

is_chain_valid() возвращает True, если никто не трогал историю

Почему PoW мешает подделке истории

Без Proof-of-Work злоумышленник мог бы быстро:

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

пересчитать хеши дальше

С Proof-of-Work ему придётся:

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

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

То есть подделка превращается в очень долгую работу.

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

Главное запомнить

Proof-of-Work заставляет «платить временем», чтобы добавить блок.

Nonce — число, которое мы меняем, чтобы найти подходящий хеш.

Сложность — сколько нулей должно быть в начале хеша.

Награда майнеру — способ выпускать новые монеты (в учебном виде).

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

Что дальше

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

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

Тестирование, улучшения и презентация проекта

Зачем это занятие

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

блоки с хешем

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

транзакции, кошельки и баланс

майнинг с Proof-of-Work и наградой майнеру

Теперь важно сделать две вещи, которые отличают просто код от проекта:

протестировать: убедиться, что всё работает и ошибки ловятся

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

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

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

Тестирование — это когда мы заранее придумываем ситуации и проверяем, что программа:

делает правильные вещи, когда всё нормально

не даёт сделать неправильные вещи, когда кто-то пытается нарушить правила

В нашем проекте это особенно важно, потому что блокчейн — это система правил.

Какие бывают тесты в нашем проекте

Позитивные тесты: всё честно, цепочка валидна, баланс считается верно

Негативные тесты: попытка подделки, перевод без денег, сумма 0, перевод самому себе

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

Быстрые проверки через assert

assert — это простая команда в Python: если условие неверно, остановись и покажи ошибку. Для проекта в Colab это удобный первый шаг.

Пример: создаём блокчейн, майним, проверяем важные правила.

Тесты на ошибки: проверяем, что правила нельзя обойти

Тест: нельзя отправить больше, чем есть

Мы ожидаем, что код выдаст ошибку ValueError.

Тест: подделка транзакции должна ломать валидность

Аккуратные тесты через unittest (по желанию)

Если хочется как у взрослых разработчиков, в Python есть встроенная библиотека unittest.

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

Плюс unittest в том, что он собирает много тестов и показывает отчёт.

Если unittest кажется сложным, это нормально. Для школьного проекта достаточно assert и try/except.

План тестирования: что обязательно проверить

| Что проверяем | Пример ситуации | Ожидаемое поведение | |---|---|---| | Создание блока | Добыли блок | Хеш начинается с нужных нулей | | Связь блоков | Есть 3 блока | previous_hash каждого совпадает с hash прошлого | | Подделка | Изменили транзакцию в старом блоке | is_chain_valid() становится False | | Баланс | Начисление и перевод | Балансы совпадают с историей | | Ошибки ввода | amount <= 0, перевод самому себе | Должна быть ошибка | | Нехватка денег | Отправка больше баланса | Должна быть ошибка |

Улучшения проекта: делаем код удобнее

Улучшение: метод для красивого просмотра цепочки

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

Улучшение: вынос настроек в одно место

Чтобы проект было проще объяснять, удобно держать настройки рядом.

Улучшение: экспорт цепочки в JSON

Так можно сохранить историю и показать её другим.

Если оператор | не работает в твоём Python, замени на простой вариант.

Улучшение: поясняющие текстовые ячейки в Colab

Чтобы проект выглядел как мини-учебник:

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

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

подпиши, какую ячейку запускать первой

Презентация проекта: как показать «КИБЕРКОИН» за 3–5 минут

Структура короткой защиты

Идея: “Это учебная криптовалюта, где всё записывается в блоки”

Блок: какие поля есть у блока, зачем нужен хеш

Цепочка: как previous_hash связывает историю

Транзакции и баланс: как мы считаем, кто сколько имеет

Proof-of-Work: зачем нужен nonce и “нули” в хеше

Тест: показываем, что подделка ломает валидность

Демо-сценарий, который можно запустить при зрителях

Создать адреса ANYA, BORYA, MINER

Начислить Ане монеты через SYSTEM

Намайнить блок и показать награду майнеру

Сделать перевод от Ани к Боре

Намайнить второй блок

Вывести балансы

Подделать старую транзакцию и показать is_chain_valid() == False

Как поделиться проектом

в Colab нажми Share и выбери доступ по ссылке

можно скачать ноутбук через File → Download → .ipynb

Справка по работе с Colab:

FAQ Google Colab

Главное запомнить

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

Для школьного проекта достаточно assert и тестов с try/except.

Улучшения делают код понятным: просмотр цепочки, настройки в одном месте, экспорт истории.

Хорошая презентация показывает не все строчки кода, а ключевые идеи и один яркий эксперимент с подделкой.