Абилимпикс Башкортостан 2026

Блокчейн-технологии (Р)

Категории: школьник · студент · специалист Официальная страница компетенции

Задания ниже — официальные файлы «Абилимпикс» (источник: abilympics-russia.ru), разложенные по категориям. Решения написаны по тексту задания, регламенту и критериям оценки; в них указано, что именно проверяет эксперт.

Школьник

14–16 лет, базовый уровень задания
Конкурсное задание · ШкольникPDF · 731 КБ

Выдержка из официального конкурсного задания: страницы, относящиеся к категории «Школьник» (стр. 5–11 источника).

Пошаговое решение

Три модуля за три часа: час на аналитику чужого контракта (46 баллов из 100), полтора часа на собственный контракт «Безопасное дорожное движение» (36 баллов) и полчаса на видео с демонстрацией (18 баллов). Модуль А — самый дорогой и самый недооценённый: вам дают код на 86 строк, в котором нужно найти ошибки трёх уровней и написать по ним семь отдельных отчётов, и половину баллов ставят не за исправления, а за то, что каждое исправление описано с номером строки и причиной. Модуль Б — контракт с двумя ролями, семью удостоверениями из табл. 1 и штрафом 10 eth, который в первые пять дней стоит 5 eth, причём один день равен пяти секундам реального времени. Модуль В — видеозахват экрана по таблице из 18 действий и таблица адресов. Идите строго по модулям: в модуле Б вы переиспользуете то, что нашли в модуле А, а на видео попадает только то, что реально работает.

Схема к заданию

Задача 1. Разобрать и починить чужой контрактМодуль А · 46 баллов

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

Схема: Задача 1. Разобрать и починить чужой контракт

Действие 1.1. Развернуть рабочее место и зафиксировать исходник

Шаг 1.1.1

Делаем

Открываем remix.ethereum.org в Firefox или Chrome, в панели File Explorer создаём новый файл Contract.sol и вставляем код из конкурсного задания целиком — с первой строки pragma и до закрывающей скобки на 86-й строке, ничего не переформатируя. Сразу сохраняем вторую копию под именем Contract_original.sol: через час вы уже не восстановите, что стояло в строке 15 до правки, а сверять отчёт придётся с исходником. Рядом заводим четыре текстовых файла: report_syntax.txt, report_logic.txt, report_security.txt и test_notes.txt.

Зачем

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

Как проверить

В File Explorer видно два файла — Contract_original.sol и Contract.sol — и четыре отчёта. Откройте исходник и сверьте нумерацию с КЗ: строка 8 — mapping(string >> address), строка 23 — adr_to.transfering(...), строка 84 — status = false. Если номера съехали, редактор склеил пустые строки.

Типичная ошибка

Скопировать код без сохранения исходника: уже на второй правке вы не помните, что было в строке 38, и отчёт пишется «по смыслу». Вторая ошибка — вести все отчёты в одном файле вперемешку: потом невозможно отделить синтаксис от логики, а КЗ требует семь разных отчётов, и каждый оценивается отдельно.

Что видит эксперт

Эксперт открывает папку участника в начале оценивания и сверяет наличие отчётов с перечнем из КЗ: семь пунктов — семь файлов. Отсутствие отчёта не компенсируется исправленным кодом, даже если контракт работает.

Шаг 1.1.2

Делаем

Нажимаем Compile в панели Solidity Compiler и переносим в report_syntax.txt список ошибок как есть: номер строки, код ошибки (ParserError, TypeError, DeclarationError), текст. Это базовая линия — то, от чего вы будете отчитываться. В таблицу сразу добавляем колонку «что сделано», но пока оставляем её пустой: заполнять будете по мере правок, чтобы не потерять ни одной строки из первичного списка.

Зачем

Первичный список ошибок — это готовый каркас отчёта по синтаксису, и он экономит минут десять из шестидесяти: компилятор уже назвал строки, вам остаётся объяснить причину и решение. Кроме того, он показывает масштаб: если в списке 20 ошибок, а вы нашли 12, значит часть правок вводит новые, и это надо увидеть до деплоя.

Как проверить

В report_syntax.txt не меньше десяти строк, и каждая ссылается на конкретный номер. После каждой правки вы снова нажимаете Compile и вычёркиваете исчезнувшие ошибки: так видно, что ни одна не «сменила адрес», а действительно исчезла.

Типичная ошибка

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

Что видит эксперт

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

Шаг 1.1.3

Делаем

Переключаем Environment на Remix VM или Injected Provider с Ganache и записываем в test_notes.txt адреса первых шести аккаунтов вместе с их балансами. Эти шесть адресов — банк, ДПС и четыре водителя из будущего модуля Б, и они же понадобятся для тестов create_user, participate и finish: на одном аккаунте нельзя проверить ни взнос, ни возврат. Баланс фиксируем до деплоя, чтобы потом отличать изменение от исходного.

Зачем

Тесты без нескольких аккаунтов физически не проходят: participate вызывается с одного адреса, finish — с другого, а проверка повторной регистрации требует третьего. Если записать адреса заранее, вы не будете в середине теста искать, с какого аккаунта что вызывали, — а на 60 минут модуля такие поиски стоят дороже, чем кажется.

Как проверить

В test_notes.txt шесть адресов по 40 hex-символов и шесть балансов. В Remix в поле Account список переключается без ошибок, а баланс каждого аккаунта больше нуля: на нулевом балансе не пройдёт ни один payable-вызов.

Типичная ошибка

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

Что видит эксперт

Наблюдает, как участник переключает аккаунты в Remix: путаница с адресами видна сразу и стоит времени, которого в модуле А нет. Отдельно отмечает, есть ли у участника заготовленный список аккаунтов.

Действие 1.2. Исправить синтаксис до чистой компиляции

Шаг 1.2.1

Делаем

Меняем первую строку: вместо pragma solidity >0.5.0; пишем pragma solidity 0.8.0;, потому что КЗ прямо указывает компилятор версии 0.8.0, а открытый диапазон >0.5.0 соберётся и на 0.6, и на 0.7 с другими правилами арифметики. Затем правим строку 10: address root = msg.sender; — в 0.8 обращение к msg.sender в инициализаторе переменной состояния запрещено, поэтому объявляем address public root; и присваиваем значение в конструкторе: constructor() { root = msg.sender; }.

Зачем

Версия в pragma — не формальность: на 0.8 арифметика проверяется на переполнение, а явное приведение payable(address) стало обязательным. Если оставить открытый диапазон, Remix может подставить 0.7.x, и часть ваших же правок перестанет собираться, а вы потратите время на поиск несуществующей проблемы. Строка 10 относится к ошибкам, которые блокируют деплой, то есть весь остаток модуля.

Как проверить

В панели Solidity Compiler выбран 0.8.0, в списке ошибок строки 10 больше нет. В файле ровно один address root, конструктор стоит внутри contract Contract, а не снаружи, и компилятор не ругается на «Variable declaration not allowed here».

Типичная ошибка

Удалить root вместо переноса в конструктор: код соберётся, но в отчёте по функционалу нечего сказать про владельца, а в отчёте по ИБ вы пропустите главную претензию — переменная объявлена и нигде не используется для ограничения доступа. Вторая ошибка — оставить >0.5.0 и удивляться, что payable(...).transfer не собирается.

Что видит эксперт

Смотрит на версию компилятора в момент деплоя: несовпадение с 0.8.0 из КЗ отмечается отдельно, потому что от него зависит поведение всего остального кода.

Шаг 1.2.2

Делаем

Правим три строки подряд. В строках 8 и 9 двойной знак «больше» заменяем на стрелку: mapping(string => address) public logins; и mapping(address => User) public users;. В строке 14 обращаемся к маппингу по его имени: logins[login] = msg.sender;, а не login[login]. В строке 15 приводим порядок аргументов к объявлению структуры User, где сначала balance, потом login: users[msg.sender] = User(msg.sender.balance, login);.

Зачем

Это самый дешёвый блок исправлений по соотношению «время — баллы»: четыре правки за две минуты, и каждая попадает в отчёт по синтаксису с точной строкой. Ошибка в строке 15 вдобавок логическая: в поле balance уезжает строка ФИО, а компилятор 0.8 такое не пропустит, потому что string в uint не приводится даже неявно.

Как проверить

После компиляции нет ошибок ParserError на строках 8 и 9 и TypeError на строках 14 и 15. Наведите курсор на logins и users: всплывающая подсказка показывает типы mapping(string => address) и mapping(address => User) — значит, объявление прочитано правильно.

Типичная ошибка

Заменить >> на => только в одном маппинге: вторая ошибка остаётся и валит весь контракт, а сообщение указывает на уже найденную строку — вы теряете время на повторный поиск. Вторая ошибка — оставить User(FIO, msg.sender.balance, login) из трёх аргументов: в структуре два поля, компилятор выдаст «Too many arguments».

Что видит эксперт

Проверяет, что в отчёте по синтаксису строка 14 объяснена как обращение к маппингу, а не как «опечатка»: разница между опечаткой и неверным именем переменной — это разница между заучиванием и пониманием.

Шаг 1.2.3

Делаем

В строке 23 у функции transfering нет ни в одном стандарте Solidity: заменяем на adr_to.transfer(msg.value); — переводим сумму, приложенную к вызову, а не адрес отправителя. В строке 38 объявление Donation donation; превращаем в массив Donation[] public donation;, иначе не скомпилируются donation.push и donation.length. В строках 41 и 42 вместо неинициализированных address[] memory sender; и uint value; пишем address[] memory sender = new address[](0); и uint[] memory value = new uint[](0); — тип второго обязан быть массивом, как в структуре.

Зачем

Три правки закрывают три разных класса ошибок: несуществующий метод, обращение к push у не-массива и несовпадение типа при вызове конструктора структуры. Без массива donation весь блок сборов не работает, а это половина функционала контракта — то есть половина отчёта по функционалу и половина демонстрации.

Как проверить

Компилятор не выдаёт «Member transfering not found», «Member push not found» и «Invalid type for argument in function call». После деплоя у donation в панели Deployed Contracts есть кнопка с индексом — признак массива, а не одиночной структуры.

Типичная ошибка

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

Что видит эксперт

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

Шаг 1.2.4

Делаем

В строке 60 у функции стоит return(uint) — правильное ключевое слово returns, поэтому пишем function get_donation_number() public view returns (uint). В строке 61 длина массива в Solidity называется length, а не len: return donation.length;. В строке 57 возвращаем поле info вместо несуществующего data: donation[donation_id].info — третьим элементом кортежа. После этих трёх правок снова нажимаем Compile и добиваемся зелёной галочки.

Зачем

Пока контракт не компилируется, его нельзя ни задеплоить, ни покрыть тестами, а без деплоя не выполняется третий пункт модуля А — публикация контракта в сети. Зелёная компиляция — это точка, после которой начинается работа, приносящая баллы, и затягивать до неё нельзя: на весь модуль 60 минут.

Как проверить

В панели компилятора зелёная галочка и надпись compilation successful, в предупреждениях нет упоминаний несуществующих членов структур. Функция get_donation_number видна в списке и помечена как view returns uint256.

Типичная ошибка

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

Что видит эксперт

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

Действие 1.3. Собрать отчёты по синтаксису, функционалу и проверкам

Шаг 1.3.1

Делаем

Собираем report_syntax.txt таблицей из четырёх колонок: номер строки, фрагмент «было», фрагмент «стало», причина. В таблицу идут все правки из действий 1.2 — строки 1, 8, 9, 10, 14, 15, 23, 38, 41, 42, 57, 60, 61. Причину пишем механизмом, а не оценкой: у строки 8 — «оператор маппинга в Solidity это =>, а >> означает побитовый сдвиг»; у строки 10 — «msg.sender недоступен в инициализаторе переменной состояния, значение задаётся в конструкторе».

Зачем

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

Как проверить

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

Типичная ошибка

Написать «исправлены синтаксические ошибки в маппингах» без номеров строк: такой отчёт не принимается, потому что КЗ требует привязку к строке. Вторая ошибка — указать строку 13 вместо 14 для logins[login], сдвинув нумерацию из-за пустых строк и потеряв весь список.

Что видит эксперт

Читает отчёт по синтаксису первым и сверяет три-четыре строки наугад с кодом. Если хоть одна не совпадает, он проверяет остальные внимательнее — и это отнимает баллы за аккуратность.

Шаг 1.3.2

Делаем

Описываем каждую функцию в порядке появления в файле, по одной-две фразы: create_user — регистрация по логину с проверкой уникальности; get_balance — чтение баланса из структуры; send_money — перевод приложенной суммы на указанный адрес; ask_to_donate — создание сбора с целью, дедлайном и описанием; participate — взнос в сбор; три get-функции — чтение карточки сбора, списков участников и сумм; get_total — сумма взносов; finish — закрытие сбора и распределение денег. Отдельной строкой отмечаем, что FIO в create_user принимается, но никуда не сохраняется.

Зачем

Функционал — второй отчёт из перечня, и он проверяет, понимаете ли вы код, который починили. Здесь же удобно зафиксировать расхождение между названием параметра и его судьбой: именно такие наблюдения отличают разбор от пересказа, а баллы за отчёт идут в те же 46 модуля А.

Как проверить

В отчёте ровно десять функций — столько же, сколько в контракте; сверьте по списку в Deployed Contracts. У каждой указано, меняет ли она состояние (public, public payable) или только читает (view), и нет ли функции, которую вы описали дважды под разными именами.

Типичная ошибка

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

Что видит эксперт

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

Шаг 1.3.3

Делаем

Находим в коде пять мест с заглушкой из подчёркиваний — строки 13, 47, 48, 73, 74 — и предлагаем текст для каждого. Строка 13: «Логин уже зарегистрирован». Строка 47: «Сбор уже закрыт». Строка 48: «Взнос должен быть больше нуля». Строка 73: «Закрыть сбор может только его создатель». Строка 74: «Сбор уже закрыт». Формулировки держим короче 40 символов, потому что каждая строка сообщения попадает в байткод и хранится в блокчейне навсегда.

Зачем

Отчёт по проверкам — отдельный пункт КЗ, и он показывает, понимаете ли вы, что именно проверяет require. Сообщение должно объяснять причину отказа пользователю, а не констатировать факт: «Сбор уже закрыт» говорит и о том, что дальше делать нечего, а «Ошибка» не говорит ничего. Длина важна и технически: длинные строки дороже в газе, и это же замечание пригодится в отчёте по оптимизации.

Как проверить

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

Типичная ошибка

Оставить заглушки или вписать одинаковый текст во все пять require: пользователь не поймёт, что не так, а эксперт увидит, что проверки не осмыслены. Вторая ошибка — написать сообщение длиной в две строки: лишний газ и лишний повод для замечания в отчёте по оптимизации.

Что видит эксперт

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

Действие 1.4. Найти логические ошибки, которые компилятор не видит

Шаг 1.4.1

Делаем

Открываем строку 67: там total = donation[donation_id].value[i]; — на каждом проходе цикла сумма заменяется последним взносом вместо накопления. Меняем на total += donation[donation_id].value[i];. Затем проверяем функцию на числах: три взноса по 2, 3 и 5 eth должны дать 10 eth, а не 5. Результат обязательно смотрим в Remix, а не в голове: get_total отдаёт wei, и в консоли должно быть 10000000000000000000.

Зачем

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

Как проверить

На чистом контракте создайте сбор с целью 10 eth, внесите 2, 3 и 5 eth с трёх аккаунтов и вызовите get_total(0): возвращается 10 eth в wei. До правки вернулось бы 5 eth — это легко воспроизвести на копии исходника и показать в отчёте.

Типичная ошибка

Поменять = на +=, но объявить total внутри цикла: сумма обнуляется на каждом проходе, и результат остаётся неверным при внешне правильной записи. Вторая ошибка — записать в отчёт «исправлено», не проверив число: на защите первый же вопрос про сумму вскроет, что проверки не было.

Что видит эксперт

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

Шаг 1.4.2

Делаем

В строке 76 условие if (total ** 2 >= donation[donation_id].amount) сравнивает с целью квадрат суммы — при взносах больше 3 eth сбор закрывается досрочно. Меняем на total >= amount. В строке 80 цикл возврата написан с обратным условием for (uint i = 0; i > value.length; i++), он не выполнится ни разу: ставим i <. В строке 84 статус после закрытия выставляется в false — меняем на true, иначе сбор закрывается повторно и деньги забираются дважды.

Зачем

Три ошибки в одной функции дают три разных последствия: квадрат ломает порог, обратное условие оставляет участников без возврата, а status = false открывает повторный вызов finish. Вместе они превращают функцию в способ вывести деньги из контракта, и в отчёте по логике это главный пункт — внутри модуля А он весит больше остальных.

Как проверить

Создайте сбор с целью 10 eth, внесите 3 eth, вызовите finish с аккаунта создателя: деньги возвращаются участнику, а status становится true. Повторный вызов finish падает с вашим сообщением «Сбор уже закрыт», и баланс не меняется.

Типичная ошибка

Оставить status = false и не проверить повторный вызов: контракт выглядит рабочим, но второй finish опустошает баланс — на демонстрации это провал модуля, а не минус балл. Вторая ошибка — исправить знак в цикле, но не поменять сравнение: цикл пойдёт, но распределит деньги не тем.

Что видит эксперт

Прогоняет finish дважды подряд при проверке: повторный успешный вызов — самый очевидный признак того, что ошибку со статусом не нашли. Второй вопрос — про возврат денег участникам при недостигнутой цели: он смотрит, открывали ли вы ветку else вообще.

Шаг 1.4.3

Делаем

Проходим по остальным функциям и фиксируем то, что не ломает компиляцию: create_user не проверяет пустой логин и не сохраняет ФИО; ask_to_donate принимает дедлайн в прошлом; participate не сверяет текущее время с дедлайном; finish не проверяет, что дедлайн уже прошёл. В отчёте по логике на каждую ошибку пишем строку, последствие и предложение — например, добавить require(bytes(login).length > 0) и сравнение block.timestamp с deadline в participate и finish.

Зачем

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

Как проверить

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

Типичная ошибка

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

Что видит эксперт

Читает отчёт по логике целиком и проверяет, что предложения не противоречат запрету менять структуры. Одно такое предложение ставит под сомнение весь отчёт.

Действие 1.5. Написать отчёты по информационной безопасности и оптимизации

Шаг 1.5.1

Делаем

В report_security.txt разбираем способ отправки денег: transfer даёт получателю 2300 газа и на 0.8 падает, если получатель — контракт с более тяжёлым fallback. Предлагаем call с проверкой результата: (bool ok, ) = payable(addr).call{value: amount}(пустые данные); require(ok, «Перевод не выполнен»);. Отдельным пунктом — порядок операций: в finish статус меняется после перевода, поэтому получатель может вызвать finish повторно из своего fallback.

Зачем

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

Как проверить

В отчёте есть три вещи: чем плох transfer, как выглядит безопасный call с проверкой ok и почему смена статуса должна идти до перевода. Формулировка проверяемая: по вашему тексту другой человек может внести правку в код, не задавая вопросов.

Типичная ошибка

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

Что видит эксперт

Задаёт вопрос про transfer и call почти всегда: ответ показывает, читал ли участник документацию 0.8 или повторял заученную фразу про безопасность. Дальше он спрашивает про порядок операций в finish, и этот ответ отличает тех, кто понял reentrancy, от тех, кто выучил слово.

Шаг 1.5.2

Делаем

Дописываем в тот же отчёт четыре пункта: переменная root объявлена, но нигде не используется, поэтому любую функцию может вызвать любой; donation_id не проверяется на существование, и обращение к несуществующему индексу даёт revert без сообщения; в цикле get_total нет ограничения на число участников, поэтому сбор с тысячей взносов не прочитается за разумный газ; события не эмитятся ни в одной функции, и историю изменений по журналу не восстановить.

Зачем

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

Как проверить

На каждый пункт есть строка кода, к которой он относится, и описание последствия. Проверьте, что вы не повторяете то, что уже написали про transfer и reentrancy: дубли в отчёте читаются как вода и снижают доверие к остальному.

Типичная ошибка

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

Что видит эксперт

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

Шаг 1.5.3

Делаем

Пишем отдельный блок «оптимизация»: три поля структуры Donation можно упаковать в один слот памяти (uint96 amount, uint32 deadline, bool status), строку name вынести за пределы структуры в отдельный маппинг, а цикл в get_total заменить накоплением в поле total при каждом participate. Отдельно отмечаем, что public у массива donation создаёт геттер на каждый индекс и удорожает деплой.

Зачем

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

Как проверить

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

Типичная ошибка

Предложить изменить struct Donation — КЗ запрещает это прямым текстом, и такое предложение обнуляет пункт. Вторая ошибка — считать экономией удаление require: проверки стоят газа, но их отсутствие стоит денег пользователей и баллов за ИБ.

Что видит эксперт

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

Действие 1.6. Написать тесты и опубликовать контракт

Шаг 1.6.1

Делаем

Создаём в Remix файл Contract_test.sol и пишем тест на create_user: успешная регистрация нового логина (после вызова logins[«ivan»] равен адресу вызывающего), повторная регистрация того же логина с ожидаемым revert и регистрация с пустым логином, если вы добавили эту проверку. Для реверта используем try/catch или хелпер shouldFail, который ловит откат и считает его успехом теста.

Зачем

КЗ прямо перечисляет три функции, которые нужно покрыть тестами: create_user, participate и finish. Тест на успех показывает, что функция работает, а тест на отказ — что проверка на месте: без второго теста вы не докажете, что require вообще срабатывает, и на защите этот вопрос задают почти всегда.

Как проверить

В консоли Remix по каждому тесту зелёная галочка или осмысленное сообщение. Тест на дубль логина падает, если закомментировать require в строке 13, — это и есть доказательство, что тест проверяет именно проверку, а не что-то рядом.

Типичная ошибка

Написать только позитивный тест: он пройдёт и на контракте без единого require, то есть не доказывает ничего, а время съедает. Вторая ошибка — сравнивать адреса строками без приведения к нижнему регистру: checksum-адрес в другом регистре даст ложное падение теста.

Что видит эксперт

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

Шаг 1.6.2

Делаем

Тест participate строим на трёх вызовах: создаём сбор через ask_to_donate с целью 10 eth и дедлайном в будущем, вносим 2 eth с одного аккаунта и проверяем, что в массиве value появился элемент 2000000000000000000, а в sender — адрес участника. Третий вызов — participate с msg.value = 0, ожидаем revert «Взнос должен быть больше нуля». Функция payable, поэтому сумму передаём в поле Value, а в аргументах её не видно.

Зачем

Именно здесь проверяется, что динамические массивы внутри структуры заполняются правильно: после правки строк 41 и 42 это самая хрупкая часть контракта. Тест с нулевым взносом закрывает require из строки 48, а без него нулевой взнос проходит, ломает расчёт суммы и искажает результат finish.

Как проверить

После двух успешных вызовов get_donation_2(0) возвращает массивы длиной 2 и 2, а после третьего, отклонённого, длина не меняется. Числа в wei совпадают с отправленными до последней цифры — сравнение идёт по точному значению, а не «примерно».

Типичная ошибка

Тестировать participate на сборе с дедлайном в прошлом: если вы добавили проверку времени, тест упадёт по неверной причине и вы начнёте править рабочий код. Вторая ошибка — ждать msg.value в параметрах функции: он приходит из поля Value в Remix и в аргументах не виден.

Что видит эксперт

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

Шаг 1.6.3

Делаем

Тест finish проверяет три исхода. Первый: сбор с целью 10 eth собрал 12 eth — после finish баланс создателя вырос на 12 eth, status стал true. Второй: собрал 4 eth — деньги вернулись участникам, у каждого на балансе ровно столько, сколько он внёс. Третий: повторный finish отклоняется с «Сбор уже закрыт», и балансы не меняются. Четвёртый прогон — finish с аккаунта, который сбор не создавал: ожидаем отказ по правам.

Зачем

finish — функция, где сходятся все найденные ошибки: сумма из get_total, знак сравнения, направление цикла и статус. Один тест на успешный сбор и один на провальный закрывают обе ветки if/else, а тест на повторный вызов доказывает, что вы действительно починили status = false, а не только написали об этом в отчёте.

Как проверить

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

Типичная ошибка

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

Что видит эксперт

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

Шаг 1.6.4

Делаем

Переключаем окружение на Injected Provider или Remix VM с Ganache, выбираем аккаунт, нажимаем Deploy и записываем адрес контракта вместе с хешем транзакции. Открываем адрес в обозревателе: там должны быть видны и транзакция создания, и вызовы из тестов. Адрес, хеш, номер блока и версию компилятора переносим на первый лист отчёта — это и есть выполнение третьего пункта модуля А.

Зачем

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

Как проверить

В отчёте есть адрес из 40 hex-символов, хеш из 64 и номер блока. В обозревателе по адресу открывается контракт с кодом, а не EOA-аккаунт, и в списке транзакций видны вызовы create_user и finish. Номер блока совпадает с тем, что записан в отчёте первой строкой.

Типичная ошибка

Записать адрес EOA-аккаунта вместо адреса контракта: по нему нет кода, и публикация не подтверждается. Вторая ошибка — задеплоить до чистой компиляции и потом править файл: адрес остаётся, а код в сети перестаёт соответствовать вашей работе, и это видно при первой же сверке.

Что видит эксперт

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

Задача 2. Написать контракт «Безопасное дорожное движение»Модуль Б · 36 баллов

Полтора часа на то, чтобы описать в коде систему с тремя субъектами: водитель, сотрудник ДПС и государственный банк, у которого на счету 1000 eth и куда уходят все уплаченные штрафы. Объект системы — транспортное средство с категорией A, B или C, рыночной стоимостью и сроком эксплуатации, а сам водитель несёт шесть характеристик: ФИО, удостоверение, год начала стажа, число ДТП, неоплаченные штрафы и баланс. Всё остальное — следствия: семь удостоверений из табл. 1 превращаются в базу для проверки, штраф в 10 eth с половиной цены в первые пять дней задаёт арифметику времени, а 25 секунд реального времени становятся тем сроком, внутри которого на видео нужно успеть оплатить.

Схема: Задача 2. Написать контракт «Безопасное дорожное движение»

Действие 2.1. Спроектировать структуры данных и связи

Шаг 2.1.1

Делаем

Начинаем файл с pragma solidity 0.8.0; и объявляем контракт SafeRoad. Внутри — три структуры по числу сущностей задания: License с полями number, validUntil, category и confirmed; Vehicle с полями category, marketValue и serviceYears; Driver с полями fio, experienceStart, accidents, unpaidFines, balance и вложенными License и Vehicle. Проверки удостоверения и машины в задании отдельные, поэтому вложенность удобнее плоского набора переменных: у удостоверения своё состояние confirmed, у машины своё registered.

Зачем

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

Как проверить

Пересчитайте поля: в Driver шесть собственных плюс два вложенных, в License четыре, в Vehicle три. Ни одно требование КЗ не пропало: ФИО, номер, срок действия, категория, год начала стажа, ДТП, неоплаченные штрафы, баланс, стоимость и срок эксплуатации машины.

Типичная ошибка

Хранить удостоверение тремя отдельными маппингами по адресу: код работает, но подтверждение ДПС приходится ставить в трёх местах, и на демонстрации легко забыть одно — тогда категория есть, а подтверждения нет. Вторая ошибка — оставить number и category без ограничения длины: любой введёт строку в 500 символов, и запись станет неоправданно дорогой.

Что видит эксперт

Сверяет структуры с перечнем характеристик из КЗ построчно — это первое, что он смотрит в модуле Б, потому что неполная структура обнуляет половину сценария демонстрации.

Шаг 2.1.2

Делаем

Добавляем три маппинга и две служебные переменные: mapping(address => Driver) public drivers, mapping(string => address) public licenseOwner для поиска водителя по номеру удостоверения — именно по номеру ДПС выписывает штраф, — и mapping(string => License) private licenseBase с семью записями табл. 1. Роли делаем двумя адресами: address public bank и address public dps, оба задаются в конструкторе, потому что на 0.8 инициализатор переменной состояния не может содержать msg.sender.

Зачем

Штраф выписывается по номеру удостоверения, а не по адресу, поэтому без обратного индекса функция issueFine физически не найдёт водителя: перебрать ключи маппинга в Solidity нельзя. Отдельная licenseBase — это база ГИБДД из задания: проверка «удостоверение есть в базе» идёт по ней, а не по данным, которые ввёл сам водитель, и именно поэтому подделка номера не проходит.

Как проверить

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

Типичная ошибка

Искать водителя перебором адресов: такой код не компилируется, и время уходит на попытки обойти ограничение языка. Вторая ошибка — хранить номер только внутри структуры Driver: тогда issueFine по номеру 111 не найдёт адрес, и половина сценария таблицы 2 не выполнится.

Что видит эксперт

Проверяет наличие обратного индекса «номер → адрес»: без него шаги 15 и 16 демонстрации не выполняются, и это видно ещё до запуска, по объявлениям. Отдельно смотрит на тип ключа: string, а не bytes32, иначе номер из табл. 1 в него не передать без приведения.

Шаг 2.1.3

Делаем

Переводим табл. 1 в числовые сроки. В задании день равен пяти секундам, поэтому объявляем uint constant DAY = 5; и считаем даты в секундах от начала эпохи: 11.01.2024 — 1704931200, 12.05.2028 — 1832544000, 09.09.2025 — 1757376000, 13.02.2030 — 1897516800, 10.05.2025 — 1746835200, 24.06.2032 — 1978272000, 31.03.2023 — 1680220800. Сроки записываем литералами в licenseBase, а не строками: сравнение с block.timestamp должно быть числовым.

Зачем

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

Как проверить

Пересчитайте хотя бы один срок: 1704931200 — это 11 января 2024 года, 00:00 UTC. Все семь значений идут в том же порядке, что и даты в таблице, а четыре просроченных (000, 222, 444, 666) меньше текущего block.timestamp — так и должно быть.

Типичная ошибка

Сравнивать строки лексикографически: 10.05.2025 и 09.09.2025 перепутаются местами, и просроченное удостоверение 444 пройдёт проверку. Вторая ошибка — поставить DAY = 1 days и забыть про масштаб: скидка на штраф станет недоступна уже через 25 секунд после выписки, то есть сразу.

Что видит эксперт

Просит показать, где в коде зашит масштаб времени: отсутствие пересчёта «день = 5 секунд» означает, что скидка и продление не заработают на демонстрации.

Действие 2.2. Задать стартовое состояние системы

Шаг 2.2.1

Делаем

В конструкторе фиксируем банк и ДПС: bank = msg.sender, dps = msg.sender — при деплое с аккаунта ДПС, как в таблице 2. Затем создаём трёх водителей: Иванова (стаж 2 года, 0 ДТП, 50 eth), Семёнова (5 лет, 0 ДТП, 50 eth) и Петрова (10 лет, 3 ДТП, 50 eth), у каждого пустое удостоверение и пустая машина. Год начала стажа считаем от текущего: 2026 − 2 = 2024 для Иванова, 2021 и 2016 для остальных, иначе через год стаж в кабинете разойдётся с заданием.

Зачем

Стартовое состояние — первый пункт демонстрации: эксперт заходит в аккаунт банка и ждёт 1000 eth, потом в аккаунт Иванова и ждёт 50 eth и стаж 2 года. Если цифры не совпадут, весь сценарий таблицы 2 теряет смысл, и баллы модуля Б снимаются до первого действия, потому что проверить работу системы не на чем.

Как проверить

После деплоя getDriver для адреса Иванова возвращает ФИО, experienceStart = 2024, accidents = 0, unpaidFines = 0, balance = 50 eth. У Петрова accidents = 3, у Семёнова стаж 5 лет и ноль ДТП — ровно как в пояснении к функционалу.

Типичная ошибка

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

Что видит эксперт

Открывает кабинет Иванова на первом шаге демонстрации: сверяет баланс 50 eth и стаж 2 года. Расхождение хотя бы в одном поле он отмечает как невыполнение стартового состояния.

Шаг 2.2.2

Делаем

Банк — это аккаунт в цепи, а не переменная, поэтому 1000 eth должны физически лежать на его адресе: Ganache выдаёт первому аккаунту 1000 ETH, и его же назначаем банком. В контракте храним только адрес bank и отдаём его геттером getBank(). Все штрафы переводим на bank через call с проверкой результата, а не копим на контракте: контракт в этой системе — реестр, а не касса.

Зачем

Задание прямо говорит, что банк задаётся в генезис-блоке и на нём 1000 eth, значит контракт не создаёт деньги, а только перенаправляет поток. Если копить штрафы на контракте, проверка «баланс банка вырос на 5 eth» на шаге 18 демонстрации не пройдёт, и последний пункт сценария окажется невыполненным.

Как проверить

В Ganache баланс первого аккаунта до деплоя равен 1000 ETH. После оплаты штрафа он больше ровно на сумму штрафа, а баланс контракта остаётся нулевым. В Remix VM по умолчанию на аккаунте 100 ETH, поэтому для сценария с 1000 eth нужен именно Ganache.

Типичная ошибка

Объявить в контракте uint bankBalance = 1000 и считать это балансом банка: цифра красивая, но реальных денег на адресе нет, и перевод штрафа упадёт. Вторая ошибка — принимать штраф на контракт и не пересылать: деньги застревают, и вывести их сможет любой, кто вызовет функцию со слабой проверкой прав.

Что видит эксперт

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

Шаг 2.2.3

Делаем

Заполняем licenseBase семью записями табл. 1: 000 — 11.01.2024, A; 111 — 12.05.2028, B; 222 — 09.09.2025, C; 333 — 13.02.2030, A; 444 — 10.05.2025, B; 555 — 24.06.2032, C; 666 — 31.03.2023, A. Пишем их одной приватной функцией seedLicenses(), которую вызывает конструктор: так инициализация водителей не смешивается с базой удостоверений, а при отладке видно, на каком именно шаге что заполняется.

Зачем

Табл. 1 — не справочная информация, а фильтр: половина демонстрации построена на том, что водители добавляют удостоверения, часть которых просрочена или не совпадает по категории. Без базы проверка «удостоверение есть в базе» превращается в проверку «строка не пустая», и все отказы, которых ждёт эксперт на шагах 7, 10, 13 и 14, перестают срабатывать.

Как проверить

Вызовите геттер по каждому номеру: 111 отдаёт срок 1832544000 и категорию B, 666 — 1680220800 и A. Записей ровно семь, и ни одна не перезаписана при повторном деплое в ту же сеть. Срок 222 — 1757376000, то есть 9 сентября 2025: он меньше текущего времени, значит отказ на шаге 7 сработает.

Типичная ошибка

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

Что видит эксперт

Сверяет две-три записи базы с табл. 1 КЗ. Особенно смотрит на 222 и 444: если они не просрочены в вашей базе, отказы в сценарии не воспроизводятся. Если 222 проходит как действующее, шаг 7 записи показывает не то, что ждёт эксперт.

Шаг 2.2.4

Делаем

Пишем геттеры, которые эксперт будет вызывать при демонстрации: getDriver(address) возвращает ФИО, стаж, ДТП, неоплаченные штрафы и баланс; getLicense(address) — номер, срок и категорию; getVehicle(address) — категорию, стоимость и срок эксплуатации. Возвращаем кортежи примитивов, а не структуры целиком: структура с вложенной строкой в public-геттере отдаётся в Remix набором индексов, и показывать её на видео неудобно.

Зачем

Личный кабинет из задания — это по сути три геттера, и вызывают их на видео восемь раз. Если возвращать структуру целиком, в Remix придётся разворачивать вложенные поля вручную, а на записи это выглядит как заминка и съедает минуты из тридцати, которых и так мало на 18 действий.

Как проверить

Каждый геттер вызывается на чистом контракте и не падает: для незарегистрированного адреса возвращает пустые значения, а не revert. Для Иванова сразу после деплоя отдаёт ровно те цифры, что в задании, — без пересчёта в голове.

Типичная ошибка

Сделать геттер, который падает на пустом адресе: первый же шаг демонстрации с незнакомым аккаунтом закончится красной ошибкой в консоли. Вторая ошибка — отдавать balance через address.balance: на 0.8 это баланс аккаунта в сети, и он не равен учётным 50 eth.

Что видит эксперт

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

Действие 2.3. Реализовать удостоверение и регистрацию транспорта

Шаг 2.3.1

Делаем

Пишем addLicense(string number): сначала require, что водитель зарегистрирован, затем что номер есть в licenseBase, затем что запись не пустая. Дальше привязка номера к адресу через licenseOwner — она делается сразу при вводе, даже если удостоверение окажется просроченным, — и автопроверка: если block.timestamp меньше срока из базы, ставим confirmed = true и записываем номер в карточку водителя; если срок прошёл, confirmed остаётся false, а в messages уходит «Удостоверение просрочено».

Зачем

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

Как проверить

Романов с номером 111 получает confirmed = true и категорию B; Петров с номером 222 получает confirmed = false и сообщение об отказе, но licenseOwner по 222 указывает на Петрова. Оба случая проверьте до записи видео: на них держатся шаги 7–10 и 16.

Типичная ошибка

Подтверждать любое удостоверение, которое есть в базе: тогда 222 у Петрова пройдёт, и шаг 7 не покажет отказа, а отказ там и есть демонстрируемый результат. Вторая ошибка — отказывать до привязки номера: штраф по 444 на шаге 16 не найдёт получателя.

Что видит эксперт

Смотрит, что отказ и привязка разделены: успешная привязка при отклонённом удостоверении — признак того, что участник продумал сценарий, а не просто написал require.

Шаг 2.3.2

Делаем

Добавляем mapping(address => string[]) public messages и приватную функцию pushMessage(address to, string memory text), которую вызывают все проверки при отказе. Тексты делаем конкретными: «Удостоверение не найдено в базе», «Удостоверение просрочено», «Категория не совпадает с удостоверением», «Есть неоплаченные штрафы», «До окончания срока больше месяца». В сценарии эти сообщения показывают четыре раза — на шагах 7, 8, 13 и 14.

Зачем

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

Как проверить

После отказа в messages адреса появляется ровно одна новая строка, и в Remix она видна по индексу в геттере. Число сообщений совпадает с числом неудачных попыток, при успешных действиях не добавляется ни одного.

Типичная ошибка

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

Что видит эксперт

Просит показать сообщение после отказа: если в кабинете пусто, а в консоли только revert, пункт «сообщение об отказе» считается невыполненным. Текст он сверяет с причиной: сообщение про категорию при отказе по сроку читается как непонимание проверки.

Шаг 2.3.3

Делаем

registerVehicle(uint marketValue, uint serviceYears, string memory category) сверяет категорию машины с категорией подтверждённого удостоверения: require(keccak256(bytes(category)) == keccak256(bytes(license.category))). Если удостоверение не подтверждено, отказ другой — «Сначала подтвердите удостоверение». При совпадении заполняем vehicle и ставим registered = true, сохраняя стоимость и срок эксплуатации из аргументов.

Зачем

Сравнение строк в Solidity — не ==, а хеширование обоих значений: оператор == для string не определён, и наивная запись просто не компилируется. Сама проверка — центральное требование модуля Б: шаги 11–14 таблицы 2 построены так, что один запрос проходит, а три отклоняются, и все три отказа имеют разные причины.

Как проверить

Дмитриев с удостоверением 111 (B) регистрирует машину B — проходит. Семёнов с 222 (C) пробует A — отказ по категории. Романов с 333 (A) пробует C — отказ по категории. Петров без подтверждённого удостоверения пробует B — отказ по подтверждению. Все четыре результата воспроизводятся до записи.

Типичная ошибка

Сравнить категории через == и получить ошибку компиляции «Operator == not compatible with types string memory and string memory» — потеря времени на ровном месте. Вторая ошибка — не проверять confirmed: тогда Петров зарегистрирует B без действующих прав, и шаг 11 демонстрации не покажет отказа.

Что видит эксперт

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

Шаг 2.3.4

Делаем

Запрещаем вторую машину: повторный вызов при registered = true возвращает отказ «Транспортное средство уже зарегистрировано». Если по заданию понадобится замена, добавляем отдельную функцию replaceVehicle с той же сверкой категории, а не разрешаем перезапись в registerVehicle. То же правило — для удостоверения: новая запись заменяет предыдущую только после проверки по базе, иначе шаг 9 сценария (Романов: 111, затем 333) перестанет быть виден.

Зачем

Запрет на перезапись нужен ровно для того, чтобы изменение состояния было видно на видео: если шаг 12 молча перезаписывает машину, эксперт не понимает, что именно изменилось. Отдельная функция замены — это ещё и следствие из модуля А: неограниченная перезапись состояния — та же уязвимость, что отсутствие проверок в чужом контракте.

Как проверить

После регистрации getVehicle отдаёт три значения: категорию, стоимость и срок эксплуатации из вызова. Повторный registerVehicle с теми же аргументами даёт отказ, а состояние не меняется. Романов после 111 и 333 имеет категорию A, а не две записи.

Типичная ошибка

Разрешить перезапись без ограничений: шаг 11 (Петров, категория B без удостоверения) пройдёт молча, и отказа, которого ждёт эксперт, не будет. Вторая ошибка — хранить стоимость в uint8: 30 eth в wei не влезет, значение обрежется, и в кабинете появится мусор.

Что видит эксперт

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

Действие 2.4. Реализовать штрафы, оплату и продление прав

Шаг 2.4.1

Делаем

Пишем issueFine(string memory number) с модификатором onlyDps: находим адрес через licenseOwner, проверяем, что он не нулевой, увеличиваем unpaidFines и добавляем в массив штрафов водителя запись с суммой 10 ether и меткой block.timestamp. Сумму храним в wei: литерал 10 ether компилятор считает как uint256, и он же участвует в расчёте скидки. Штраф кладём в массив с индексом, чтобы у водителя их могло быть несколько.

Зачем

Штраф выписывается по номеру удостоверения — прямое требование задания, и оно объясняет, зачем нужен обратный маппинг. Модификатор onlyDps закрывает половину отчёта по ИБ из модуля А: без него любой участник выпишет штраф сам себе или конкуренту, и вся экономика системы рухнет за одну транзакцию.

Как проверить

После issueFine(«111») у Романова unpaidFines равен 1, в массиве штрафов одна запись на 10000000000000000000 wei. Вызов с аккаунта, не равного dps, откатывается с сообщением «Только сотрудник ДПС», и состояние не меняется.

Типичная ошибка

Хранить штрафы в маппинге «адрес → штраф» без индекса: тогда нельзя выписать два штрафа одному водителю, вторая запись перезапишет первую. Вторая ошибка — не увеличивать unpaidFines: продление прав пройдёт при неоплаченном штрафе, и проверка из задания перестанет работать.

Что видит эксперт

Проверяет, что штраф уходит именно владельцу номера: на шаге 15 это Романов, а не тот, кто платит. Ошибку в обратном индексе он видит по неверному адресу получателя в событии.

Шаг 2.4.2

Делаем

payFine(uint index) public payable: берём штраф по индексу, считаем цену — если block.timestamp − issuedAt <= 25 секунд, цена 5 ether, иначе 10 ether; требуем msg.value == price, помечаем paid = true, уменьшаем unpaidFines и переводим сумму на bank через call с проверкой ok. Порядок строгий: сначала меняем состояние, потом отправляем деньги. Скидку считаем от issuedAt, а не от номера блока: block.timestamp в Ganache идёт по реальному времени.

Зачем

Скидка за первые пять дней — единственное место в задании, где время переводится в деньги, и его проверяют на видео дважды: Петров платит сразу после выписки и должен отдать 5 eth вместо 10. Требование точного равенства msg.value защищает от недоплаты, а порядок «состояние, потом перевод» закрывает reentrancy, о которой вы писали в модуле А, — здесь она уже не теория.

Как проверить

Петров платит в пределах 25 секунд после выписки: с его аккаунта уходит 5 eth, баланс банка растёт на 5 eth, unpaidFines становится 0, штраф помечен оплаченным. Если подождать 30 секунд, тот же вызов потребует 10 eth.

Типичная ошибка

Считать срок в реальных днях (86400 секунд) вместо пяти: скидка не сработает никогда, и шаг 17 покажет списание 10 eth вместо 5, а ваш комментарий на видео станет неверным. Вторая ошибка — принимать msg.value >= price и не возвращать разницу: переплата останется на контракте.

Что видит эксперт

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

Шаг 2.4.3

Делаем

renewLicense(uint newValidUntil) проверяет два условия из задания: до текущего срока осталось не больше месяца в масштабе задания (30 дней по 5 секунд — 150 секунд) и unpaidFines равен нулю. При выполнении записываем новый срок, обновляем licenseBase и сбрасываем confirmed до повторной проверки; при отказе пишем в messages точную причину — «До окончания срока больше месяца» или «Есть неоплаченные штрафы».

Зачем

Продление — вторая проверка, где встречаются время и деньги, и её легко сделать формально: если не пересчитать месяц в 150 секунд, условие «не больше чем за месяц» станет бессмысленным, потому что до 2030 года всегда больше месяца. В демонстрацию школьников продление не входит, но входит в функционал роли, и его наличие отличает полное решение от половины.

Как проверить

Романов с удостоверением 333 (срок 13.02.2030) получает отказ: до срока больше 150 секунд. Водитель, у которого срок подведён к границе и ноль неоплаченных штрафов, проходит; если есть хотя бы один неоплаченный — отказ с другим текстом.

Типичная ошибка

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

Что видит эксперт

Спрашивает, почему месяц равен 150 секундам: ответ показывает, понял ли участник масштаб времени из КЗ или скопировал число из чужого решения. Если ответ «так в задании», он просит пересчитать 30 дней в секунды при нём.

Действие 2.5. Задокументировать код и опубликовать контракт

Шаг 2.5.1

Делаем

Оформляем код комментариями NatSpec: перед контрактом — @title SafeRoad и @notice с описанием системы, перед каждой публичной функцией — @notice, @param на каждый параметр и @return на возвращаемые значения. В комментариях к issueFine и payFine отдельно фиксируем масштаб времени: «1 день = 5 секунд, скидка действует 25 секунд». Текст пишем по-русски, теги оставляем английскими, иначе генератор документации их не распознает.

Зачем

Задание требует, чтобы код решения был задокументирован, и NatSpec — единственный формат, который эксперт узнаёт с первого взгляда. Отдельная строка про масштаб времени снимает главный вопрос при проверке: почему скидка считается за 25 секунд, а не за пять дней, и почему продление проверяет 150 секунд.

Как проверить

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

Типичная ошибка

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

Что видит эксперт

Открывает код и ищет комментарии у двух-трёх функций, выбранных наугад: наличие @param и @return для него признак того, что документирование сделано, а не имитировано.

Шаг 2.5.2

Делаем

Деплоим SafeRoad с аккаунта ДПС, записываем адрес контракта и адреса пяти участников в отдельный файл, который потом пойдёт в таблицу 3. Рядом кладём README на одну страницу: как поднять Ganache, как подключить Remix через Injected Provider, какая версия компилятора, в каком порядке вызывать функции. Адрес и хеш деплоя — в шапку README. Отдельно фиксируем chainId: при другом значении MetaMask не подключится к сети, и деплой не пройдёт.

Зачем

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

Как проверить

В README есть версия компилятора 0.8.0, сеть и chainId, адрес контракта, список аккаунтов с ролями и порядок вызовов. Человек, который не видел вашу работу, сможет повторить деплой по этому файлу, не задавая вопросов.

Типичная ошибка

Оставить инструкцию «разверните контракт в Remix»: без сети, версии и порядка вызовов её невозможно выполнить. Вторая ошибка — не зафиксировать адреса сразу: после перезапуска Ganache они меняются, и таблица 3 заполняется по памяти, то есть с ошибками.

Что видит эксперт

Проверяет README на выполнимость: открывает его и пытается повторить первый шаг. Если для этого нужен ваш устный комментарий, инструкция считается неполной.

Задача 3. Записать демонстрацию и сдать решениеМодуль В · 18 баллов

Последние 30 минут — это не разработка, а доказательство: 18 действий из таблицы 2 подряд, без монтажа и без пауз на «а что дальше», с комментарием того, что меняется в состоянии блокчейна. Съёмка идёт на чистой сети, потому что первый кадр должен показать банк с 1000 eth, а последний — тот же банк, но с выросшим балансом. Кроме видео нужны таблица 3 с адресами и инструкция по запуску: без них модуль считается невыполненным, даже если контракт работает идеально.

Схема: Задача 3. Записать демонстрацию и сдать решение

Действие 3.1. Подготовить сценарий, сеть и запись

Шаг 3.1.1

Делаем

Распечатываем табл. 2 из КЗ и размечаем её: напротив каждого из 18 пунктов пишем аккаунт, функцию и ожидаемый результат. Отмечаем четыре пункта, где ожидается отказ (7, 10, 13, 14), и два, где меняется баланс (17 и 18). Рядом держим открытой табл. 3 для адресов и отдельный лист с текстами сообщений, которые должны появиться в кабинете. Разметку держим на бумаге перед собой: переключаться на второй экран во время записи — терять темп.

Зачем

На запись даётся 30 минут, и любая пауза «а что дальше» съедает баллы: видео оценивают как непрерывную демонстрацию, монтаж и склейки не приветствуются. Разметка заранее — единственный способ пройти 18 действий без запинки, потому что в сценарии чередуются успешные и отклоняемые вызовы, и легко перепутать, где какой должен быть.

Как проверить

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

Типичная ошибка

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

Что видит эксперт

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

Шаг 3.1.2

Делаем

Поднимаем чистую сеть: ganache с chainId 1337 и десятью аккаунтами, копируем приватные ключи первых шести в Remix через Injected Provider. Включаем запись экрана с захватом окна браузера, без веб-камеры, и увеличиваем масштаб интерфейса до 125 процентов: строки в консоли Remix мелкие, и на видео их не разобрать. Проверяем, что запись захватывает и Remix, и окно Ganache одновременно или переключается между ними без задержки.

Зачем

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

Как проверить

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

Типичная ошибка

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

Что видит эксперт

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

Шаг 3.1.3

Делаем

Деплоим SafeRoad с аккаунта 0 — это банк, и он же ДПС по сценарию, потому что на шаге 15 штраф выписывает тот же адрес. В первом кадре показываем адрес контракта крупно, затем вызываем getBank и getDriver для Иванова. Проговариваем вслух: банк 1000 eth, у Иванова 50 eth, стаж 2 года, 0 ДТП, удостоверения и машины нет. С этого кадра начинается отсчёт изменений, поэтому переснимать его нельзя, не начав заново.

Зачем

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

Как проверить

В кадре видно адрес контракта, баланс 1000 ETH и поля Иванова: ФИО, 2024 как год начала стажа, 0 ДТП, 0 штрафов, 50 eth. Адрес контракта совпадает с записанным в README и в шапке таблицы 3. Если баланс отличается, сеть не очищена или деплой прошёл с другого аккаунта.

Типичная ошибка

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

Что видит эксперт

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

Действие 3.2. Пройти 18 действий таблицы 2 на запись

Шаг 3.2.1

Делаем

Регистрируем Романова (стаж 6 лет, 1 ДТП, 1000 eth) и Дмитриева (стаж 3 года, 1 ДТП, 1000 eth) через registerDriver. После каждого вызова вызываем getDriver и показываем, что появились ФИО, стаж и ДТП, а удостоверение и машина пустые. Комментируем, что 1000 eth — это реальный баланс аккаунта в Ganache, поэтому цифры в кабинете и в сети совпадают. Это первые вызовы, где видно, что регистрация открыта всем, а не только трём водителям из конструктора.

Зачем

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

Как проверить

После двух вызовов в системе пять водителей: три из конструктора и два новых. У Романова стаж 6 и 1 ДТП, у Дмитриева 3 и 1, у обоих 1000 eth и пустые поля удостоверения и машины. Балансы новых водителей берутся из Ganache, в конструкторе они не задаются.

Типичная ошибка

Регистрировать новых водителей с нулевым стажем: шаги 13 и 14 опираются на конкретные цифры, и расхождение с таблицей заметят сразу. Вторая ошибка — не показать состояние до добавления удостоверения: изменение информации не будет видно, а именно его просят показать в пунктах 5–10.

Что видит эксперт

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

Шаг 3.2.2

Делаем

По очереди переключаем аккаунты и добавляем удостоверения: Дмитриеву 111, Семёнову 222, Петрову 222, Романову 111, затем Романову 333, Петрову 444. После каждого вызова показываем поле license и массив messages. Проговариваем результат: 111 и 333 проходят как действующие, 222 и 444 отклоняются как просроченные — их сроки 09.09.2025 и 10.05.2025 раньше текущей даты.

Зачем

Шесть вызовов с четырьмя разными исходами — самая насыщенная часть сценария, и она проверяет три механизма сразу: поиск в базе, проверку срока и запись сообщения об отказе. Именно здесь видно, что контракт не просто принимает строку, а сверяет её с табл. 1, — за это и дают баллы за модуль Б.

Как проверить

У Дмитриева после шага 5 категория B и confirmed = true; у Романова после 111 тоже B, после 333 — A. У Семёнова и Петрова поле license пусто, а в messages по одной строке про просроченное удостоверение.

Типичная ошибка

Показывать только успешные вызовы: половина смысла этих шагов в отказах, и без них эксперт не увидит проверку срока. Вторая ошибка — перепутать порядок и добавить Петрову 444 раньше 222: сообщений станет два, а объясняете вы одно.

Что видит эксперт

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

Шаг 3.2.3

Делаем

Петрову пытаемся зарегистрировать машину категории B — получаем отказ, потому что подтверждённого удостоверения у него нет. Дмитриеву регистрируем B — проходит, у него удостоверение 111 категории B. Семёнову пробуем A — отказ по категории, у него 222 категории C. Романову пробуем C — отказ, у него 333 категории A. Каждый отказ показываем вместе с текстом сообщения в кабинете.

Зачем

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

Как проверить

У Дмитриева getVehicle возвращает категорию B, стоимость и срок эксплуатации из вызова. У Петрова, Семёнова и Романова vehicle пуст, а в messages прибавилось по сообщению с конкретной причиной — категория или отсутствие подтверждения.

Типичная ошибка

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

Что видит эксперт

Проверяет, различаются ли причины отказов у Петрова и Семёнова: у одного нет прав, у другого не та категория, и одинаковый текст он считает одной проверкой вместо двух.

Шаг 3.2.4

Делаем

С аккаунта ДПС выписываем штраф по номеру 111 — он уходит Романову, последнему, кто привязал этот номер к своему адресу. Затем штраф по 444 — он уходит Петрову, потому что привязка делается при вводе, даже если удостоверение отклонено. Петров сразу оплачивает: 5 eth вместо 10, потому что прошло меньше 25 секунд. В финале заходим в банк и показываем, что баланс вырос на 5 eth.

Зачем

Два штрафа и одна оплата — проверка всей денежной части: суммы 10 и 5 eth, скидки за пять дней, перевода на счёт банка и счётчика неоплаченных штрафов. Привязка номера при вводе — то решение, без которого шаг 16 не выполнить: у Петрова просроченное удостоверение, но штраф по его номеру выписать нужно, иначе сценарий обрывается.

Как проверить

Баланс банка в последнем кадре больше первого на 5 eth, у Петрова unpaidFines равен 1 после выписки и 0 после оплаты, штраф помечен оплаченным. Между выпиской и оплатой прошло меньше 25 секунд — это видно по времени транзакций в Ganache.

Типичная ошибка

Медлить с оплатой на записи: скидка действует 25 секунд, и если вы в это время объясняете предыдущий шаг, Петров заплатит 10 eth, а комментарий про 5 eth станет неверным. Вторая ошибка — выписать штраф по номеру, который никому не привязан: вызов упадёт, и в кадре останется пустая транзакция.

Что видит эксперт

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

Действие 3.3. Заполнить таблицу адресов, написать инструкцию и сдать

Шаг 3.3.1

Делаем

Заполняем табл. 3 из КЗ: банк, Иванов, Семёнов, Петров, Романов, Дмитриев — и напротив каждого полный адрес из Ganache. Адреса копируем из списка аккаунтов, а не из консоли транзакций, чтобы не перепутать отправителя и получателя. Таблицу вставляем в тот же документ, что и инструкцию, и отдельно сохраняем скриншот списка аккаунтов. Адреса проверяем по контрольной сумме: одна перепутанная цифра делает строку бесполезной.

Зачем

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

Как проверить

Шесть строк заполнены, все адреса начинаются с 0x и содержат 40 hex-символов, ни один не повторяется дважды. Адрес контракта в шапке таблицы совпадает с адресом из README и с первым кадром записи. Ни одна строка не заполнена адресом из другого запуска сети.

Типичная ошибка

Заполнить таблицу адресами из другого запуска Ganache: они выглядят правильными, но состояние по ним пустое, и проверка не сходится. Вторая ошибка — указать адрес контракта вместо адреса банка: в таблице это разные строки, и путаница видна сразу.

Что видит эксперт

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

Шаг 3.3.2

Делаем

Дописываем инструкцию по запуску: установка Ganache и Remix, версия компилятора 0.8.0, порядок деплоя, список ролей и аккаунтов, последовательность вызовов из таблицы 2 с ожидаемым результатом каждого. Добавляем раздел «что смотреть в сети»: где в Ganache видно изменение баланса, где в Remix — журнал транзакций. Пишем так, чтобы инструкцию можно было выполнить, не открывая код.

Зачем

Инструкция — отдельное требование КЗ наряду с видео, и она проверяется на выполнимость: эксперт может попробовать повторить запуск. Ожидаемые результаты по каждому шагу нужны и для самопроверки: если на шаге 6 у вас прошло, а в инструкции написано «отказ», вы увидите это до сдачи, а не после.

Как проверить

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

Типичная ошибка

Написать инструкцию после сдачи видео, по памяти: половина шагов пропущена, порядок не совпадает с записью. Вторая ошибка — не указать версию компилятора: на 0.7 код с call{value:} и явным payable не соберётся, и повторяющий не поймёт почему.

Что видит эксперт

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

Шаг 3.3.3

Делаем

Собираем пакет: видео, семь отчётов модуля А, исходники обоих контрактов, README с инструкцией, таблицы 2 и 3. Называем файлы по шаблону из задания с номером участника, чтобы эксперт не искал, что где. За пять минут до конца проверяем пакет по списку и сдаём через эксперта площадки, а не через общий сетевой диск. В имени видео ставим номер участника и слово demo, чтобы файл не потерялся среди отчётов.

Зачем

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

Как проверить

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

Типичная ошибка

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

Что видит эксперт

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

Студент

учащиеся колледжей и техникумов
Конкурсное задание · СтудентPDF · 970 КБ

Выдержка из официального конкурсного задания: страницы, относящиеся к категории «Студент» (стр. 5–6, 11–17 источника).

Пошаговое решение

Задание для категории «Студенты» — три часа на три модуля: час на аналитику готового контракта, полтора часа на приватный Ethereum с geth и собственный контракт «Безопасное дорожное движение», полчаса на видеодемонстрацию. Модуль А — это 86 строк с намеренно сломанным синтаксисом, пять отчётов (функционал, логика, проверки, информационная безопасность, оптимизация) и автотесты на create_user, participate, finish. Модуль Б — подъём сети с банком на 1000 eth в генезисе, страховая с нулём, три стартовых водителя и формула страхового взноса, которую нужно перевести в целые числа без потери точности. Модуль В — четырнадцать действий из таблицы 2 на экране, включая два обязательных отказа: занятое удостоверение 222 и штраф по 555. Главная ловушка — время: пять дней на оплату штрафа со скидкой равны 25 секундам реального времени, и без этого окна оплата покажет 10 eth вместо 5.

Схема к заданию

Задача 1. Модуль А: разобрать контракт и снять синтаксисМодуль А · 1 час

Первый час уходит на исходник из приложения к заданию: 86 строк, в которых сломаны объявления маппингов, инициализация владельца, конструктор структуры и четыре метода. Задача не «переписать красиво», а найти каждую ошибку, зафиксировать её номер строки и довести файл до сборки компилятором 0.8.0. Порядок разбора жёсткий: пока не исправлен >> в строке 9, компилятор не показывает ни одной из ошибок ниже, поэтому правки идут сверху вниз, а таблица правок заполняется параллельно с кодом.

Схема: Задача 1. Модуль А: разобрать контракт и снять синтаксис

Действие 1.1. Развернуть окружение и зафиксировать исходник

Шаг 1.1.1

Делаем

Открываем remix.ethereum.org в Chrome, в панели File Explorer создаём файл Contract.sol и вставляем исходник из задания построчно, сохраняя пустые строки: в КЗ код напечатан с номерами 1–86, и вставка «одним куском» сдвинет нумерацию. Включаем нумерацию строк правым кликом в редакторе, сверяем, что mapping(string >> address) стоит на строке 9, а finish начинается на 64-й. Сохраняем копию как Contract_original.sol — она понадобится для отчёта.

Зачем

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

Как проверить

В редакторе видны номера строк: 11-я — address root = msg.sender;, 35-я — Donation donation;, 64-я — function finish(uint donation_id) public{. Всего 86 строк, последняя — закрывающая скобка контракта. В файловом дереве два файла: Contract.sol и Contract_original.sol.

Типичная ошибка

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

Что видит эксперт

Эксперт открывает ваш Contract.sol и сравнивает номера строк с КЗ: совпадение нумерации — первый признак того, что отчёт делался по этому файлу, а не по памяти.

Шаг 1.1.2

Делаем

В панели Solidity Compiler выбираем из списка ровно 0.8.0, а не «0.8.31» и не auto: КЗ фиксирует компилятор 0.8.0, и на другой версии часть сообщений просто не воспроизведётся. Снимаем галочку Auto compile и нажимаем Compile — читаем список ошибок сверху вниз, а не по одной: ParserError на строке 9 останавливает разбор, и всё, что ниже, компилятор ещё не проверял. Первые пять сообщений с номерами строк сразу переносим в таблицу правок.

Зачем

Порядок разбора объясняет, почему нельзя хвататься за последнюю ошибку в списке: пока не исправлен >>, компилятор не увидит ни login[login], ни Donation donation. Версия 0.8.0 важна и для отчёта: в 0.8 включена проверка переполнения, и total ** 2 на больших суммах падает с Panic(0x11), а на 0.7 просто переполнился бы — это отдельный довод в отчёте по безопасности.

Как проверить

В выпадающем списке стоит 0.8.0, Auto compile снят, первая ошибка в списке — Expected '=>' but got '>>' на строке 9. Если первая ошибка про pragma, вы уже правили строку 1 — вернитесь к копии и сверьте порядок правок.

Типичная ошибка

Оставить Auto compile: редактор пересобирает файл на каждое нажатие клавиши, список ошибок прыгает, и последовательность правок теряется. Вторая ошибка — взять 0.8.20 «потому что новее»: тексты сообщений изменятся, а сверка с КЗ пойдёт по другим формулировкам.

Что видит эксперт

Эксперт смотрит на скриншот панели компилятора: версия 0.8.0 в списке — доказательство, что контракт собран тем компилятором, который назван в задании.

Шаг 1.1.3

Делаем

Заводим таблицу правок в Google Sheets с четырьмя колонками: номер строки, исходный текст, исправленный текст, причина. Каждую правку вносим сначала в таблицу, потом в код — так отчёт по синтаксису пишется параллельно работе и к концу часа занимает минуты. После каждого блока правок сохраняем снапшот: Contract_v1.sol, Contract_v2.sol в папку Конкурсное_задание[номер участника].

Зачем

Отчёт по синтаксису — отдельный пункт КЗ, и он требует именно «в какой строке и какое изменение», то есть таблицу, а не пересказ. Снапшоты страхуют от отката: если после очередной правки контракт перестал собираться, вы возвращаетесь к последней рабочей версии за секунду вместо поиска потерянной скобки в 86 строках.

Как проверить

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

Типичная ошибка

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

Что видит эксперт

Эксперт сверяет три-четыре строки из вашей таблицы с исходником КЗ: совпало — пункт засчитан, нет — весь отчёт идёт как невыполненный. Он сличает формулировки причины с реальным кодом.

Действие 1.2. Починить объявления, владельца и конструктор структуры

Шаг 1.2.1

Делаем

Меняем строку 1 на pragma solidity 0.8.0. Конструкция >0.5.0 формально означает «любая версия выше 0.5.0», и под неё подходит и 0.6, и 0.9, где часть синтаксиса уже другая. Если хочется оставить диапазон, правильный вид — pragma solidity ^0.8.0;, но задание называет 0.8.0, поэтому пишем точно и без крыши. После правки строка компилируется без предупреждений о версии.

Зачем

Pragma — первое, что читает эксперт в отчёте по синтаксису, и первое, что проверяет компилятор при воспроизведении вашей сборки. Несовпадение версии означает, что «исправленный» контракт собирался не тем компилятором, и все выводы отчёта ставятся под сомнение.

Как проверить

Строка 1 читается ровно как pragma solidity 0.8.0; — без крыши, без звёздочки, с точкой с запятой в конце. Компилятор 0.8.0 не выдаёт предупреждение о несоответствии pragma. Проверьте ещё, что файл сохранён: несохранённая правка не меняет результат сборки.

Типичная ошибка

Оставить >0.5.0 и считать, что ошибки нет: компилятор промолчит, но в отчёте не будет первой и самой очевидной правки, а проверяющий начнёт сверку именно с неё. Вторая ошибка — поставить ^0.8.0 и не отметить это в таблице.

Что видит эксперт

Эксперт открывает файл и смотрит первую строку: если pragma не приведена к 0.8.0, дальше отчёт читается с недоверием. В отчёте эта строка должна стоять первой, с номером 1.

Шаг 1.2.2

Делаем

Правим строки 9 и 10: mapping(string => address) public logins; и mapping(address => User) public users. Двойной угловой >> в объявлении типа — не оператор Solidity, компилятор ждёт => и падает с ParserError. Проверяем, что public у обоих маппингов остался: он генерирует геттеры logins(string) и users(address), без которых не обойтись в тестах и в демонстрации.

Зачем

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

Как проверить

После правки компилятор переходит к следующей ошибке — как правило, к address root = msg.sender на строке 11. В дереве ABI появились функции logins и users с типом возврата address и кортежем. Если в ABI видно logins и users, обе строки исправлены.

Типичная ошибка

Исправить только строку 9, забыв строку 10: ошибка переезжает ниже, и в отчёте не хватает одного пункта. Хуже — заменить >> на >=: текст ошибки меняется, и вы тратите время на поиск новой причины. Оба варианта правки стоят баллов в отчёте по синтаксису.

Что видит эксперт

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

Шаг 1.2.3

Делаем

Строку 11 address root = msg.sender; переносим в конструктор: объявляем address public root; и ниже пишем constructor() { root = msg.sender; }. На уровне состояния Solidity не позволяет обращаться к msg.sender: эта переменная существует только во время выполнения функции, поэтому инициализация в объявлении — ошибка компиляции, а не стилистика. Проверяем, что конструктор стоит сразу после объявления.

Зачем

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

Как проверить

Компилятор не жалуется на строку 11; после деплоя в Remix вызов root() возвращает адрес аккаунта, с которого вы деплоили. В конструкторе нет других присваиваний, кроме root. Нулевой адрес в этом вызове — признак того, что конструктор не сработал.

Типичная ошибка

Оставить address root; без конструктора: контракт соберётся, но root() вернёт нулевой адрес, и любая проверка msg.sender == root будет ложной — функции с ограничением доступа окажутся заблокированными навсегда.

Что видит эксперт

Эксперт вызывает root() после деплоя: адрес должен совпадать с аккаунтом деплоя, а не быть нулевым. Он просит показать конструктор: инициализация в объявлении не компилируется в 0.8.0.

Шаг 1.2.4

Делаем

Строка 14: login[login] = msg.sender; — здесь два дефекта сразу: маппинг называется logins, а параметр функции — login, поэтому обращение неоднозначно. Переименовываем параметр в loginName и пишем logins[loginName] = msg.sender. Строку 15 приводим к структуре: users[msg.sender] = User(0, loginName); — в User два поля, uint balance и string login, а в исходнике передано три аргумента, причём строка FIO встала на место uint.

Зачем

Структуры менять нельзя — это прямо запрещено КЗ, поэтому ФИО в контракте хранить негде, и это надо честно написать в отчёте по логике: поле FIO либо уходит в отдельный маппинг mapping(address => string), либо признаётся нереализуемым в рамках фиксированной структуры. Баланс при регистрации логично ставить нулевым и начислять отдельно.

Как проверить

Контракт компилируется до следующей ошибки, в ABI у users тип (uint256,string). После вызова create_user("ivan", "Иванов") геттер users(адрес) возвращает 0 и ivan, а logins("ivan") — ваш адрес. Сверяем значения до перехода к следующей строке.

Типичная ошибка

Оставить три аргумента в User(...): TypeError не даст собрать контракт, и время уйдёт на поиск «лишнего» поля, которого в структуре нет. Вторая ошибка — подставить msg.sender.balance в баланс пользователя: это баланс кошелька в сети, а не депозит в контракте, и учёт поедет на первом переводе.

Что видит эксперт

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

Действие 1.3. Починить массив заявок, массивы участников и геттеры

Шаг 1.3.1

Делаем

Строку 35 Donation donation; заменяем на Donation[] public donation; — массив структур, иначе donation.push(...) в ask_to_donate и обращение donation[donation_id] в остальных функциях не компилируются. Вызов конструктора структуры оставляем по составу полей: Donation(id, name, msg.sender, amount, deadline, sender, value, false, info), где id — это donation.length до вставки.

Зачем

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

Как проверить

В ABI появились donation(uint256) и get_donation_number(). После двух вызовов ask_to_donate функция get_donation_number() возвращает 2, а get_donation(0) и get_donation(1) показывают разные имена. Проверяем это на двух заявках подряд.

Типичная ошибка

Объявить Donation[] donation; без public и потом искать, почему в Remix нет кнопки для чтения заявки. Вторая ошибка — оставить donate_id жёстко нулевым: все заявки получат одинаковый идентификатор, и отчёт по логике потеряет смысл.

Что видит эксперт

Эксперт проверяет, что donate_id уникален и равен индексу в массиве: по нему потом сверяются демонстрация и тесты. Он следит, что геттер donation возвращает поля в порядке объявления структуры.

Шаг 1.3.2

Делаем

В ask_to_donate (строки 40–43) правим объявления: address[] memory sender = new address[](0); и uint[] memory value = new uint[](0). Просто uint value; — это скаляр, а структура ждёт uint[], и динамический массив в памяти нужно явно создавать через new, иначе обращение к нему упадёт. Индекс выносим в uint id = donation.length; перед push. Индекс считаем до вставки, а не после.

Зачем

Пустые массивы при создании заявки — правильная модель: участников ещё нет, они добавляются в participate. Явное new address[](0) в 0.8.0 обязательно, потому что неинициализированный memory-массив имеет нулевую длину и не размечен — компилятор такие обращения просто запрещает.

Как проверить

ask_to_donate компилируется; после вызова get_donation(0) возвращает имя, адрес организатора, сумму, дедлайн и false, а get_donation_2(0) — два пустых массива и строку info. Имена и суммы в обеих заявках не пересекаются — проверьте на двух вызовах подряд.

Типичная ошибка

Оставить uint value; и подставить его в конструктор: TypeError «Invalid type for argument». Вторая ошибка — создавать массивы длины один «на всякий случай»: в get_total появится фиктивный ноль, но проверка суммы на ноль сломается.

Что видит эксперт

Эксперт пролистывает ask_to_donate целиком: инициализация массивов — маркер того, что участник понимает разницу между storage и memory в 0.8. Он следит, что пустые массивы созданы через new, а не оставлены неинициализированными.

Шаг 1.3.3

Делаем

Правим четыре места: строку 21 — adr_to.transfer(msg.value) вместо transfering(msg.sender), строку 49 donation[donation_id].info вместо .data, строку 55 returns (uint) вместо return (uint), строку 56 donation.length вместо donation.len(). Метод .len() есть в Python и C++, в Solidity у массивов только .length, а transfering — несуществующий метод адреса.

Зачем

Каждая из этих правок — отдельная строка отчёта по синтаксису, и все они типовые: задание проверяет, различает ли участник синтаксис Solidity и «похожий» синтаксис других языков. transfer(msg.value) заодно чинит логику send_money: функция payable, значит переводить надо присланную сумму, а не адрес отправителя.

Как проверить

После правок компилятор проходит send_money, get_donation_2 и get_donation_number без ошибок. В ABI у get_donation_number возвращаемый тип uint256, а не пустой список. Если компилятор ругается на return вместо returns, значит строка 55 ещё не исправлена.

Типичная ошибка

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

Что видит эксперт

Эксперт ищет в отчёте строку 21: правильный ответ — transfer или call{value: ...}, вариант send без проверки результата не принимается. Он сверяет тип возврата в ABI — uint256, а не пустой список.

Действие 1.4. Собрать без ошибок и прогнать дымовой сценарий

Шаг 1.4.1

Делаем

Нажимаем Compile и добиваемся состояния «0 errors». Дальше читаем предупреждения: обычно это Function state mutability can be restricted to view, неиспользуемая переменная root и отсутствие SPDX-лицензии. Каждое предупреждение либо устраняем, либо вносим в отчёт с обоснованием, почему оставлено: молча игнорировать их нельзя, эксперт открывает вкладку с warning-ами.

Зачем

Чистая сборка — формальный признак выполненного пункта «исправьте синтаксические ошибки». Предупреждения не блокируют деплой, но именно они показывают глубину: view у геттера уменьшает газ при вызове из другого контракта, а отсутствие SPDX — вопрос юридической чистоты кода, который тоже входит в отчёт.

Как проверить

В панели компилятора зелёная галочка, «0 errors», список warnings пуст или каждая строка объяснена в таблице. Байткод в поле BYTECODE начинается с 60806040, длина — до 24 КБ. Если warning про view остался, добавьте его в таблицу с пометкой «оставлено намеренно».

Типичная ошибка

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

Что видит эксперт

Эксперт нажимает Compile при вас: повторная сборка должна пройти без ошибок на его машине, с тем же компилятором 0.8.0. Он сравнивает число предупреждений со списком в вашем отчёте.

Шаг 1.4.2

Делаем

В Deploy & Run выбираем окружение Remix VM (Cancun), аккаунт со 100 eth, деплоим и прогоняем дымовой сценарий: create_user("ivan", "Иванов"), ask_to_donate("Ремонт", 10, 1700000000, "сбор"), participate(0) со value 1 eth, get_total(0), finish(0). Смотрим не на зелёные галочки, а на возвращаемые значения и на баланс аккаунта после каждого вызова. Адрес контракта копируем сразу в accounts.txt.

Зачем

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

Как проверить

get_total(0) возвращает 1 eth, get_donation(0) показывает false в последнем поле, get_donation_number() равно 1. Баланс контракта после participate — ровно 1 eth. Если get_total вернул 0, значит value.push не выполнился или массив объявлен неверно.

Типичная ошибка

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

Что видит эксперт

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

Шаг 1.4.3

Делаем

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

Зачем

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

Как проверить

В консоли eth.getCode по адресу возвращает строку длиннее 0x6000, хеш транзакции сохранён в отчёте, ABI в build совпадает с тем, что вы деплоили. В эксплорере видна хотя бы одна транзакция создания контракта.

Типичная ошибка

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

Что видит эксперт

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

Задача 2. Модуль А: пять отчётов и автотестыМодуль А · 1 час

Вторая половина модуля А — это шесть документов, которые проверяют не по коду, а по тексту: функционал, логика, проверки, информационная безопасность, оптимизация и тесты на create_user, participate, finish. Здесь важно не количество исправленных строк, а способность объяснить последствие каждой: что именно ломается, при каком сценарии и какой строкой кода это лечится. Отчёты пишутся по ходу правок, а тесты запускаются в Hardhat на той же версии компилятора, что стоит в задании.

Схема: Задача 2. Модуль А: пять отчётов и автотесты

Действие 2.1. Отчёт по функционалу и сфера применения

Шаг 2.1.1

Делаем

Собираем таблицу по всем десяти функциям: create_user, get_balance, send_money, ask_to_donate, participate, get_donation, get_donation_2, get_donation_number, get_total, finish. Для каждой три колонки: что принимает с типами и единицами, что возвращает, кто имеет право вызывать по замыслу системы. Права пишем не по коду, а по логике: participate — любой участник, finish — только организатор.

Зачем

Отчёт по функционалу — отдельный пункт КЗ, и оценивается он по полноте: пропущенная функция читается как «участник не разобрал контракт». Колонка «кто вызывает» сразу выявляет дыры: у ask_to_donate и send_money в коде нет ни одной проверки, и это переходит в отчёт по безопасности.

Как проверить

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

Типичная ошибка

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

Что видит эксперт

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

Шаг 2.1.2

Делаем

Описываем сквозной сценарий словами и с номерами строк: пользователь вызывает create_user и попадает в logins и users; организатор вызывает ask_to_donate и создаёт заявку с дедлайном; участники вызывают participate со value, которая ложится в sender[] и value[]; любой читает get_total; организатор вызывает finish, и контракт либо переводит всё организатору, либо возвращает каждому его взнос. Проговариваем баланс контракта на каждом шаге.

Зачем

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

Как проверить

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

Типичная ошибка

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

Что видит эксперт

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

Шаг 2.1.3

Делаем

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

Зачем

Пункт сформулирован как «предположите и опишите сферу использования», то есть оценивается аргументация, а не список отраслей. Связка «свойство блокчейна → конкретная проблема» даёт балл, а перечисление «финансы, логистика, медицина» — нет. Верхняя граница — пять сфер, дальше аргументация размывается.

Как проверить

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

Типичная ошибка

Указать «банки и финансы» без объяснения: контракт не хранит проценты и не выдаёт кредиты, и эксперт отметит несоответствие заявленной сферы коду. Вторая ошибка — перечислить десять отраслей по одной строке.

Что видит эксперт

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

Действие 2.2. Отчёт по логике: четыре дефекта и их правки

Шаг 2.2.1

Делаем

В get_total (строки 58–62) меняем total = donation[donation_id].value[i] на total += donation[donation_id].value[i]. В исходнике переменная перезаписывается на каждом шаге, поэтому функция возвращает последний взнос, а не сумму: при трёх взносах по 1 eth ответ будет 1 вместо 3. Добавляем view и выносим массив в storage-указатель, чтобы не читать его трижды. После правки функция остаётся view и не пишет в storage.

Зачем

Это ключевая логическая ошибка: от неё зависит вся ветка finish, потому что сравнение с целью считается по сумме. С оператором = контракт никогда не наберёт цель при нескольких участниках и всегда уйдёт в возврат, то есть система неработоспособна в основном сценарии.

Как проверить

Тест: два взноса по 1 eth и один 2 eth дают get_total = 4 eth. Сверяем с балансом контракта — числа обязаны совпасть, иначе часть денег не учтена в массивах. Если числа расходятся, ищите взнос, который не попал в массив value.

Типичная ошибка

Исправить = на +=, но оставить чтение donation[donation_id] внутри цикла: работает, но на пятидесяти участниках съедает лишние сорок тысяч газа. В отчёте по оптимизации это отдельный пункт. Эти сорок тысяч газа и есть предмет отчёта по оптимизации.

Что видит эксперт

Эксперт вызывает get_total после двух взносов: ответ, равный последнему взносу, — признак неисправленной ошибки. Он просит объяснить, откуда берётся сумма, если взносов три.

Шаг 2.2.2

Делаем

В строке 65 меняем total ** 2 >= amount на total >= amount: возведение в квадрат — не сравнение с целью, а на суммах больше 1e9 wei оно переполняет uint256 и роняет транзакцию с Panic(0x11). В строке 68 меняем условие цикла i > value.length на i < value.length: сейчас тело не выполняется ни разу, поэтому возврат средств не происходит вообще. Обе правки идут в отчёт отдельными строками.

Зачем

Две правки закрывают обе ветки: без первой контракт сравнивает квадрат суммы с целью, и при 3 eth против цели 10 eth «набирает» 9, а при 4 eth — 16, то есть выплачивает при недоборе. Без второй проигранный сбор оставляет деньги заблокированными в контракте навсегда.

Как проверить

Сбор с целью 10 eth и взносами 2 + 3 eth: get_total = 5, условие ложно, каждый участник получает свой взнос обратно, баланс контракта 0. Сбор с взносами 6 + 6 eth: организатор получает 12 eth, баланс 0.

Типичная ошибка

Заменить ** на * и оставить total * 1: арифметически совпадёт, но в отчёте это выглядит подгонкой, и на вопрос «почему не просто total» ответа не будет. Вторая ошибка — исправить > на <, но перепутать сторону сравнения и уйти за границу массива.

Что видит эксперт

Эксперт прогоняет провальный сценарий: если после finish баланс контракта не ноль, возврат не работает. Он сверяет, что сумма возвратов равна сумме взносов до wei.

Шаг 2.2.3

Делаем

В строке 72 меняем donation[donation_id].status = false; на true. Сейчас после завершения заявка остаётся активной, и finish можно вызвать повторно: контракт второй раз попытается перевести ту же сумму, которой уже нет, и транзакция упадёт на нехватке баланса. Дополнительно переносим установку статуса до переводов и добавляем в начало require(status == false).

Зачем

Флаг status — единственная защита от повторного завершения, и в исходнике он не работает в обе стороны: participate проверяет status == false и пропускает взносы после финала, а finish не видит, что заявка уже закрыта. Это одновременно логическая ошибка и уязвимость повторного вызова, за которую в отчёте по безопасности дают отдельный пункт.

Как проверить

После finish геттер get_donation(0) возвращает true в последнем поле. Второй вызов finish(0) откатывается с вашим сообщением, баланс не меняется, событие не эмитится. Проверьте ещё, что participate после финала тоже откатывается.

Типичная ошибка

Поставить true только в конце функции, после переводов: внешний вызов в цикле успевает войти в finish повторно до записи статуса — классический reentrancy. Вторая ошибка — забыть, что participate тоже читает status, и оставить возможность платить в закрытую заявку.

Что видит эксперт

Эксперт дважды нажимает finish в Remix: второй вызов должен откатиться с внятным сообщением, а не с out of gas. Он смотрит, меняется ли статус до или после перевода денег.

Шаг 2.2.4

Делаем

Дописываем три дефекта: participate не сверяет block.timestamp с deadline, поэтому взносы принимаются после срока; повторный create_user с новым логином перезаписывает users[msg.sender] целиком и обнуляет накопленный баланс; ФИО принимается параметром, но в структуру не попадает, а в баланс пишется msg.sender.balance — баланс кошелька, а не учётный. По каждому — правка: проверка дедлайна, запрет перезаписи, отдельный маппинг для ФИО.

Зачем

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

Как проверить

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

Типичная ошибка

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

Что видит эксперт

Эксперт выбирает один пункт и просит показать правку в коде: если правки нет, пункт считается описанным формально. Он просит показать тест, который ловит этот дефект.

Действие 2.3. Отчёт по проверкам: тексты сообщений

Шаг 2.3.1

Делаем

Заполняем все пять заглушек "__________" конкретными текстами: для create_user — «Логин уже занят»; для participate — «Сбор завершён» и «Взнос должен быть больше нуля»; для finish — «Только организатор может завершить сбор» и «Сбор уже завершён». Тексты пишем по-русски, коротко, в одном стиле, без точки в конце: так их удобно сверять в тестах и читать в консоли.

Зачем

Отчёт по проверкам — отдельный пункт КЗ, и оценивается он по тому, объясняет ли сообщение причину отказа. Формулировка «Ошибка» или «Нельзя» баллов не даёт: пользователь кошелька видит именно этот текст в MetaMask, и по нему должен понять, что делать дальше.

Как проверить

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

Типичная ошибка

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

Что видит эксперт

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

Шаг 2.3.2

Делаем

Добавляем проверки, которых нет: в participate — require(block.timestamp <= deadline) и require(msg.sender != donation[donation_id].user); в ask_to_donate — require(amount > 0) и require(deadline > block.timestamp); в finish — require(block.timestamp > deadline). Для каждой в отчёт пишем строку, условие и текст сообщения: «Срок сбора истёк», «Организатор не может делать взнос», «Цель должна быть больше нуля», «Дедлайн в прошлом», «Сбор ещё идёт».

Зачем

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

Как проверить

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

Типичная ошибка

Добавить проверку дедлайна в finish и забыть про participate: организатор не сможет завершить сбор, пока идёт приём, но участники продолжат платить после срока — логика рвётся в другом месте. В отчёте это описывается как отдельный дефект логики.

Что видит эксперт

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

Действие 2.4. Отчёт по информационной безопасности

Шаг 2.4.1

Делаем

Описываем reentrancy в finish: переводы идут в цикле до записи status = true, поэтому получатель с вредоносным receive может вызвать finish повторно и получить выплату дважды. Предлагаем pull-pattern: не отправлять деньги в цикле, а начислять mapping(address => uint) pending, давать функцию withdraw() с обнулением баланса до перевода; альтернатива — модификатор nonReentrant и call{value:} с проверкой результата.

Зачем

Это самый весомый пункт отчёта по безопасности: контракт хранит чужие деньги, и повторный вход в finish опустошает его полностью. Даже с transfer и его 2300 газа защиты хватает не всегда: если получатель — контракт с дешёвым fallback, вызов проходит, а статус ещё не записан.

Как проверить

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

Типичная ошибка

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

Что видит эксперт

Эксперт просит показать место в коде, где статус пишется после перевода: нашли — пункт закрыт, вы цитируете строки 67–72. Он просит назвать шаг, на котором злоумышленник получает деньги дважды.

Шаг 2.4.2

Делаем

Разбираем доступ: root объявлен, но нигде не проверяется, поэтому ask_to_donate может вызвать кто угодно и создать заявку с произвольными amount и deadline; send_money вообще без проверок и позволяет любому инициировать перевод с баланса контракта; get_donation_2 публично раскрывает список адресов и сумм всех участников. Предлагаем модификатор onlyRoot для создания заявок, проверку владельца в send_money или её удаление, ограничение видимости списка участников.

Зачем

Пункт оценивается по тому, названы ли конкретные функции и последствия, а не по общим словам «слабая авторизация». send_money в исходном виде — открытый вывод средств: любой участник отправляет баланс контракта на свой адрес, и это первое, что найдёт проверяющий.

Как проверить

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

Типичная ошибка

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

Что видит эксперт

Эксперт спрашивает, что мешает вызвать send_money из чужого аккаунта: ответ «ничего, поэтому функция удалена или закрыта root» — правильный. Он уточняет, на какие функции это ограничение распространяется.

Шаг 2.4.3

Делаем

Дописываем три пункта: отсутствие событий, из-за чего по журналу нельзя восстановить, кто и сколько внёс; чтение msg.sender.balance даёт ложное представление о средствах в контракте; get_donation_2 отдаёт массивы целиком и на тысяче участников превышает лимит газа. Предлагаем event Contribution(uint indexed donation_id, address indexed sender, uint value), отдачу пагинации через offset и limit, хранение keccak256 от ФИО вместо открытой строки.

Зачем

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

Как проверить

В отчёте три события с сигнатурами и местами эмиссии. Для get_donation_2 указан предел: больше пятисот участников — вызов не проходит по газу при стандартном лимите RPC. Если лимит не указан, пункт считается описанным без цифр.

Типичная ошибка

Предложить хранить ФИО в блокчейне «для прозрачности»: персональные данные в открытом реестре — нарушение 152-ФЗ, и это отдельный минус в отчёте по безопасности. Такое нарушение отмечают отдельным пунктом, независимо от остальных находок.

Что видит эксперт

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

Действие 2.5. Отчёт по оптимизации

Шаг 2.5.1

Делаем

Описываем оптимизацию по газу: Donation storage d = donation[donation_id]; вместо шести обращений к массиву, потому что каждое холодное чтение storage стоит 2100 газа; кэширование d.value.length в переменную; uint256 i вместо uint в цикле для читаемости; unchecked { ++i; } для счётчика, где переполнение невозможно. Считаем экономию на примере: цикл по двадцати участникам экономит около шестидесяти тысяч газа.

Зачем

Оптимизация — отдельный пункт КЗ, и он оценивается по конкретике: «использовать memory» без цифр не считается. На приватной сети газ можно сделать нулевым, но код всё равно оценивают по мейннет-стандартам, и разница в шестьдесят тысяч газа — реальные деньги при вызове finish.

Как проверить

В отчёте есть до и после: количество SLOAD в get_total уменьшилось с 2N+1 до трёх, газ finish на двадцати участниках упал с примерно 180 000 до 120 000. Числа снимаются в Remix на вкладке с газом, а не берутся из статьи.

Типичная ошибка

Заменить uint на uint8 «для экономии»: в памяти и в стеке это не экономит, а в структуре без упаковки добавляет операции приведения типов и может увеличить газ. Правильный вариант — измерить газ до и после и показать разницу.

Что видит эксперт

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

Шаг 2.5.2

Делаем

Второй блок: error NotOwner(); вместо строк в require — экономит около пятидесяти газа на отказ и уменьшает байткод; хранение двух динамических массивов внутри структуры заменить на события и mapping(uint256 => mapping(address => uint256)) contributions; immutable для адресов из конструктора; calldata вместо memory для строковых параметров внешних функций.

Зачем

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

Как проверить

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

Типичная ошибка

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

Что видит эксперт

Эксперт проверяет, что оптимизация не сломала возврат средств: прогон провального сбора после правок обязателен. Он сверяет размер байткода с лимитом в 24 КБ.

Действие 2.6. Автотесты на create_user, participate и finish

Шаг 2.6.1

Делаем

Разворачиваем Hardhat в папке проекта: npm init -y, npm i -D hardhat @nomicfoundation/hardhat-toolbox, npx hardhat init с выбором JavaScript-проекта. В hardhat.config.js ставим solidity: "0.8.0" с оптимизатором на 200 прогонов и сеть hardhat по умолчанию. Контракт кладём в contracts/Contract.sol, тесты — в test/contract.test.js. Проверяем, что версия Node не ниже 18.

Зачем

Тесты — последний пункт модуля А, и они требуют именно автоматизированной проверки трёх функций: create_user, participate, finish. Без зафиксированной версии компилятора тесты могут пройти локально и не собраться у эксперта, поэтому версия в конфиге повторяет задание.

Как проверить

npx hardhat compile проходит без ошибок, в artifacts/contracts появились ABI и байткод. npx hardhat test запускается и показывает 0 passing на пустом наборе — окружение готово. Если компилятор скачивается заново, значит версия в конфиге не совпала с локальной.

Типичная ошибка

Ставить solidity: "^0.8.0": Hardhat подтянет последнюю 0.8.x, и поведение проверок переполнения будет отличаться от того, что вы описали в отчёте. Разница проявится на тесте с переполнением, а не при сборке.

Что видит эксперт

Эксперт запускает npx hardhat test у себя: конфиг должен подниматься без сети и без установки дополнительных зависимостей. Он смотрит, что версия компилятора в конфиге совпадает с заданием.

Шаг 2.6.2

Делаем

Пишем блок describe("create_user") с тремя тестами: успешная регистрация — после вызова logins("ivan") равен адресу вызывающего, users(addr) возвращает (0, "ivan"); повторная регистрация с тем же логином — revertedWith("Логин уже занят"); повторная регистрация того же адреса с другим логином — фиксируем текущее поведение и помечаем тест it.skip с комментарием, что это известный дефект из отчёта по логике.

Зачем

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

Как проверить

npx hardhat test показывает 2 passing и 1 pending в этом блоке. Ожидаемые значения в expect записаны явно, без assert.ok(true) и без проверки только факта отсутствия реверта. Если pending больше одного, значит часть тестов пропущена без объяснения.

Типичная ошибка

Писать тест, который проверяет только expect(tx).to.not.be.reverted: он проходит и при неверной записи в маппинг, то есть не проверяет ничего. На защите такой тест считается отсутствующим, и проверка исчезает из покрытия.

Что видит эксперт

Эксперт читает ассерты: проверка конкретных значений logins и users — признак настоящего теста, а не декорации. Он просит показать, что тест падает на исходной версии контракта.

Шаг 2.6.3

Делаем

Блок participate: создаём заявку через ask_to_donate с целью 10 eth и дедлайном now + 3600. Тест 1 — взнос 1 eth от второго аккаунта увеличивает get_total(0) до 1 eth и баланс контракта до 1 eth. Тест 2 — participate(0, { value: 0 }) откатывается с «Взнос должен быть больше нуля». Тест 3 — после finish вызов participate откатывается с «Сбор завершён».

Зачем

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

Как проверить

Три passing. В первом тесте сверяются и get_total, и provider.getBalance(contract.target) — числа должны совпадать до wei. Отдельно проверьте, что в sender[0] записан адрес плательщика, а не организатора.

Типичная ошибка

Проверять только get_total, не сверяя баланс: ошибка в value.push при верном массиве сумм останется незамеченной и всплывёт на защите. Проверять вызов без await expect(...).to.be.revertedWith, ловя любую ошибку: тогда тест проходит и на неверной причине отказа.

Что видит эксперт

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

Шаг 2.6.4

Делаем

Блок finish: тест 1 — не организатор вызывает finish, ожидается «Только организатор может завершить сбор»; тест 2 — сбор 12 eth при цели 10 eth, организатор получает 12 eth, баланс контракта 0, status true; тест 3 — сбор 5 eth при цели 10 eth, каждый участник получает взнос обратно, баланс 0; тест 4 — повторный finish откатывается с «Сбор уже завершён». Затем npx hardhat coverage и скриншот отчёта в папку задания.

Зачем

Четыре теста покрывают обе ветки и защиту от повторного вызова — ровно то, что просят в задании. Coverage даёт цифру для отчёта: по функциям обычно выходит 100%, по строкам 90–95%, и эта цифра подтверждает, что тесты не декоративные. Если coverage ниже 90%, в отчёте видно, какая ветка осталась непроверенной.

Как проверить

Четыре passing, в coverage по контракту функции 100%, строки не ниже 90%. Балансы сверяются через changeEtherBalances, а не прямым сравнением, чтобы газ не ломал тест. Если строки ниже 90%, добавьте тест на возврат при нулевом сборе.

Типичная ошибка

Сравнивать баланс организатора напрямую: газ съест часть суммы, и тест упадёт на верном контракте. Вторая ошибка — не сохранить скриншот coverage: результат модуля проверяют по файлу. Без скриншота покрытие нечем подтвердить, и пункт закрыт наполовину.

Что видит эксперт

Эксперт открывает отчёт coverage: непокрытые строки в finish сразу показывают, какая ветка не тестировалась. Он просит назвать тест, который покрывает ветку возврата.

Задача 3. Модуль Б: приватная сеть на geth и система «Безопасное дорожное движение»Модуль Б · 1 ч 30 мин

Полтора часа на самую объёмную часть: поднять приватный Ethereum на geth, завести пять аккаунтов, выдать банку 1000 eth прямо в генезис-блоке и написать контракт, в котором водитель регистрируется, добавляет удостоверение, платит штраф и получает страховку, а ДПС подтверждает документы, выписывает штрафы и отмечает ДТП. Считаемая часть — формула страхового взноса: её надо перевести в целые числа без потери точности, иначе расчёт разойдётся с примером из задания на десятые доли eth, а вместе с ним и вся демонстрация.

Схема: Задача 3. Модуль Б: приватная сеть на geth и система «Безопасное дорожное движение»

Действие 3.1. Поднять аккаунты и кошелёк

Шаг 3.1.1

Делаем

Проверяем установку: geth version должен показать 1.13.x или новее. Создаём каталог ~/chain и пять аккаунтов: geth --datadir ~/chain account new пять раз, каждый раз вводя пароль дважды и записывая его в passwords.txt в том же порядке. Получаем адреса: банк, страховая, ДПС, водитель-деплоер, резервный для выдачи стартовых балансов. Каталог ~/chain создаём до первого вызова, иначе geth создаст его сам с другими правами.

Зачем

Аккаунты — фундамент всей работы: адрес банка пойдёт в генезис-блок с балансом 1000 eth, и если перепутать порядок, банком окажется не тот аккаунт, а исправлять это придётся пересозданием цепи. Пароли в файле рядом нужны потому, что personal.unlockAccount требует их на каждый вызов, и ручной ввод тридцати раз съедает десять минут из девяноста.

Как проверить

В ~/chain/keystore пять файлов вида UTC--..., geth account list выводит пять адресов. В passwords.txt пять строк, порядок совпадает с порядком создания аккаунтов. Если файлов четыре, значит один вызов прервался на вводе пароля.

Типичная ошибка

Создать аккаунты без --datadir и получить их в ~/.ethereum: цепь будет искаться не там, и geth init создаст второй набор файлов. Вторая ошибка — один пароль на все аккаунты без записи: восстановить забытый пароль нельзя, и аккаунт с 1000 eth станет недоступен.

Что видит эксперт

Эксперт смотрит geth account list и сверяет число аккаунтов с таблицей адресов: пять адресов, каждый подписан именем пользователя. Он просит показать файл с паролями: он должен лежать рядом, а не в переписке.

Шаг 3.1.2

Делаем

Выписываем адреса в accounts.txt с подписями: BANK, INSURANCE, DPS, DRIVER1 (Иванов), DRIVER2 (Семенов). Эти же адреса сразу вносим в заготовку таблицы 3 из задания — так она заполняется по ходу, а не восстанавливается в последние пять минут. Проверяем каждый адрес: 42 символа, начинается с 0x, чек-сумма не нарушена. Адреса копируем из вывода geth account list, а не из кошелька.

Зачем

Таблица 3 — обязательный результат модуля В, и в ней пять строк: банк, Иванов, Семенов, Петров, Романов. Если адреса не записаны в момент создания, к демонстрации их придётся искать по журналу транзакций, а Петров и Романов появляются уже в ходе записи видео.

Как проверить

В accounts.txt пять строк вида ИМЯ=0x..., все адреса уникальны, длина каждого ровно 42 символа. Копия файла лежит в папке задания рядом с контрактом. Если адрес короче 42 символов, при копировании потерялась цифра.

Типичная ошибка

Копировать адреса из вывода консоли вручную: одна перепутанная цифра — и eth.getBalance вернёт 0 там, где ожидается 1000 eth, а вы будете искать ошибку в генезисе, которой нет. На сверку адресов потом уходит половина модуля В.

Что видит эксперт

Эксперт сверяет адрес банка в таблице 3 с полем alloc в genesis.json: совпадение — обязательное условие зачёта модуля. Он проверяет, что в таблице нет двух одинаковых адресов.

Шаг 3.1.3

Делаем

В MetaMask добавляем сеть: RPC URL http://127.0.0.1:8545, Chain ID 1337, символ ETH, блок-эксплорер пустой. Импортируем пять аккаунтов по приватным ключам, которые достаём из keystore через geth account export или чтением JSON с паролем. Переименовываем аккаунты в MetaMask по именам: Банк, Страховая, ДПС, Иванов, Семенов. Ключи импортируем по одному и сразу переименовываем аккаунт.

Зачем

Демонстрация в модуле В идёт через личный кабинет, а личный кабинет — это MetaMask с выбранным аккаунтом: если имена не совпадают с таблицей 2, эксперт не поймёт, чей экран ему показывают. Chain ID фиксируем одинаково в генезисе и в кошельке, иначе транзакции уйдут в другую сеть.

Как проверить

В MetaMask пять аккаунтов с именами, сеть Localhost 1337, баланс банка 1000 ETH, у остальных 0. Переключение аккаунта меняет адрес в шапке кошелька. Если баланс банка в MetaMask нулевой, проверьте chainId: кошелёк смотрит в другую сеть.

Типичная ошибка

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

Что видит эксперт

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

Действие 3.2. Генезис-блок с банком на 1000 eth

Шаг 3.2.1

Делаем

Пишем genesis.json: chainId 1337, homesteadBlock, eip155Block, eip158Block, byzantiumBlock, constantinopleBlock, petersburgBlock, istanbulBlock, berlinBlock и londonBlock — все 0, gasLimit 0x1c9c380 (30 000 000), difficulty 0x1, alloc с адресом банка и балансом 0x3635C9ADC5DEA00000 — это 1000 eth в wei. Страховую в alloc не добавляем: её баланс должен быть 0, и это проверяется на демонстрации.

Зачем

1000 eth банка задаются именно в генезисе, потому что задание требует этого на старте системы: другого способа выдать сумму до первого блока нет. 0x3635C9ADC5DEA00000 — это 10^21 wei, и ошибка в одном разряде даёт либо 100 eth, либо 10 000 eth, что видно уже на первом шаге демонстрации.

Как проверить

Проверка арифметики: python3 -c "print(int('0x3635C9ADC5DEA00000',16)/1e18)" печатает 1000.0. JSON валиден: python3 -m json.tool genesis.json не выдаёт ошибок. Если в выводе 1000.0, разрядность верна.

Типичная ошибка

Указать баланс в eth ("balance": "1000") вместо wei: geth прочитает 1000 wei, и банк получит ноль. Вторая ошибка — забыть londonBlock 0 и получить расхождение по baseFee с текущей версией geth. Вы ищете ошибку в контракте, которой там нет.

Что видит эксперт

Эксперт открывает genesis.json и проверяет три поля: chainId, alloc, gasLimit — это первое, что смотрят при защите приватной сети. Он просит объяснить, почему баланс задан в wei, а не в eth.

Шаг 3.2.2

Делаем

Инициализируем цепь: geth --datadir ~/chain init genesis.json, затем запускаем geth --datadir ~/chain --networkid 1337 --http --http.addr 127.0.0.1 --http.port 8545 --http.api eth,net,web3,personal,miner --http.corsdomain "*" --allow-insecure-unlock --nodiscover --mine --miner.etherbase <адрес деплоера>. Во втором окне подключаемся: geth attach ~/chain/geth.ipc.

Зачем

Без --http.api personal не заработает personal.unlockAccount, а без него нельзя подписывать транзакции из консоли — на этом теряют время почти все. --allow-insecure-unlock нужен, потому что geth по умолчанию запрещает разблокировку по HTTP, а --mine включает мгновенную добычу блока на одном аккаунте, чтобы транзакции подтверждались за секунду.

Как проверить

В консоли eth.blockNumber растёт, eth.getBalance("<банк>") возвращает 1000000000000000000000, eth.getBalance("<страховая>") — 0, net.version равно 1337. Если net.version пустое, запуск без --networkid ушёл в сеть по умолчанию.

Типичная ошибка

Запустить без --mine: транзакции висят в txpool и не попадают в блок, а вы решаете, что контракт не деплоится. Вторая ошибка — --http.api без personal: разблокировка вернёт ошибку «account unlock with HTTP access is forbidden».

Что видит эксперт

Эксперт смотрит команду запуска: наличие personal в списке API и allow-insecure-unlock — признак того, что сеть поднималась осознанно. Он проверяет, что каталог данных указан в каждом вызове.

Шаг 3.2.3

Делаем

Проверяем стартовое состояние до деплоя: eth.getBalance по банку = 1e21 wei, по страховой = 0, eth.blockNumber = 1 после первого блока, eth.getBlock("latest").baseFeePerGas = 0. Если сеть уже использовалась, удаляем каталог ~/chain/geth (keystore сохраняем) и инициализируем заново — демонстрация начинается с балансов 1000 и 0. После переинициализации проверяем, что keystore не тронут.

Зачем

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

Как проверить

Три вызова в консоли дают ровно: 1000000000000000000000, 0 и число блоков не больше двух. baseFeePerGas последнего блока равно 0. Если банк показывает 0, значит адрес в alloc не совпал с адресом аккаунта.

Типичная ошибка

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

Что видит эксперт

Эксперт просит показать баланс банка до начала демонстрации: 1000 ETH на экране — точка отсчёта для всех дальнейших расчётов. Он просит показать, что страховая действительно с нулём.

Действие 3.3. Контракт: структуры, роли, штрафы, страховка, ДТП

Шаг 3.3.1

Делаем

Пишем Traffic.sol: struct Driver { string fio; uint license; uint licenseExpiry; string category; uint stageStart; uint accidents; uint unpaidFines; bool insured; uint insurancePaid; } и struct Vehicle { string category; uint price; uint age; }, плюс mapping(uint => Driver) drivers, mapping(uint => Vehicle) vehicles, mapping(uint => address) licenseOwner, mapping(address => uint) balances. Ключ по номеру удостоверения, а не по адресу.

Зачем

Номер удостоверения — единственный идентификатор, который есть у сотрудника ДПС по заданию: и штраф, и отметка о ДТП оформляются по номеру водительского удостоверения. Маппинг licenseOwner даёт обратную связь номера и адреса и позволяет проверять уникальность: по нему отклоняется попытка добавить занятый номер.

Как проверить

Компилятор 0.8.0 собирает файл, в ABI есть drivers(uint256) и licenseOwner(uint256). В структуре водителя присутствуют все семь характеристик из задания, включая год начала стажа и количество неоплаченных штрафов.

Типичная ошибка

Хранить водителя по адресу и искать штраф перебором: на демонстрации issueFine(111) не найдёт владельца, потому что по номеру ничего не проиндексировано. Штраф уходит в никуда, а демонстрация останавливается на шаге 10.

Что видит эксперт

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

Шаг 3.3.2

Делаем

Добавляем роли: address public bank; address public insurance; address public dps; в конструкторе и modifier onlyDps() { require(msg.sender == dps, "Только сотрудник ДПС"); _; }. Функции: registerDriver(string fio, uint stageStart, uint accidents) создаёт запись и начисляет 50 eth с резервного аккаунта, addLicense(uint number, uint expiry, string category) проверяет, что номер есть в таблице 1, что категория и дата совпадают с таблицей, и что licenseOwner[number] == address(0).

Зачем

Проверка по таблице 1, а не по календарю, — принципиальный момент: в таблице есть просроченные удостоверения (000 до 11.01.2024, 444 до 10.05.2025), и если отклонять их по дате, шаг 6 демонстрации с удостоверением 444 не пройдёт. ДПС проверяет, что документ есть в базе и поля заполнены верно, — это и есть сверка с таблицей.

Как проверить

addLicense(111, ...) от Иванова проходит; повторный вызов с тем же номером от другого адреса откатывается с «Удостоверение уже привязано к другому водителю»; addLicense(999, ...) — с «Удостоверения с таким номером нет в базе».

Типичная ошибка

Проверять срок через block.timestamp: удостоверение 444 с датой 10.05.2025 в 2026 году окажется просроченным, демонстрация встанет на шаге 6, и контракт придётся переписывать в прямом эфире. Переписывать контракт в прямом эфире — потеря двадцати минут и половины модуля Б.

Что видит эксперт

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

Шаг 3.3.3

Делаем

Реализуем штрафы: issueFine(uint license, uint amount) onlyDps создаёт запись с суммой, временем выдачи и флагом оплаты и увеличивает unpaidFines; payFine(uint fineId) payable требует ровно 10 ether или 5 ether, если block.timestamp - issuedAt <= 25 (пять дней по пять секунд), переводит сумму на адрес банка через call с проверкой результата, обнуляет долг и уменьшает счётчик неоплаченных.

Зачем

Задание фиксирует две цифры: штраф 10 eth и скидка вдвое при оплате в первые пять дней, а один день равен пяти секундам. Отсюда окно 25 секунд: если считать пять дней как 5×86400, скидка не сработает никогда, и на демонстрации оплата покажет 10 eth вместо 5, а сверка с балансом банка не сойдётся.

Как проверить

Тест: штраф выписан, оплата через 10 секунд — списано 5 eth, банк получил 5 eth; оплата через 30 секунд — 10 eth. unpaidFines уменьшился на единицу в обоих случаях. Если списано 10 eth при оплате через 10 секунд, окно скидки считается неверно.

Типичная ошибка

Проверять msg.value >= 5 ether без верхней границы: водитель заплатит 6 eth, и разница останется в контракте навсегда. Вторая ошибка — отправлять штраф на адрес страховой вместо банка: по заданию все штрафы идут в банк.

Что видит эксперт

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

Шаг 3.3.4

Делаем

Пишем calcPremium(uint license) public view returns (uint): берём Vehicle владельца, считаем int delta = 10 - int(v.age); if (delta < 0) delta = -delta; и premium = int(v.price) * delta / 100 + int(d.unpaidFines) * 2e17 + int(d.accidents) * 1e18 - int(stage()) * 2e17 с проверкой, что результат больше нуля. Функция requestInsurance показывает сумму, confirmInsurance payable принимает ровно premium и переводит его страховой.

Зачем

Формула из задания в целых числах: Рс*(|1 – Сэ/10|)*0,1 — это price*|10-age|/100, дальше плюс 0,2 за каждый штраф, плюс 1 за каждое ДТП, минус 0,2 за каждый год стажа. Проверка на примере из КЗ (30 eth, возраст 2, 2 штрафа, 1 ДТП, стаж 5) должна дать 2.8 eth: другой ответ означает ошибку в коэффициенте, и вся демонстрация страховки развалится.

Как проверить

calcPremium для набора из примера возвращает 2800000000000000000 wei. Для Семенова (30 eth, возраст 2, 0 штрафов, 0 ДТП, стаж 5) — 1.4 eth; для Дмитриева — число, которое вы заранее вписали в сценарий.

Типичная ошибка

Считать в uint без знака: 10 - age при возрасте больше десяти уходит в минус и роняет транзакцию с Panic(0x11), поэтому нужен int или отдельная ветка. Вторая ошибка — не проверять отрицательный итог: при стаже 30 лет и дешёвой машине премия уходит в минус.

Что видит эксперт

Эксперт подставляет числа из примера задания в вашу функцию: 2.8 eth — единственный правильный ответ. Он просит посчитать в уме: 2.4 + 0.4 + 1 − 1 = 2.8.

Шаг 3.3.5

Делаем

Реализуем ДТП: registerAccident(uint license) onlyDps увеличивает accidents и, если insured, выплачивает владельцу десятикратный взнос через call; если на счету страховой не хватает — вызывает borrowFromBank(amount), который переводит недостачу с адреса банка и пишет debt. Функция repayBank() при поступлении взносов гасит долг: переводит банку минимум из баланса и долга.

Зачем

Задание прямо описывает механику займа: страховая занимает у банка без процентов, когда не хватает на выплату, и возвращает автоматически при поступлении денег. Десятикратный размер взноса — тоже цифра из КЗ: при взносе 1.4 eth выплата 14 eth, а на старте у страховой 0 eth, поэтому первый же страховой случай обязательно уходит в займ.

Как проверить

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

Типичная ошибка

Платить фиксированные 10 eth вместо десяти взносов: при взносе 0.35 eth это 3.5 eth, и цифры в демонстрации не сойдутся с формулой. Вторая ошибка — не вести debt и «одалживать» каждый раз заново: банк теряет 1000 eth быстрее, чем это объяснимо.

Что видит эксперт

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

Действие 3.4. Компиляция, деплой и стартовые данные

Шаг 3.4.1

Делаем

Компилируем: solc --version должен показать 0.8.0, затем solc --bin --abi --optimize --optimize-runs 200 -o build Traffic.sol. Проверяем размер байткода: wc -c build/Traffic.bin — меньше 49 152 символов hex, то есть меньше 24 КБ, иначе контракт не влезет в лимит EIP-170. ABI сохраняем в build/Traffic.abi. Если solc не найден, ставим 0.8.0 через solc-select и повторяем.

Зачем

Версия компилятора влияет на байткод и на поведение проверок переполнения: если собрать 0.8.20, а эксперт повторит сборку на 0.8.0, адрес контракта и расход газа изменятся. Лимит 24 КБ — реальное ограничение: контракт с пятью функциями и тремя структурами подходит к нему близко, и оптимизатор здесь не косметика.

Как проверить

solc --version показывает 0.8.0+commit, размер .bin меньше 49 152 символов, в каталоге build лежат Traffic.abi и Traffic.bin, оба читаются. Если .bin тяжелее лимита, включаем оптимизатор с меньшим числом прогонов и пересобираем.

Типичная ошибка

Собрать в Remix и скопировать байткод оттуда: версия компилятора в Remix может оказаться 0.8.30, и solc в консоли даст другой результат — сверка с экспертом не сойдётся. Байткод и адрес у эксперта выйдут другими, и повторить ваш деплой он не сможет.

Что видит эксперт

Эксперт просит показать solc --version и размер байткода: два числа, которые нельзя подделать. Он просит показать, что оптимизатор включён и прогонов ровно 200.

Шаг 3.4.2

Делаем

Деплоим из консоли geth: personal.unlockAccount(eth.accounts[0], "пароль", 0), затем var abi = [...]; var bin = "0x..."; var factory = eth.contract(abi); var traffic = factory.new({from: eth.accounts[0], data: bin, gas: 5000000}, "пароль"); и ждём адрес в traffic.address. Альтернатива — Remix с окружением Injected Provider и сетью Localhost 1337. Адрес контракта дописываем в accounts.txt.

Зачем

Деплой в приватную сеть — обязательный пункт модуля Б: без адреса контракта в сети модуль В нечем демонстрировать. Газ 5 000 000 берём с запасом, потому что конструктор пишет три адреса и создаёт маппинги, а на приватной цепи с нулевым baseFee запас ничего не стоит.

Как проверить

eth.getCode(traffic.address) возвращает строку длиннее 0x6000, сам адрес — 42 символа. В eth.getTransactionReceipt поле status равно 0x1. Если status равен 0x0, транзакция откатилась и кода по адресу нет.

Типичная ошибка

Деплоить с газом 3 000 000 и получить out of gas: транзакция спишется, кода по адресу не будет, а traffic.address останется пустым, и вы потратите блок на диагностику вместо работы. Объяснять это на камеру бессмысленно, а время уходит.

Что видит эксперт

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

Шаг 3.4.3

Делаем

Засеваем стартовое состояние: Иванов (удостоверение 111, стаж с 2024, 0 ДТП, 50 eth), Семенов (222, стаж с 2021, 0 ДТП, 50 eth), Петров (без удостоверения, стаж с 2016, 3 ДТП, 50 eth). Проверяем 50 eth у каждого и 0 у страховой. Отдельно фиксируем в журнале, что у Петрова удостоверение не заполнено, а неоплаченных штрафов ноль. Каждого водителя проверяем отдельным вызовом drivers.

Зачем

Задание перечисляет трёх стартовых водителей с точными данными: Иванов — сотрудник ДПС и одновременно водитель со стажем 2 года, Семенов — стаж 5 лет, Петров — без удостоверения, стаж 10 лет, 3 ДТП. Эти числа потом входят в формулу страховки, и если стаж записан как год начала, а не как количество лет, премия вырастет в десять раз.

Как проверить

drivers(111).stageStart = 2024, drivers(222).stageStart = 2021, у Петрова accidents = 3, балансы по 50 eth, у страховой 0. У Петрова licenseOwner для его внутреннего id не заполнен. Если у Петрова стоит номер удостоверения, шаг 5 демонстрации потеряет смысл.

Типичная ошибка

Записать стаж числом лет и потом вычитать год: 2024 как «стаж 2024 года» даст отрицательную премию. Хранить надо год начала и считать текущий год минус год начала. Премия считается отрицательной, что видно на первом же расчёте.

Что видит эксперт

Эксперт сверяет трёх стартовых водителей с заданием построчно: ФИО, номер удостоверения, стаж, ДТП, баланс. Он просит назвать год начала стажа каждого из трёх.

Шаг 3.4.4

Делаем

Документируем код до финальной сборки: к каждой публичной функции — NatSpec-блок с @notice, @param и @return, к структурам — комментарий о смысле полей, в README — раздел «Архитектура»: роли, схема данных, формула штрафа и формула взноса. Комментарии пишем по-русски, одна строка — одна мысль, без пересказа очевидного. Комментарии пишем в том же проходе, что и код.

Зачем

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

Как проверить

У каждой публичной функции есть @notice и @param, в README три раздела: запуск, роли, формулы. Проверка простая: человек, не видевший код, по README поднимает сеть и повторяет демонстрацию без ваших подсказок.

Типичная ошибка

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

Что видит эксперт

Эксперт открывает комментарий к issueFine: единицы в wei, права onlyDps и событие — три вещи, которые должны быть названы в двух строках. И просит показать README целиком.

Задача 4. Модуль В: записать демонстрацию и сдать работуМодуль В · 30 мин

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

Схема: Задача 4. Модуль В: записать демонстрацию и сдать работу

Действие 4.1. Подготовить запись и сценарий

Шаг 4.1.1

Делаем

Настраиваем запись: OBS Studio или ffmpeg -f x11grab -video_size 1920x1080 -framerate 30 -i :0.0 out.mp4 с захватом микрофона. Разрешение 1920×1080, шрифт в терминале 16–18 pt, консоль geth и MetaMask в половине экрана каждый. Делаем пробную запись на тридцать секунд и смотрим, читаются ли адреса и суммы. Проверяем, что в кадр не попадает панель уведомлений.

Зачем

Модуль оценивается по видео: если адрес из 42 символов нечитаем, работу не проверят, даже когда контракт идеален. Тридцать секунд пробы стоят меньше минуты и спасают весь модуль, а перезапись на конкурсе обычно невозможна — время на неё не выделено. Поэтому проба идёт до записи, а не после.

Как проверить

На пробном кадре видны и адрес контракта, и сумма в MetaMask, звук без эха и щелчков. Файл пишется в MP4, размер за три минуты — около 100 МБ. Если звук пишется в отдельный файл, сведите дорожки до загрузки.

Типичная ошибка

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

Что видит эксперт

Эксперт смотрит видео целиком: читаемость адресов и балансов — первое, на что он обращает внимание. Он просит показать пробный кадр до начала основной записи, а не после.

Шаг 4.1.2

Делаем

Раскладываем таблицу 2 на четырнадцать пунктов и держим перед глазами: банк 1000, страховая 0, регистрация Романова, удостоверения 222, 333, 444, страховки Дмитриева и Семенова, баланс страховой, штраф 111, ДТП 111, штраф 555, оплата Романовым, финальные балансы. Напротив каждого пункта пишем ожидаемое число, чтобы во время записи не считать в уме.

Зачем

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

Как проверить

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

Типичная ошибка

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

Что видит эксперт

Эксперт сверяет видео с таблицей 2 по номерам: отсутствие пункта фиксируется как невыполненное действие. Он отмечает каждый пункт, который не подтверждён экраном.

Шаг 4.1.3

Делаем

Приводим MetaMask в порядок: имена аккаунтов по пользователям, сеть Localhost 1337, одинаковый nonce (0 на чистой цепи). Для Романова и Дмитриева создаём аккаунты заранее и записываем адреса: регистрация в кадре должна идти с нуля, но кошелёк уже существует. У банка на экране 1000 ETH, у остальных 0. Пароли при этом в кадр не попадают: окно ввода закрываем до старта записи.

Зачем

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

Как проверить

В MetaMask восемь аккаунтов с именами: Банк, Страховая, ДПС, Иванов, Семенов, Петров, Романов, Дмитриев. Адреса Романова и Дмитриева уже вписаны в заготовку таблицы 3. Если nonce больше нуля, цепь не чистая — перезапустите её до записи.

Типичная ошибка

Создавать аккаунт на камеру: MetaMask показывает seed-фразу, и её нельзя показывать в записи, кроме того на это уходит две-три минуты. Вторая ошибка — забыть переименовать аккаунт и показывать «Account 7».

Что видит эксперт

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

Действие 4.2. Провести демонстрацию по таблице 2

Шаг 4.2.1

Делаем

Пункты 1–3: показываем баланс банка (1000 ETH) и страховой (0), затем от аккаунта Романова регистрируем его с данными из задания: стаж 6 лет, 1 ДТП, 0 неоплаченных штрафов, 50 eth на счету. В кабинете видны ФИО, стаж, ДТП и баланс, удостоверение не указано. Пятьдесят eth начисляем с резервного аккаунта, а не с банка, иначе баланс банка на шаге 14 не сойдётся.

Зачем

Первый пункт — точка отсчёта: эксперт запоминает 1000 и 0 и дальше сверяет все изменения относительно этих чисел. Если стартовые балансы не показаны, дальнейшие суммы ничего не доказывают, и модуль теряет половину смысла. Без этих двух чисел вся дальнейшая арифметика повисает в воздухе.

Как проверить

На экране последовательно: 1000 ETH у банка, 0 у страховой, затем кабинет Романова с заполненными полями и пустым номером удостоверения. Баланс резервного аккаунта уменьшился на 50 eth. Если резервный аккаунт не уменьшился, деньги пришли из другого места.

Типичная ошибка

Выдать стартовые 50 eth из банка: банк станет 950, и финальная сверка на шаге 14 даст неверную сумму, а объяснять расхождение в записи некому. Правильно — выдать стартовые суммы из резерва до записи, это заметно по первому же кадру.

Что видит эксперт

Эксперт сверяет данные Романова с таблицей 2: стаж 6 лет и 1 ДТП — цифры, по которым потом считается его страховка. Стаж 6 и 1 ДТП дают премию, отличную от нуля.

Шаг 4.2.2

Делаем

Пункты 4–6: от Романова добавляем удостоверение 222 — контракт отказывает, потому что 222 уже привязано к Семенову, и в кабинете появляется сообщение об отказе. Затем от Петрова добавляем 333 (категория A, до 13.02.2030) — успех. Затем от Романова добавляем 444 (B, до 10.05.2025) — успех, в кабинете появляются номер, категория и срок действия. Каждый шаг комментируем вслух.

Зачем

Отказ на 222 — не сбой, а доказательство работы проверки уникальности: в таблице 1 номер 222 закреплён за Семеновым, и задание сознательно ставит этот шаг перед успешным. Если отказа не показать, эксперту не видно, что проверка вообще есть, — это минус по критерию работы ДПС.

Как проверить

Три сообщения подряд: отказ по 222 с текстом про занятый номер, затем два успешных добавления. В кабинете Петрова категория A, у Романова B и дата 10.05.2025. Если отказ не появился, проверка уникальности не реализована.

Типичная ошибка

«Исправить» демонстрацию, дав Романову 222 вместо 444: тогда не видно ни проверки уникальности, ни работы ДПС, и два пункта таблицы 2 остаются без доказательства. К тому же 444 проверяет работу с просроченной датой.

Что видит эксперт

Эксперт ждёт именно отказа на 222: это единственный шаг, где проверяется негативный сценарий подтверждения документа. Его пропуск стоит баллов по двум критериям сразу.

Шаг 4.2.3

Делаем

Пункты 7–9: от Дмитриева оформляем страховку — показываем расчёт премии по его данным, подтверждаем оплату, баланс уменьшается на сумму взноса. От Семенова оформляем вторую: 30 eth, возраст 2 года, 0 штрафов, 0 ДТП, стаж 5 лет, премия 1.4 eth. В конце показываем баланс страховой — он равен сумме двух взносов. Комментируем каждое слагаемое формулы вслух.

Зачем

Страховка — единственное место, где видно работу формулы из задания, и эксперт проверяет арифметику на экране. Семенов удобен тем, что его данные дают ровно 1.4 eth: 30 × |1 − 0.2| × 0.1 = 2.4, минус 0.2 × 5 лет стажа = 1.4, и это легко проверить в уме.

Как проверить

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

Типичная ошибка

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

Что видит эксперт

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

Шаг 4.2.4

Делаем

Пункты 10–14: ДПС выписывает штраф по удостоверению 111, затем отмечает ДТП по 111 — страховка у Иванова не оплачена, поэтому выплаты нет, но счётчик ДТП увеличивается. Дальше попытка выписать штраф по 555 заканчивается отказом: номера нет в системе. поскольку штрафа у Романова ещё нет, выписываем ему штраф по 444 как дополнительный функционал и сразу оплачиваем: в первые 25 секунд списывается 5 eth, банк получает их, и в конце показываем балансы страховой и банка.

Зачем

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

Как проверить

Пять сообщений и три баланса: отказ по 555, списание 5 eth у Романова, плюс 5 eth у банка, счётчик ДТП у Иванова вырос на единицу, выплата по нему не произведена. Если банк получил 10 eth, оплата прошла после 25 секунд — окно скидки работает.

Типичная ошибка

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

Что видит эксперт

Эксперт сверяет баланс банка в конце: 1000 + 5 = 1005 ETH, если штраф оплачен со скидкой, и 1010 при оплате после 25 секунд. Разница в 5 eth — доказательство работы скидки.

Действие 4.3. Сдать таблицу адресов, инструкцию и видео

Шаг 4.3.1

Делаем

Заполняем таблицу 3: банк, Иванов, Семенов, Петров, Романов — напротив каждого адрес из accounts.txt. Рядом кладём README на одну страницу: версия geth и solc, команда инициализации, команда запуска, адрес контракта, порядок демонстрации. Инструкция пишется так, чтобы по ней работу можно было повторить с нуля на другой машине. Инструкцию пишем по шагам, с командами в обратных кавычках.

Зачем

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

Как проверить

В таблице пять строк, все адреса совпадают с MetaMask и accounts.txt посимвольно. В README есть все пять команд: init, запуск, компиляция, деплой, подключение консоли. Если адрес в README отличается от таблицы, считайте это ошибкой сдачи.

Типичная ошибка

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

Что видит эксперт

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

Шаг 4.3.2

Делаем

Делаем финальный прогон записи одним куском, без склеек: старт с чистой цепи, четырнадцать пунктов, финальные балансы, таблица адресов на экране. Имя файла — по шаблону организаторов, например Блокчейн_СТУДЕНТЫ_Фамилия.mp4. Проверяем длительность: три-пять минут, звук ровный, все суммы читаемы, затем загружаем в указанное место и дублируем на флешку.

Зачем

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

Как проверить

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

Типичная ошибка

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

Что видит эксперт

Эксперт смотрит первые тридцать секунд и последние тридцать: по ним видно, есть ли стартовое состояние и финальная сверка, — остальное он проверяет по таблице 2.

Специалист

работающие профессионалы
Конкурсное задание · СпециалистPDF · 971 КБ

Выдержка из официального конкурсного задания: страницы, относящиеся к категории «Специалист» (стр. 5–6, 17–23 источника).

Пошаговое решение

Категория «Специалисты» — то же задание, что у студентов, плюс две добавки: код нужно задокументировать и покрыть тестами. Три часа делятся на модуль А (1 час аналитики по чужому контракту), модуль Б (1 час 30 минут на приватную сеть geth и систему «Безопасное дорожное движение») и модуль В (30 минут на видео). В модуле А разбирается листинг на 86 строк под Solidity 0.8.0: двенадцать синтаксических ошибок, четыре логические, пробелы в контроле доступа и вопросы оптимизации газа — на каждый пункт свой отчёт. В модуле Б появляются числа, на которых всё проверяется: банк со 1000 eth, страховая с нулём, три водителя по 50 eth, штраф 10 eth со скидкой 5 eth в первые пять дней (один день равен пяти секундам) и страховой взнос по формуле с примером 2,8 eth. Дальше — тесты на create_user, participate и finish, README, инструкция запуска и 14 пунктов таблицы 2 на видео.

Схема к заданию

Задача 1. Поднять листинг из КЗ до компиляции и описать функционалМодуль А · 13 баллов (синтаксис 8, функционал 5)

Модуль А начинается не с правок, а с фиксации исходного состояния: в КЗ лежит контракт Contract на 86 строк, в котором ошибки идут каскадом — пока не исправлены объявления хранилищ, компилятор не читает тела функций. Задача — довести файл до чистой сборки на компиляторе 0.8.0, ничего не меняя в структурах User и Donation, и оформить два отчёта: по синтаксису с номерами строк и по функционалу. Здесь же снимаются первые 13 баллов из 40 за модуль А.

Схема: Задача 1. Поднять листинг из КЗ до компиляции и описать функционал

Действие 1.1. Зафиксировать исходник и получить список ошибок

Шаг 1.1.1

Делаем

Забираем листинг из КЗ (контракт Contract, 86 строк — от pragma до финальной скобки) и сохраняем его в файл Contract_original.sol: именно с ним потом сверяется каждый пункт отчёта, поэтому копию не трогаем до сдачи. Рядом создаём рабочую копию Contract.sol и открываем её в Remix или в VS Code с расширением Solidity, включив нумерацию строк — все отчёты модуля А требуют ссылок вида «строка 41». Сразу снимаем скриншот панели компилятора с числом ошибок до правок: это доказательство, что работу начали с исходника.

Зачем

Пункт 1 модуля А сформулирован как «исправьте синтаксические ошибки», а отчёт по синтаксису оценивают по номерам строк: без сохранённого исходника через сорок минут номера помнятся приблизительно, и часть из 8 баллов теряется на формальности. Копия страхует и от случайной автозамены: восстановить 86 строк по памяти невозможно, а переписывать листинг из PDF — это десять минут из часа модуля А.

Как проверить

В папке участника лежат Contract_original.sol ровно на 86 строк и Contract.sol с той же нумерацией. Откройте original и проверьте две опорные строки: первая — pragma solidity >0.5.0, пятая — mapping(string >> address) public logins. Если нумерация сдвинулась, листинг скопирован не полностью.

Типичная ошибка

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

Что видит эксперт

Эксперт заходит в папку в первые минуты модуля и фиксирует наличие исходника и рабочей копии; дальше он сверяет номера строк в отчёте именно с вашим original-файлом.

Шаг 1.1.2

Делаем

Выставляем в компиляторе ровно ту версию, которую требует КЗ — 0.8.0: в Remix это пункт 0.8.0+commit.c7dfd78e в списке Solidity compiler, в Hardhat — solidity: {version: «0.8.0»}. EVM version оставляем Istanbul, оптимизатор на этапе правок выключаем, чтобы видеть все предупреждения. Нажимаем Compile: прагма >0.5.0 на 0.8.0 проходит молча, поэтому первую ошибку даст строка 5 с мэппингом, а расхождение версии с КЗ вы фиксируете сами — в отчёте.

Зачем

В КЗ сказано прямо: контракт написан под компилятор 0.8.0, и проверка синтаксиса идёт на нём; на 0.6.x часть ошибок выглядит иначе, а ** и checked-арифметика ведут себя по-другому, поэтому отчёт получится про другой код. Кроме того, деплой в модуле Б пойдёт с тем же компилятором, и расхождение версий даст разный байткод — это ловится при сверке артефактов.

Как проверить

В панели компилятора стоит 0.8.0, тип компиляции — single file, и список ошибок получен именно для Contract_original.sol. Отсутствие предупреждения про версию ничего не доказывает: >0.5.0 на 0.8.0 собирается, поэтому соответствие КЗ проверяется глазами по первой строке.

Типичная ошибка

Решить, что прагма в порядке, раз компилятор молчит: >0.5.0 собирается на 0.8.0, но КЗ требует зафиксировать версию, и это отдельный пункт отчёта. Вторая ошибка — включить оптимизатор до правок: часть предупреждений о неиспользуемых переменных пропадёт, и останется незамеченным, что локальная uint value в ask_to_donate не заполняется.

Что видит эксперт

Эксперт проверяет версию по скриншоту и по файлу конфигурации; на категории «Специалисты» это отдельный пункт, потому что версия определяет все дальнейшие выводы отчётов.

Шаг 1.1.3

Делаем

Проходим вывод компилятора построчно и заводим таблицу из четырёх колонок: строка, текст ошибки, тип (синтаксис или типы), что меняем. Однотипные ошибки собираем вместе: >> вместо => в строках 5 и 6 — один пункт отчёта, а login[login] в строке 40 и User(FIO, msg.sender.balance, login) в строке 41 — разные, хотя стоят рядом. Таблицу ведём в том же файле, из которого потом вырастет отчёт по синтаксису.

Зачем

Полнота таблицы прямо конвертируется в баллы: каждая найденная и исправленная ошибка — часть блока из 8 баллов, а ошибка, исправленная в коде, но не описанная в отчёте, баллов не приносит, потому что проверить её нечем. Группировка по типам нужна и для защиты: вопрос «почему здесь =>» должен получать ответ про синтаксис мэппинга, а не «компилятор сказал».

Как проверить

В таблице не меньше десяти строк, и каждая ссылается на строку из original-файла. Сверьтесь с выводом компилятора: если он ругается на строку 40, а в таблице её нет — записано не всё, и это видно эксперту за десять секунд.

Типичная ошибка

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

Что видит эксперт

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

Действие 1.2. Исправить прагму, мэппинги и объявления хранилищ

Шаг 1.2.1

Делаем

Меняем первую строку на pragma solidity ^0.8.0. Именно каретка, а не >0.8.0: ^0.8.0 разрешает 0.8.x и запрещает 0.9, а КЗ фиксирует компилятор 0.8.0, на котором решение обязано собираться. Если хотите жёстче — допустима запись pragma solidity 0.8.0: она привязывает контракт к точной версии и защищает от сюрпризов при пересборке на чужой машине. В отчёте это строка 1.

Зачем

Прагма — единственная строка, которая определяет, какая арифметика будет в контракте: в 0.8 включены проверки переполнения, и total += value падает при переполнении вместо тихого обнуления, как было до 0.8. В отчёте это пункт «строка 1: ограничен диапазон версии сверху», он входит в блок синтаксиса на 8 баллов и проверяется первым делом — эксперт открывает файл и смотрит на первую строку.

Как проверить

Прагма в файле — ^0.8.0, и вторая прагма не появилась. Компилятор на неё не жалуется ни до, ни после правки, поэтому проверять нужно глазами: сравните строку 1 с требованием КЗ, а не с выводом компилятора.

Типичная ошибка

Оставить >0.5.0: файл собирается на 0.8.0, ошибки не будет, но требование КЗ не выполнено, и пункт отчёта про версию теряет баллы. Вторая ошибка — pragma solidity >=0.8.0 без верхней границы: формально допустимо, но расплывчатая фиксация версии снижается в оценке.

Что видит эксперт

Проверяет первую строку в файле и в отчёте; на вопрос «почему каретка» ждёт ответ про 0.8.x и запрет 0.9. Если участник не может объяснить выбор версии, балл за отчёт снижается: от неё зависит вся дальнейшая арифметика в контракте.

Шаг 1.2.2

Делаем

Правим объявления хранилищ: mapping(string >> address) public logins и mapping(address >> User) public users получают нормальную стрелку =>. Дальше решаем то, чего компилятор не подскажет: logins — справочник «логин → адрес», он должен читаться снаружи, поэтому public оставляем; users отдаёт структуру целиком, и для приватности его лучше сделать private, а чтение вынести в отдельную функцию get_user.

Зачем

>> — это побитовый сдвиг, а не разделитель типа и имени, поэтому парсер видит бессмысленную конструкцию и валит весь контракт, а не одну строку: пока не исправлены оба мэппинга, остальные сообщения компилятора читать бессмысленно. Публичный users дополнительно раскрывает баланс любого адреса — в отчёте по информационной безопасности это отдельный пункт из блока на 6 баллов.

Как проверить

После правки ошибки в строках 5–6 исчезают и появляются следующие по порядку — признак, что парсер прошёл дальше. Раскройте вкладку с ABI: logins виден как функция, а users — только если вы сознательно оставили его публичным.

Типичная ошибка

Заменить >> на => только в одной строке: компилятор сообщит про вторую, и минута уйдёт на её поиск. Вторая ошибка — оставить users публичным не подумав: вы сами не заметите уязвимость, которую эксперт найдёт при чтении отчёта по безопасности.

Что видит эксперт

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

Шаг 1.2.3

Делаем

Разбираемся с хранилищем заявок: в листинге объявлено Donation donation, а используется она как массив — donation.push, donation[donation_id], donation.length. Меняем объявление на Donation[] public donation; саму структуру Donation при этом не трогаем, КЗ это прямо запрещает. Внутри ask_to_donate локальная uint value тоже становится массивом: uint[] memory value = new uint[](0); иначе её нельзя передать в конструктор структуры.

Зачем

Запрет на изменение структур данных — жёсткое условие задания: правка полей User или Donation обнуляет модуль А независимо от качества остального кода, и это первое, что проверяют на защите. Объявление переменной-массива структурой не является, его менять можно и нужно: без массива метода push не существует, и весь сбор средств не работает.

Как проверить

После правки donation.length и donation[0] компилируются, а структура Donation совпадает с КЗ поле в поле: donate_id, name, user, amount, deadline, sender, value, status, info. Сравните со строками 24–35 задания построчно — две минуты, которые экономят весь модуль.

Типичная ошибка

«Починить» хранение, добавив поле в Donation: компилируется, но это прямое нарушение КЗ, и эксперт снимает блок целиком. Вторая ошибка — оставить uint value скаляром: конструктор структуры примет её вместо uint[], и вы получите ошибку типов уже в строке 421, потратив время на поиск не там.

Что видит эксперт

Сверяет структуру с КЗ по полям и типам, а на специалистах дополнительно смотрит, объяснил ли участник в отчёте, почему менял объявление, а не структуру.

Действие 1.3. Исправить тела функций

Шаг 1.3.1

Делаем

Правим create_user: login[login] = msg.sender превращается в logins[login] = msg.sender — обращение к мэппингу, а не к строковому параметру. Конструктор User(FIO, msg.sender.balance, login) не соответствует объявлению struct User{uint balance; string login;}: порядок и количество полей другие, поэтому пишем users[msg.sender] = User(msg.sender.balance, login). ФИО терять нельзя — заводим mapping(address => string) public fio и заполняем его той же транзакцией.

Зачем

Это ядро регистрации: без правильного мэппинга логин не привязывается к адресу, вход в систему по логину не работает, а без ФИО не собирается таблица 3 соответствия адресов, которую требуют в конце демонстрации. В отчёте по функционалу на 5 баллов нужно описать ровно это: функция пишет в два хранилища, и почему одно поле вынесено наружу.

Как проверить

Вызовите create_user из Remix с логином ivanov и ФИО Иванов Иван Иванович, затем прочитайте logins(ivanov) — должен вернуться ваш адрес, users(адрес) — структура с балансом и логином, fio(адрес) — ФИО. Три чтения подряд и есть проверка регистрации.

Типичная ошибка

Оставить login[login]: компилятор скажет «Indexed expression has to be a type, mapping or array», и функция не соберётся, а вы потеряете время на чтение невнятного сообщения. Вторая ошибка — «подогнать» структуру под вызов, переставив поля: это изменение структуры и прямое нарушение КЗ.

Что видит эксперт

Смотрит, что структура не изменена, а данные не потеряны; на защите может попросить показать, где хранится ФИО, и ждёт внятного ответа про отдельный мэппинг.

Шаг 1.3.2

Делаем

Правим перевод средств: adr_to.transfering(msg.sender) — метода transfering в Solidity не существует, а аргументом должна быть сумма, а не адрес. Корректно так: function send_money(address payable adr_to) public payable { require(msg.value > 0, «send_money: value is zero»); (bool ok, ) = adr_to.call{value: msg.value}(«»); require(ok, «send_money: transfer failed»); }. Проверку на нулевую сумму добавляем сразу, иначе пустая транзакция проходит и жжёт газ впустую.

Зачем

call с value — единственный способ отправить эфир в 0.8, и любая опечатка в имени метода валит компиляцию; при этом call предпочтительнее transfer, потому что transfer передаёт получателю только 2300 газа и ломает контракты с логикой в receive. В отчёте по безопасности это пункт про совместимость и повторный вход, он входит в 6 баллов блока ИБ.

Как проверить

Функция собирается, в ABI помечена как payable, а тестовый вызов с msg.value = 1 eth уменьшает баланс отправителя и увеличивает баланс получателя ровно на 1 eth за вычетом газа. Проверяйте именно разницу балансов по адресам, а не только статус транзакции.

Типичная ошибка

Заменить на adr_to.transfer(msg.sender) и оставить как есть: transfer существует, поэтому компилятор может пропустить, но функция попытается отправить адрес как сумму — в 0.8 это ошибка типов, и вы получите её через десять минут поиска. Вторая ошибка — не проверить msg.value > 0 и позволить пустые переводы.

Что видит эксперт

Смотрит, используется ли call с проверкой результата, и спрашивает, почему не transfer; ответ про 2300 газа — то, что ждут на категории «Специалисты».

Шаг 1.3.3

Делаем

Дочищаем остальные ошибки: function get_donation_number() public view return(uint) получает returns (uint), donation.len() — donation.length, donation[donation_id].data — donation[donation_id].info, потому что поля data в структуре нет. В get_total меняем total = donation[donation_id].value[i] на total += ...: иначе возвращается только последнее пожертвование, а не сумма всех.

Зачем

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

Как проверить

Компилятор выдаёт ноль ошибок и ноль предупреждений о неиспользуемых переменных. Прогоните чтение: get_donation_number возвращает количество заявок, get_total по заявке с двумя взносами по 1 eth возвращает 2 eth, а не 1.

Типичная ошибка

Оставить total = ...: тесты на finish будут проходить странно — сбор никогда не достигает цели, — и вы потратите полчаса на поиск ошибки в цикле, где её нет. Вторая ошибка — заменить .data на .info только в одном из двух мест: в get_donation_2 или в объявлении.

Что видит эксперт

Проверяет, что после правок не осталось предупреждений, и выборочно спрашивает смысл изменённых строк — особенно += в get_total. Именно эта замена показывает, читал ли участник код или правил по подсказкам компилятора.

Действие 1.4. Оформить отчёт по синтаксису и по функционалу

Шаг 1.4.1

Делаем

Собираем отчёт по синтаксису: таблица на три колонки — номер строки в исходном листинге, что было, что стало и почему. Формулировки технические и короткие: «строка 5: mapping(string >> address) → mapping(string => address); >> — побитовый сдвиг, а не разделитель типа и имени». Одинаковые по смыслу правки (два мэппинга, два обращения к массиву) описываем отдельными строками, потому что номера строк разные.

Зачем

Отчёт — самостоятельный результат модуля А: 8 баллов за синтаксис ставят по таблице, а не по файлу, и требование КЗ «указать, в какой строке и какое именно изменение внесли» означает, что фраза «исправил ошибки» не засчитывается вообще. Таблица же защищает от спора: эксперт видит вашу логику, а не догадывается о ней.

Как проверить

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

Типичная ошибка

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

Что видит эксперт

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

Шаг 1.4.2

Делаем

Пишем отчёт по функционалу: по каждому контракту и каждой функции — что делает, что читает, что пишет, кто может вызвать. Формат — таблица: функция, назначение, изменяемые данные, ограничения доступа. Отдельным блоком описываем структуры User и Donation: какие поля, зачем нужны, что означает status и почему sender и value — параллельные массивы. Такой отчёт потом переносится в README почти без переписывания.

Зачем

Отчёт по функционалу стоит 5 баллов и проверяет понимание кода, а не умение его компилировать: здесь видно, разобрался ли участник, что status — признак закрытия сбора. Этот же отчёт потом экономит время в модуле В: половина комментариев к видео берётся отсюда, и их не нужно придумывать под запись.

Как проверить

В таблице перечислены все десять функций файла: create_user, get_balance, send_money, ask_to_donate, participate, get_donation, get_donation_2, get_donation_number, get_total, finish. Для каждой заполнены четыре колонки, и хотя бы у трёх указано «только владелец» или «любой адрес».

Типичная ошибка

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

Что видит эксперт

Сверяет список функций с файлом и спрашивает, что вернёт get_donation_2 и почему в ней два массива; ответ «список участников и сумм» — половина балла за пункт.

Шаг 1.4.3

Делаем

Финальный шаг модуля А: собираем контракт с оптимизатором на 200 запусков, сохраняем ABI и байткод в файлы Contract.abi и Contract.bin, снимаем скриншот панели компилятора с зелёной галочкой и строкой «Compilation successful». Скриншот называем Compile_ok.png и кладём в папку участника рядом с отчётами, а не в «Изображения». Проверьте, что на скриншоте видна строка версии компилятора, а не только список файлов.

Зачем

ABI и байткод понадобятся в модуле Б для деплоя в geth: если пересобирать контракт на другом компиляторе или без оптимизатора, адрес и газ изменятся, и результаты тестов разойдутся с демонстрацией. Скриншот — доказательство сборки на 0.8.0, его смотрят при спорных оценках и при проверке соответствия артефактов.

Как проверить

Contract.abi содержит десять функций; события появляются только если вы их добавили, и тогда видны в разделе events. Байткод начинается с 0x60806040. На скриншоте читаются версия компилятора, имя файла и сообщение об успехе — проверьте, открыв файл, а не на глаз в момент съёмки.

Типичная ошибка

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

Что видит эксперт

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

Задача 2. Разобрать логику, проверки, безопасность и оптимизациюМодуль А · 22 балла (логика 8, проверки 4, ИБ 6, оптимизация 4)

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

Схема: Задача 2. Разобрать логику, проверки, безопасность и оптимизацию

Действие 2.1. Починить жизненный цикл заявки

Шаг 2.1.1

Делаем

Разбираем состояния заявки по полям структуры: status = false — сбор открыт, status = true — закрыт и рассчитан. В finish строка donation[donation_id].status = false должна стать true, иначе заявку можно закрывать бесконечно и каждый раз выплачивать деньги заново. Рисуем на бумаге три состояния и переходы: создана, собирает, закрыта — и подписываем, какая функция делает каждый переход.

Зачем

Логика — 8 баллов, самая весомая часть аналитики: ошибка со статусом не синтаксическая, компилятор её не видит, а последствие — повторная выплата из того же пула, то есть прямая потеря средств. КЗ требует не только указать ошибку, но и предложить устранение: фраза «присваивать true и проверять статус до перевода» и есть нужное предложение.

Как проверить

После правки повторный вызов finish с тем же donation_id возвращает revert с сообщением про закрытый сбор, а статус в get_donation читается как true. Проверяйте оба признака — и отказ, и значение статуса, потому что они могут разойтись при неверной ветке.

Типичная ошибка

Оставить status = false: демонстрация «финиш дважды» проходит успешно два раза, и эксперт фиксирует ошибку прямо на защите, снимая баллы сразу за логику и за тестирование. Вторая ошибка — проверять status == false в participate и при этом закрывать сбор значением false: условия противоречат друг другу, и сбор блокируется навсегда.

Что видит эксперт

Просит показать, где меняется статус, и проверяет, что запись происходит до перевода средств; порядок операций в finish — его основной вопрос по этому блоку.

Шаг 2.1.2

Делаем

Правим условие закрытия: if (total ** 2 >= donation[donation_id].amount) — ** в Solidity это возведение в степень, поэтому при total = 3 сравнивается 9 с суммой сбора, а при total = 10 — уже 100. Логика задания другая: сбор закрывается, когда собрано не меньше запрошенного, значит if (total >= donation[donation_id].amount). Если по заданию нужен порог с запасом, он задаётся явным коэффициентом, а не оператором степени.

Зачем

Степень вместо сравнения — тихая ошибка: код компилируется, тесты на малых суммах проходят, и только на реальных числах расчёт становится неверным. В отчёте по логике это отдельный пункт с арифметикой: покажите на числах, что при amount = 10 eth и total = 4 eth условие с ** даёт ложь, но и при total = 4 сбор закрывать нельзя — а при total = 11 условие истинно случайно.

Как проверить

Прогоните три случая: total < amount (возврат средств), total = amount (выплата), total > amount (выплата, остаток остаётся на контракте). Во всех трёх статус после finish равен true, а балансы меняются ровно на собранную сумму.

Типичная ошибка

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

Что видит эксперт

Просит объяснить, что делает ** в 0.8 и почему условие неверно; ждёт числовой пример, а не общую фразу про логику. Если участник путает степень и умножение, вопрос переходит на всю арифметику в контракте.

Шаг 2.1.3

Делаем

Правим цикл возврата: for (uint i = 0; i > donation[donation_id].value.length; i++) не выполнится ни разу, потому что условие противоположно направлению счёта. Меняем на i < ..., а длину массива кэшируем в локальную переменную uint len = donation[donation_id].value.length — это и логика, и экономия газа на каждом шаге. Внутри цикла адрес берём из sender[i], сумму — из value[i], индексы обязаны совпадать.

Зачем

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

Как проверить

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

Типичная ошибка

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

Что видит эксперт

Смотрит, кэшируется ли длина массива, и спрашивает, что будет при 500 участниках; ответ про блок-газ и необходимость pull-подхода — признак уровня специалиста.

Действие 2.2. Заполнить проверки и выстроить их порядок

Шаг 2.2.1

Делаем

Заполняем вместо шести заглушек «__________» осмысленные тексты по шаблону «кто — что — почему»: require(logins[login] == address(0), «create_user: login already taken»); require(msg.value > 0, «participate: donation must be greater than zero»); require(donation[id].status == false, «participate: donation is closed»). Пустой адрес пишем как address(0), а не как 42 нуля — короче и надёжнее при чтении.

Зачем

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

Как проверить

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

Типичная ошибка

Писать «error» или «not allowed»: эксперт не может отличить, какая проверка сработала, и снижает балл за блок. Вторая ошибка — менять условие require вместе с текстом: тогда проверка начинает запрещать правильные вызовы, и вы получаете отказ там, где его быть не должно.

Что видит эксперт

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

Шаг 2.2.2

Делаем

Дополнительно переводим проверки на кастомные ошибки 0.8: error LoginTaken(string login); и if (logins[login] != address(0)) revert LoginTaken(login);. Отчёт по проверкам при этом не отменяется: в нём показываем оба варианта — строку для require и кастомную ошибку — и объясняем, что выбрать в каком случае. Кастомные ошибки дешевле на деплое и в ревертах, но требуют поддержки в клиенте.

Зачем

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

Как проверить

В контракте объявлены ошибки, и все реверты используют их или require — смешивать без причины не стоит. В тестах при повторной регистрации логина ловится LoginTaken с переданным логином, а не общее «transaction reverted».

Типичная ошибка

Перевести всё на кастомные ошибки и забыть поправить тесты: они падают с «reverted without a reason», и вы теряете десять минут в модуле, где их нет. Вторая ошибка — оставить в контракте оба механизма без объяснения, из-за чего отчёт противоречит коду.

Что видит эксперт

Смотрит, есть ли в отчёте сравнение по газу и совместимости; за «сделал как модно» без обоснования полный балл не ставит. Хороший ответ — назвать цену деплоя и то, как ошибка читается в клиенте.

Шаг 2.2.3

Делаем

Выстраиваем порядок проверок в каждой функции: сначала аргументы (нулевой адрес, пустая строка, msg.value), потом права (msg.sender), потом состояние (status, дедлайн), и только затем внешние вызовы. В finish это выглядит так: владелец, статус, расчёт суммы, смена статуса, перевод. Каждую функцию проходим по списку и отмечаем, что проверено, а что нет.

Зачем

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

Как проверить

В каждой функции с внешним вызовом запись состояния стоит выше вызова, а проверки прав — выше записи. Просмотрите finish и send_money: в них виден порядок «проверка → эффект → взаимодействие» без перестановок.

Типичная ошибка

Проверять статус после перевода: тест на двойной финиш проходит, но в реальной сети транзакция с внешним вызовом может откатиться не полностью. Вторая ошибка — проверять msg.sender == root в функции, где root ещё не инициализирован.

Что видит эксперт

Читает функции сверху вниз и смотрит на последовательность строк; вопрос «почему статус меняется до перевода» — типовой на защите. Ответ должен звучать как схема checks-effects-interactions, а не как «так принято».

Действие 2.3. Провести аудит информационной безопасности

Шаг 2.3.1

Делаем

Разбираем повторный вход на примере finish: если сначала отправить эфир получателю, а статус поменять после, получатель-контракт может вызвать finish повторно из своего receive. Правим по схеме checks-effects-interactions — статус true до перевода — и дополнительно ставим модификатор nonReentrant с uint256 private _lock = 1 на все функции с переводом.

Зачем

Reentrancy — первая уязвимость, которую ищут в контрактах с переводами, и в отчёте по ИБ она стоит отдельных баллов из шести. На разборе важно показать не только исправление, но и сценарий атаки: контракт-получатель, его receive, повторный вызов finish — эксперты ждут именно этого, а не названия уязвимости.

Как проверить

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

Типичная ошибка

Поставить nonReentrant и оставить порядок «перевод → статус»: защита сработает, но объяснить, почему она нужна, вы не сможете, и балл будет частичным. Вторая ошибка — считать, что transfer с 2300 газа полностью закрывает проблему: газ может вырасти после изменения стоимости опкодов.

Что видит эксперт

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

Шаг 2.3.2

Делаем

Проверяем модель доступа: address root = msg.sender фиксирует владельца в момент деплоя — переносим это в конструктор constructor(){ root = msg.sender; } и помечаем immutable. Функциям, которые меняют чужие данные, добавляем модификатор onlyRoot: закрытие сбора, смена адресов банка и страховой, ручной вывод. Для системы «Безопасное дорожное движение» заводим отдельную роль mapping(address => bool) isDps и модификатор onlyDps.

Зачем

Отсутствие контроля доступа — самая дорогая уязвимость в отчёте по ИБ: любой адрес может закрыть чужой сбор и забрать деньги. В КЗ роли прописаны явно — водитель, сотрудник ДПС, страховая, банк, — поэтому в решении должна быть их техническая реализация, иначе контракт не соответствует заданию и модуль Б теряет баллы.

Как проверить

Вызов finish с чужого адреса возвращает revert, вызов от владельца проходит. Проверьте именно два адреса — владельца и посторонний: в Remix это два аккаунта в списке Account, и переключение между ними занимает секунду.

Типичная ошибка

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

Что видит эксперт

Проверяет, что каждая привилегированная функция защищена, и спрашивает разницу между msg.sender и tx.origin — вопрос почти обязательный. Заодно смотрит, не осталось ли публичных сеттеров для адресов банка и страховой.

Шаг 2.3.3

Делаем

Проверяем остальные риски и фиксируем их в отчёте: отправка через transfer ограничена 2300 газа и ломает контракты-получатели; цикл по массиву участников при большом N не влезет в блок-газ и заблокирует finish; массивы sender и value растут неограниченно, и чтение get_donation_2 со временем станет дорогим; строковое поле info хранится в каждом изменении состояния. Для каждого пункта пишем строку «риск — последствие — устранение».

Зачем

Отчёт по ИБ оценивают по полноте: 6 баллов распределены между контролем доступа, reentrancy, DoS по газу и обработкой внешних вызовов. Пункт про неограниченные массивы пропускают чаще всего, и он же чаще всего проявляется при демонстрации, когда транзакций становится больше десятка.

Как проверить

В отчёте не меньше четырёх рисков, у каждого есть конкретное последствие и способ устранения. Сверьте с кодом: если написано «используем call вместо transfer», в контракте должен стоять call, а не transfer, иначе отчёт противоречит файлу.

Типичная ошибка

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

Что видит эксперт

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

Действие 2.4. Оптимизировать контракт и замерить газ

Шаг 2.4.1

Делаем

Оптимизируем хранение: поля структуры Donation упаковываем по слотам — donate_id и status рядом, amount и deadline рядом, чтобы две переменные занимали один 32-байтовый слот. Параллельные массивы sender и value заменяем на mapping(uint256 => Contribution[]), если структуру менять нельзя — оставляем массивы, но убираем дублирование имени заявки через мэппинг хэшей. Каждое изменение допустимо только вне структур User и Donation.

Зачем

Оптимизация — 4 балла, и оценивают её по конкретным решениям с числами, а не по слову «оптимизировал». Упаковка слотов сокращает стоимость записи примерно на 20 000 газа за слот, а это прямые деньги при каждой регистрации; в отчёте нужна таблица «до — после» по газу, иначе пункт не засчитывается.

Как проверить

В контракте нет двух подряд идущих маленьких типов, которые можно объединить в слот. Замеры газа по create_user до и после упаковки отличаются, и разница записана в отчёт с указанием единиц — газа, не процентов «на глаз».

Типичная ошибка

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

Что видит эксперт

Смотрит, какие изменения допустимы по КЗ, и проверяет арифметику в отчёте по газу: цифры должны складываться с числом изменённых слотов. Упаковка, которая ломает структуру, для него хуже отказа от оптимизации.

Шаг 2.4.2

Делаем

Правим газ на уровне функций: строковые параметры принимаем как calldata вместо memory там, где они только читаются; root помечаем immutable; длину массивов в циклах кэшируем; вместо хранения вычисляемых значений используем view-функции. Каждое изменение проверяем замером: console2.log(gasleft()) в Hardhat или Gas Report в Remix. Замеры записывайте в тот же файл, где ведёте отчёт по оптимизации.

Зачем

Эти четыре приёма дают вместе 5–10% экономии на вызовах и почти ничего не стоят по сложности — именно поэтому они ожидаются в решении специалиста. В отчёте по оптимизации важен эффект: строка «calldata вместо memory в ask_to_donate — минус 1 200 газа» весит больше страницы теории про память и хранилище.

Как проверить

В сигнатурах внешних функций строки объявлены как calldata, в цикле нет повторного обращения к donation[id].value.length. Замеры до и после сведены в таблицу с одинаковыми условиями: одна и та же транзакция, один и тот же аккаунт, один и тот же компилятор.

Типичная ошибка

Заменить memory на calldata в функции, которая модифицирует строку: компилятор выдаст ошибку, и вы потеряете время на её разбор. Вторая ошибка — мерить газ на разных входных данных и делать вывод об оптимизации: числа несравнимы, и эксперт это увидит.

Что видит эксперт

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

Шаг 2.4.3

Делаем

Собираем таблицу замеров: функция, газ до оптимизации, газ после, что изменили. Меряем три функции — create_user, participate, finish — на одинаковых входных данных, по три прогона, и берём медиану. Таблицу вставляем в отчёт по оптимизации и упоминаем в презентации одной фразой с числом, чтобы эксперт услышал подтверждение. Числа берите из трёх прогонов одной и той же транзакции, а не из разных сценариев.

Зачем

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

Как проверить

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

Типичная ошибка

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

Что видит эксперт

Может попросить повторить замер; ждёт, что участник помнит порядок чисел, а не только вывод «стало дешевле». Если числа не воспроизводятся, он снимает балл за оптимизацию, но оставляет балл за отчёт по газу.

Задача 3. Покрыть контракт тестамиМодуль А · 5 баллов (тестирование)

КЗ требует автоматизированную проверку трёх функций: create_user(), participate() и finish(). Пять баллов ставят не за количество тестов, а за то, что они ловят ошибки: успешный сценарий без негативного ничего не доказывает. Поэтому на каждую функцию пишется пара «проходит / отклоняется», плюс проверка изменения балансов — именно она обнаруживает расхождение между учётом и деньгами.

Схема: Задача 3. Покрыть контракт тестами

Действие 3.1. Собрать каркас тестов

Шаг 3.1.1

Делаем

Разворачиваем Hardhat в отдельной папке tests рядом с контрактом: npm init -y, npm i -D hardhat @nomicfoundation/hardhat-toolbox, npx hardhat init с выбором JavaScript-проекта. В hardhat.config.js прописываем solidity: {version: «0.8.0», settings: {optimizer: {enabled: true, runs: 200}}} — те же настройки, что при деплое, иначе газ в тестах не совпадёт с сетью.

Зачем

Тесты — 5 баллов, и КЗ требует именно автоматизированную проверку трёх функций: без каркаса проверять нечего. Версия компилятора в конфиге должна совпадать с модулем А, иначе один и тот же исходник даст другое поведение, и тесты будут проверять не тот контракт, который уйдёт в сеть.

Как проверить

npx hardhat compile собирает контракт без ошибок, в папке artifacts появляется Contract.json с ABI. npx hardhat test на пустом наборе завершается сообщением «0 passing» без падений — каркас готов к наполнению.

Типичная ошибка

Поставить hardhat-toolbox на Node ниже 18: установка формально проходит, но тесты падают на импорте ethers, и вы полчаса ищете ошибку в контракте. Вторая ошибка — оставить версию Solidity по умолчанию 0.8.24 и не заметить расхождения с модулем А.

Что видит эксперт

Смотрит конфиг и версию: несовпадение с модулем А — типовая причина, по которой тесты проходят, а контракт в сети ведёт себя иначе. Отдельно проверяет, что оптимизатор включён на 200 запусков, как при деплое.

Шаг 3.1.2

Делаем

Пишем фикстуру: в beforeEach деплоим контракт от owner и создаём адреса через ethers.getSigners() — владелец, участник, посторонний. Стартовые балансы фиксируем в переменные и после каждого теста сравниваем дельты, а не абсолютные значения. Отдельный хелпер deployFresh() поднимает новый экземпляр, чтобы тесты не зависели от порядка запуска. Фикстура пишется один раз и используется всеми тестами модуля.

Зачем

Изоляция тестов — то, за что дают баллы в блоке тестирования: если состояние перетекает из теста в тест, падение одного ломает остальные, и причину невозможно локализовать. Хелпер деплоя ещё и ускоряет работу: на тесты в модуле А остаётся меньше получаса, и тратить его на отладку фикстур нельзя.

Как проверить

Каждый тест начинается с чистого контракта: donation.length равен 0, балансы совпадают со стартовыми. Запустите набор дважды подряд — результат одинаковый, порядок тестов на него не влияет. Проверьте также, что beforeEach не оставляет открытых транзакций в pending.

Типичная ошибка

Деплоить контракт один раз в before и надеяться на порядок: второй тест на create_user упадёт из-за занятого логина, и вы будете искать ошибку в контракте, а не в тестах. Вторая ошибка — сравнивать абсолютные балансы с учётом газа: числа не сойдутся никогда.

Что видит эксперт

Смотрит, есть ли beforeEach и хелперы; отсутствие изоляции — минус ко всему блоку тестов, даже если сами проверки написаны верно. Ему важно, чтобы набор проходил дважды подряд без чистки состояния.

Шаг 3.1.3

Делаем

Добавляем хелперы времени: async function increaseTime(sec){ await network.provider.send(«evm_increaseTime», [sec]); await network.provider.send(«evm_mine»); }. Помним перевод из КЗ: 1 день = 5 секунд реального времени, значит скидочное окно в 5 дней — это 25 секунд, и в тесте пишем increaseTime(25), а не 432000. Константы заводим отдельно: FINE = 10 eth, FINE_DISCOUNT = 5 eth.

Зачем

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

Как проверить

После increaseTime(25) block.timestamp сдвинулся ровно на 25 секунд, после increaseTime(26) скидка не применяется. Оба случая — граница: скидка действует в первые 5 дней, то есть до 25-й секунды включительно.

Типичная ошибка

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

Что видит эксперт

Спрашивает, сколько секунд в конкурсном дне; ответ «пять» — обязательный минимум для специалиста, и он же проверяется в тестах. Если хелпер времени не используется, он смотрит, как тесты обходятся без скидки.

Действие 3.2. Написать тесты на три функции из КЗ

Шаг 3.2.1

Делаем

Пишем тесты на create_user: успешная регистрация (адрес появился в logins, ФИО записано, событие UserCreated с адресом и логином), повторный логин с другого адреса (ожидаем revert с нашим сообщением), пустой логин (revert), проверка, что balance в структуре соответствует msg.sender.balance на момент вызова. Четыре отдельных it(), каждый — одна проверка.

Зачем

create_user — первая из трёх функций, перечисленных в КЗ, и самая частая точка отказа при демонстрации: без неё не регистрируются Романов и Дмитриев из таблицы 2. В блоке из 5 баллов тесты на успех и на отказ должны быть парными: проверка только успешного пути не доказывает, что require работает.

Как проверить

npx hardhat test показывает 4 passing по create_user, ни один тест не помечен skip. В тесте на повторную регистрацию проверяется именно текст ошибки через revertedWith, а не просто факт падения транзакции.

Типичная ошибка

Проверять только успешную регистрацию: тест зелёный, а require на дубль логина не работает — на защите это видно с первого вызова. Вторая ошибка — сравнивать адрес как строку в разном регистре: ethers отдаёт checksum-адрес, и сравнение падает на пустом месте.

Что видит эксперт

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

Шаг 3.2.2

Делаем

Пишем тесты на participate: взнос 1 eth увеличивает total и длину массива value на 1, второй взнос суммируется, взнос 0 отклоняется с сообщением, взнос в закрытую заявку отклоняется, взнос в несуществующую заявку с id = 99 отклоняется. Каждый тест проверяет и состояние, и баланс контракта: expect(await contract.get_total(0)).to.equal(ethers.parseEther(«2»)).

Зачем

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

Как проверить

Тестов на participate не меньше пяти, сумма после двух взносов равна 2 eth, баланс контракта — тоже 2 eth. Тест на нулевой взнос возвращает ваше сообщение из require, а не общий revert. Тест на закрытую заявку создаёт её заранее, а не полагается на порядок тестов.

Типичная ошибка

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

Что видит эксперт

Просит показать тест, который упал бы при total = вместо +=; это проверка того, что тесты действительно ловят ошибки, а не просто выполняются. Дальше спрашивает, почему проверяется ещё и баланс контракта.

Шаг 3.2.3

Делаем

Пишем тесты на finish: не владелец вызывает — revert; владелец при недоборе — возврат каждому участнику; при достижении суммы — выплата владельцу; повторный finish — revert; проверка статуса после завершения (true). Отдельным тестом фиксируем изменение балансов через expect(...).to.changeEtherBalances([a, b], [1, 1]) — хелпер сам учитывает комиссию, и вручную газ вычитать не нужно.

Зачем

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

Как проверить

Минимум пять тестов на finish, все проходят. Тест на повторный вызов ловит сообщение про закрытый сбор, тест на возврат проверяет оба адреса участников. npx hardhat test в сумме даёт не меньше 14 passing.

Типичная ошибка

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

Что видит эксперт

Смотрит общее число тестов и наличие changeEtherBalances; просит назвать тест, который поймал бы ошибку со статусом. За 14 passing и полный набор отказов на finish ставит максимум по блоку.

Задача 4. Поднять приватный Ethereum на geth и задеплоить контрактМодуль Б · 32 балла (сеть и деплой 12, бизнес-логика 20)

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

Схема: Задача 4. Поднять приватный Ethereum на geth и задеплоить контракт

Действие 4.1. Собрать генезис-блок и инициализировать ноду

Шаг 4.1.1

Делаем

Готовим каркас сети: создаём папку node1 и файл genesis.json. В нём chainId 1515 (то же значение в networkId), consensus clique с параметрами {period: 5, epoch: 30000}, gasLimit «0x1c9c380» — это 30 000 000 газа на блок, и alloc с адресами аккаунтов. Период 5 секунд берём осознанно: он совпадает с конкурсным днём (1 день = 5 секунд), и скидка на штраф в демонстрации становится наглядной.

Зачем

Генезис-блок — фундамент модуля Б: в нём задаются балансы банка и страховой, и если их нет в alloc, то на старте системы 1000 eth у банка взять неоткуда, а без этого не работают ни штрафы, ни займы страховой. Clique с фиксированным периодом делает время предсказуемым — это нужно для проверки скидки в первые 5 дней.

Как проверить

JSON валиден (python3 -m json.tool genesis.json без ошибок), chainId и period на месте, в alloc ровно четыре адреса с балансами. Проверьте сумму: 1000 + 0 + 50 + 50 + 50 eth, записанных hex-строками в wei.

Типичная ошибка

Забыть chainId и получить конфликт с тестовой сетью в MetaMask: транзакции уходят не туда, а балансы «не меняются», и вы ищете ошибку в контракте. Вторая ошибка — period 0 или 1: блоки майнятся мгновенно, и правило «1 день = 5 секунд» перестаёт работать.

Что видит эксперт

Открывает genesis.json и сверяет chainId, period и alloc с заданием; отсутствие баланса банка — критичная ошибка всего модуля, а не отдельного пункта.

Шаг 4.1.2

Делаем

Записываем балансы в alloc в wei: банк — 1000 eth = 0x3635c9adc5dea00000, страховая — 0 (адрес указываем явно с нулевым балансом для наглядности), каждый водитель — 50 eth = 0x2b5e3af16b1880000. Адреса берём из заранее созданных аккаунтов geth (geth account new), а не придумываем: alloc должен ссылаться на реальные ключи, иначе деньги достанутся адресу без владельца.

Зачем

Балансы на старте — прямое требование КЗ: банк 1000 eth, страховая 0 eth, водители по 50 eth. Это же проверяется первыми двумя пунктами таблицы 2 при демонстрации, поэтому цифры в генезисе и на видео обязаны совпадать до wei, иначе эксперт видит расхождение сразу.

Как проверить

Пересчитайте hex в десятичные: 0x3635c9adc5dea00000 = 1000 × 10^18, 0x2b5e3af16b1880000 = 50 × 10^18. После запуска eth.getBalance по адресу банка возвращает ровно 1000 eth до первой транзакции. Адрес страховой должен присутствовать в alloc с нулевым балансом, иначе проверка «0 eth» ничего не доказывает.

Типичная ошибка

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

Что видит эксперт

Сверяет адреса в alloc с адресами аккаунтов в сети; подмена «демо-балансов» на скриншотах ловится именно так. Если банк показывает 1000 eth, он проверяет, что это баланс из генезиса, а не ручной перевод уже после запуска.

Шаг 4.1.3

Делаем

Инициализируем datadir: geth --datadir ./node1 init genesis.json. Команда должна завершиться строкой «Successfully wrote genesis state». После этого проверяем содержимое: в node1/geth появляются chaindata и lightchaindata, размер chaindata — единицы мегабайт. Каталог node1/keystore создаём заранее и храним там ключи, чтобы они не потерялись при переинициализации.

Зачем

Без init нода не стартует, а типовая ошибка — запустить geth с --datadir на пустой папке и получить сеть с другим генезисом, где балансов нет вовсе. Отдельный keystore нужен потому, что при повторном init с тем же genesis ключи сохраняются, а при новом генезисе адреса меняются, и вся таблица 3 устаревает.

Как проверить

Команда вернула успех, в node1/geth/chaindata есть файлы, geth --datadir ./node1 account list показывает ваши аккаунты. Если init сообщает «database already contains an incompatible genesis block» — datadir не пустой, его нужно очистить перед повторным init.

Типичная ошибка

Инициализировать не тот каталог и потом удивляться, что балансов нет: на экране всё выглядит рабочим, а сеть пустая. Вторая ошибка — менять genesis после init без очистки chaindata: нода не запустится, и вы потеряете десять минут на диагностику.

Что видит эксперт

Смотрит, что init выполнен на чистом datadir, и проверяет совпадение хэша генезис-блока с тем, что показывает нода. Ошибку «incompatible genesis block» он считает грубой: она означает перепутанные каталоги.

Шаг 4.1.4

Делаем

Создаём аккаунты: geth --datadir ./node1 account new, пароль вводим дважды и сохраняем в password.txt (права 600). Нужно минимум шесть адресов: банк, страховая, Иванов (он же ДПС), Семенов, Петров, резервный для Романова. После создания переносим адреса в genesis.json в alloc и переинициализируем ноду на чистом datadir — только так балансы попадут в генезис-блок.

Зачем

Порядок «аккаунты → alloc → init» критичен: адрес генезиса неизменяем, и добавить баланс в уже запущенную сеть нельзя. Если сделать наоборот, придётся удалять chaindata и начинать заново, а в модуле Б на это нет времени. Права 600 на файл пароля — требование безопасности, которое отмечают в отчёте по ИБ.

Как проверить

geth --datadir ./node1 account list показывает шесть адресов, каждый из alloc присутствует в списке keystore. Сверьте первые четыре и последние четыре символа каждого адреса: ошибка в одном символе — и баланс уйдёт не туда.

Типичная ошибка

Создать аккаунты после init и вписать их в alloc «для порядка»: genesis.json больше не перечитывается, и балансы не появятся ни у кого. Вторая ошибка — потерять пароль: разблокировать аккаунт при запуске будет невозможно, и все транзакции останутся неподписанными.

Что видит эксперт

Проверяет соответствие адресов alloc и keystore; пароль в командной строке — отдельный минус по безопасности. Ему важно, чтобы участник мог объяснить порядок «аккаунты, потом alloc, потом init».

Действие 4.2. Запустить ноду и подключить инструменты

Шаг 4.2.1

Делаем

Запускаем ноду в отдельном терминале: geth --datadir ./node1 --networkid 1515 --http --http.addr 127.0.0.1 --http.port 8545 --http.api eth,net,web3,personal,miner,txpool --http.corsdomain «*» --allow-insecure-unlock --mine --miner.etherbase <адрес> --unlock <адрес> --password password.txt --verbosity 3. Пароль держим в файле: в командной строке он попадёт в историю и в скриншоты.

Зачем

Флаги — самая частая причина, по которой Remix не видит сеть: без --http RPC не поднимается, без --http.api недоступны personal и miner, без --allow-insecure-unlock geth откажется разблокировать аккаунт по HTTP. Это техническая часть модуля Б на 12 баллов, и она проверяется фактом подключения, а не описанием в отчёте.

Как проверить

В логе видно «HTTP server started» и «Commit new sealing work», а запрос eth_blockNumber по адресу http://127.0.0.1:8545 возвращает растущий номер блока. Remix подключается через Web3 Provider к тому же адресу и показывает те же аккаунты с теми же балансами.

Типичная ошибка

Забыть --networkid: MetaMask подключается, но транзакции не проходят из-за несовпадения сети. Вторая ошибка — запустить без --mine и ждать подтверждения: блоки не создаются, транзакция висит в pending, и вы ищете ошибку в контракте.

Что видит эксперт

Проверяет подключение Remix к сети и номер блока; на демонстрации ждёт, что блоки идут с периодом 5 секунд. Если нода запущена без --mine, он видит это по висящей транзакции раньше, чем участник.

Шаг 4.2.2

Делаем

Проверяем сеть тремя запросами: eth_blockNumber (номер растёт), eth_accounts (видны разблокированные адреса), eth_getBalance по адресу банка — 1000 eth. Затем отправляем тестовый перевод 1 eth с аккаунта водителя на резервный адрес и убеждаемся, что транзакция попала в блок: eth.getTransactionReceipt(hash).blockNumber не null. Этот же скриншот потом идёт в отчёт.

Зачем

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

Как проверить

Номер блока увеличивается каждые 5 секунд, баланс банка ровно 1000 eth, тестовая транзакция имеет статус 0x1 и ненулевой blockNumber. Все три признака видны в geth attach или в консоли Remix без дополнительных инструментов.

Типичная ошибка

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

Что видит эксперт

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

Шаг 4.2.3

Делаем

Подключаем MetaMask к сети: RPC URL http://127.0.0.1:8545, Chain ID 1515, символ валюты ETH. Импортируем созданные ключи (через geth account export или приватные ключи из keystore) и переименовываем аккаунты по ролям: Банк, Страховая, Иванов, Семенов, Петров, ДПС. В Remix выбираем Environment → Injected Provider — MetaMask и проверяем, что адрес совпадает с выбранным в кошельке.

Зачем

Роли в демонстрации переключаются между аккаунтами, и без понятных имён вы будете путаться в hex-адресах, теряя время на записи и на объяснения. Кроме того, таблица 3 заполняется именно по этим именам, поэтому порядок наведения порядка в кошельке — часть подготовки к модулю В.

Как проверить

MetaMask показывает сеть с Chain ID 1515 и шесть аккаунтов с ожидаемыми балансами: 1000, 0, 50, 50, 50 eth и резервный. В Remix в списке Account видны те же адреса и суммы. Убедитесь также, что в MetaMask выбран именно этот аккаунт перед каждой транзакцией.

Типичная ошибка

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

Что видит эксперт

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

Действие 4.3. Скомпилировать и задеплоить контракт

Шаг 4.3.1

Делаем

Компилируем контракт из командной строки тем же solc 0.8.0: solc --optimize --optimize-runs 200 --bin --abi --overwrite -o build Contract.sol. Получаем Contract.bin и Contract.abi и сверяем с артефактами модуля А: байткод должен совпадать побайтово. Если разошёлся — значит в файле осталась несохранённая правка или другая версия оптимизатора. На сверку уходит минута.

Зачем

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

Как проверить

sha256sum Contract.bin совпадает с хэшем артефакта от модуля А, в ABI десять функций. Компилятор не выдаёт ни ошибок, ни предупреждений — предупреждения на этом этапе означают, что собран не тот файл.

Типичная ошибка

Собрать без --optimize, а деплоить версию с оптимизатором: адрес и код отличаются, и газовые замеры в отчёте становятся неверными. Вторая ошибка — оставить в папке build старые артефакты и задеплоить их, получив контракт без последних правок.

Что видит эксперт

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

Шаг 4.3.2

Делаем

Деплоим контракт одним из двух способов. В Remix: Environment Injected Provider, выбираем Contract из списка, конструктор без аргументов, Deploy, подтверждаем в MetaMask. Из скрипта: const f = new ethers.ContractFactory(abi, bytecode, signer); const c = await f.deploy(); await c.waitForDeployment(); — и адрес сохраняем в deploy.json. Второй способ предпочтительнее: адрес сразу попадает в скрипт инициализации.

Зачем

Деплой — центральный пункт модуля Б: без адреса контракта все демонстрационные действия невозможны, и 12 баллов за сеть и деплой ставятся по факту существования контракта в цепи. Скрипт даёт воспроизводимость: при том же nonce аккаунта адрес будет тем же, и таблица 3 не устареет при перезапуске сети.

Как проверить

Транзакция деплоя имеет статус success, eth.getCode(адрес) возвращает непустой код, первые байты 0x6080. В Remix в разделе Deployed Contracts функции видны по именам, а не как безымянные кнопки. Проверьте, что адрес в deploy.json совпадает с адресом из Remix, а не остался от прошлой попытки.

Типичная ошибка

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

Что видит эксперт

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

Шаг 4.3.3

Делаем

Фиксируем результат: адрес контракта, хэш транзакции, номер блока и адрес деплоера — в файл deploy.json и в README. Проверяем, что контракт виден в блокчейне: eth.getTransactionReceipt, eth.getCode, вызов view-функции get_donation_number возвращает 0. Только после этой проверки переходим к инициализации субъектов. Это занимает минуту и снимает половину вопросов на защите.

Зачем

Тройка «адрес — хэш — блок» нужна и для отчёта, и для защиты: эксперт может открыть сеть и убедиться, что контракт существует, а не нарисован на скриншоте. Нулевое значение get_donation_number подтверждает, что задеплоен чистый контракт, а не копия с прежними данными из прошлой попытки.

Как проверить

По адресу есть код, get_donation_number возвращает 0, в deploy.json заполнены три поля, номер блока деплоя меньше текущего. Скриншот консоли с этими тремя значениями — самый быстрый способ показать результат эксперту.

Типичная ошибка

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

Что видит эксперт

Сверяет адрес в README с адресом в сети; подмена адреса ставит под сомнение весь модуль, а не один пункт. Ему достаточно одного вызова get_donation_number, чтобы понять, тот ли это контракт и нет ли в нём старых данных.

Действие 4.4. Реализовать бизнес-логику системы

Шаг 4.4.1

Делаем

Инициализируем субъектов в порядке КЗ: банк (1000 eth), страховая (0 eth), затем водитель 1 Иванов Иван Иванович — удостоверение 111, стаж 2 года, 0 ДТП, 0 штрафов, 50 eth; водитель 2 Семенов Семен Семенович — 222, стаж 5 лет, 0 ДТП, 0 штрафов, 50 eth; водитель 3 Петров Петр Петрович — без удостоверения, стаж 10 лет, 3 ДТП, 0 штрафов, 50 eth. Роль ДПС выдаём Иванову отдельным вызовом: он одновременно водитель и сотрудник.

Зачем

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

Как проверить

Прочитайте состояние по каждому адресу: баланс банка 1000 eth, страховой 0, у Иванова права 111 и стаж 2, у Петрова прав нет и 3 ДТП. Это пять значений, которые видны в view-функциях — сверьте их с КЗ построчно.

Типичная ошибка

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

Что видит эксперт

Сверяет стартовые данные с КЗ; на специалистах ждёт, что старт системы выполняется скриптом или функцией initialize, а не десятью ручными транзакциями.

Шаг 4.4.2

Делаем

Реализуем расчёт страхового взноса: СтрВзн = Рс·|1 − Сэ/10|·0,1 + 0,2·Штр + ДТП − 0,2·Вс. Считаем в целых числах, без float: int256 unit = int256(1e18); int256 d = int256(10) - int256(exp); if (d < 0) d = -d; int256 base = int256(price) * d / 100; int256 premium = base + int256(fines) * 2 * unit / 10 + int256(dtp) * unit - int256(expYears) * 2 * unit / 10. Проверяем на примере КЗ: 30 eth, срок 2 года, 2 штрафа, 1 ДТП, стаж 5 — получается 2,8 eth.

Зачем

Формула — содержательный центр модуля Б: 20 баллов распределены между регистрацией, страховкой, штрафами и ДТП, а страховка считается только по ней. Модуль |1 − Сэ/10| нужен потому, что для машины старше 10 лет коэффициент снова растёт; забыть модуль — значит занизить взнос для старых автомобилей и получить отрицательное значение.

Как проверить

На числах из КЗ функция возвращает 2,8 × 10^18 wei. Проверьте ещё два случая: Сэ = 10 даёт нулевую базовую часть, Сэ = 12 даёт тот же коэффициент, что Сэ = 8. Значение не уходит в минус: если стаж большой, ставим require(premium > 0) и понятное сообщение.

Типичная ошибка

Считать в float: в Solidity нет чисел с плавающей точкой, и 0,1 * price не скомпилируется, а замена на деление до умножения даёт нулевой взнос. Вторая ошибка — потерять модуль и получить отрицательный коэффициент для машин старше десяти лет.

Что видит эксперт

Просит посчитать взнос для конкретного водителя вслух и сверить с контрактом; расхождение хотя бы на 0,1 eth — минус по страховому блоку. Отдельно спрашивает, что будет при стаже больше 10 лет и почему в формуле стоит модуль.

Шаг 4.4.3

Делаем

Реализуем штрафы: fine(vuNumber, reason) доступна только ДПС, создаёт запись с issuedAt = block.timestamp и суммой 10 eth; payFine(id) принимает ровно 10 eth, но если с момента выписки прошло меньше 25 секунд (5 конкурсных дней × 5 секунд), сумма 5 eth. В payFine переводим средства на адрес банка и уменьшаем счётчик неоплаченных штрафов у водителя.

Зачем

Штраф — единственный источник пополнения банка, и правило скидки проверяется на демонстрации: по таблице 2 штраф по удостоверению 111 выписывается, а по 555 оплачивается Романовым. Если скидка считается по реальным суткам, оплата в демонстрации всегда будет полной, и баллы за функционал снимаются как за невыполненный пункт.

Как проверить

Штраф, оплаченный через 20 секунд, списывает 5 eth; через 30 секунд — 10 eth. Баланс банка увеличивается ровно на сумму штрафа, счётчик неоплаченных у водителя уменьшается на единицу. Оба числа видны в view-функциях без разбора транзакций.

Типичная ошибка

Считать 5 дней как 432 000 секунд: в конкурсе это 24 часа реального времени, скидка не срабатывает никогда, и пункт демонстрации провален. Вторая ошибка — принимать любую сумму: недоплата проходит, штраф остаётся неоплаченным, а деньги списаны.

Что видит эксперт

Спрашивает, сколько секунд в конкурсном дне, и проверяет, что оплата идёт на адрес банка, а не на адрес ДПС. Скидку он проверяет на границе: 25 секунд — ещё 5 eth, 26 — уже полные 10.

Шаг 4.4.4

Делаем

Реализуем ДТП: registerAccident(vuNumber) от ДПС увеличивает счётчик ДТП у водителя и, если страховка оформлена, запускает выплату — десятикратный размер страхового взноса на адрес водителя. Если у страховой не хватает средств, она автоматически занимает у банка: borrowFromBank(amount) увеличивает долг, а при поступлении взносов repayBank() гасит его в первую очередь, до любых других расходов.

Зачем

Страховой случай — самая содержательная часть системы: здесь пересекаются четыре роли, и КЗ прямо описывает и десятикратную выплату, и автоматический займ у банка с возвратом. Без этого блока демонстрация по таблице 2 не проходит пункты 10–14, а они дают основную часть баллов модуля Б.

Как проверить

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

Типичная ошибка

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

Что видит эксперт

Просит показать балансы страховой и банка до и после ДТП; ждёт, что долг виден в отдельной view-функции, а не только в событии. Вопрос «откуда страховая возьмёт деньги на выплату» задаётся почти всегда.

Задача 5. Задокументировать решение и показать его на видеоМодули Б–В · 28 баллов (документация 7, инструкция 6, демонстрация 15)

Категория «Специалисты» отличается от студенческой двумя требованиями: код надо задокументировать и приложить инструкцию по запуску. Это 13 баллов в модуле Б, и они теряются чаще всего — не потому, что трудно, а потому, что на них не остаётся времени. Дальше идёт модуль В на 15 баллов: видеозахват по таблице 2 из 14 пунктов и заполненная таблица 3 адресов. Здесь важно не красноречие, а последовательность и видимость изменений состояния сети.

Схема: Задача 5. Задокументировать решение и показать его на видео

Действие 5.1. Задокументировать код и систему

Шаг 5.1.1

Делаем

Документируем код в NatSpec: перед каждой внешней функцией — /// @notice одной фразой, /// @param на каждый аргумент, /// @return на возвращаемые значения, /// @dev для деталей реализации. Пишем по-русски и по делу: «@notice Выписывает штраф по номеру водительского удостоверения», а не «функция для штрафа». Комментарии внутри тел оставляем только там, где объясняют неочевидное — например, модуль в формуле страхового взноса.

Зачем

Документирование кода — отдельное требование КЗ для специалистов, и в модуле Б на него отведено 7 баллов вместе с README: без NatSpec эти баллы не ставятся, даже если контракт работает идеально. Документация ещё и проверяется автоматически через docgen, и это самый быстрый способ доказать её наличие — одним скриншотом сгенерированной страницы.

Как проверить

У всех десяти внешних функций есть @notice и @param, у геттеров — @return. npx hardhat docgen собирает docs/index.html без ошибок, и в нём видно дерево функций с описаниями. Проверьте, что описания не противоречат сигнатурам после последнего рефакторинга.

Типичная ошибка

Писать комментарии вида «// функция оплаты»: они не читаются docgen и ничего не объясняют, баллы за них не начисляются. Вторая ошибка — документировать параметры, которых после рефакторинга уже нет: NatSpec рассинхронизируется с кодом и вводит в заблуждение сильнее, чем отсутствие комментария.

Что видит эксперт

Открывает два-три описания и сверяет с сигнатурами; спрашивает смысл параметра, который описан формально. Страница, собранная docgen, для него доказательство, что документация есть, а не обещана в отчёте.

Шаг 5.1.2

Делаем

Пишем README: назначение системы, схема ролей (водитель, ДПС, страховая, банк) с указанием доступных каждой роли функций, таблица функций с описанием и таблица событий. Отдельный раздел — бизнес-правила: штраф 10 eth, 5 eth в первые 5 дней, 1 день = 5 секунд, десятикратная выплата, формула взноса с примером 2,8 eth. Схему рисуем в Mermaid прямо в markdown — она отображается на GitHub без картинок.

Зачем

README — вторая половина блока документации: по нему эксперт проверяет, понимает ли участник свою систему целиком, а не только отдельные функции. Бизнес-правила в README дублируют код намеренно: если в тексте написано 5 секунд, а в контракте 25, это видно сразу, без запуска и без чтения кода.

Как проверить

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

Типичная ошибка

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

Что видит эксперт

Читает README до запуска и по нему проверяет систему; расхождение документа и кода — минус в двух блоках сразу. Отдельно ищет в тексте числа: штраф, скидку, перевод дня в секунды и десятикратную выплату.

Шаг 5.1.3

Делаем

Заполняем таблицу 3 из КЗ: пользователь — адрес в сети Ethereum. Строки: Банк, Иванов Иван Иванович, Семенов Семен Семенович, Петров Петр Петрович, Романов Роман Романович и Дмитриев Дмитрий Дмитриевич, если он участвует в демонстрации. Адреса копируем целиком, без сокращений вида 0x1234…abcd, и проверяем по балансу, что это нужный аккаунт. Таблица заполняется до записи видео, а не после.

Зачем

Таблица 3 — обязательный результат демонстрации: без неё эксперт не может связать действия на видео с адресами в сети и проверить балансы. Сокращённый адрес здесь бесполезен: по нему нельзя открыть аккаунт, и таблица не выполняет свою функцию, за которую дают баллы в модуле В.

Как проверить

Шесть строк, в каждой полный адрес из 42 символов, начинающийся с 0x. Каждый адрес проверен через eth.getBalance, и сумма соответствует роли: 1000, 50, 50, 50 eth. Адрес ДПС совпадает с адресом Иванова — в КЗ это один человек.

Типичная ошибка

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

Что видит эксперт

Берёт два адреса из таблицы и проверяет их в сети на месте; несовпадение — серьёзный минус к презентации. Полные адреса из 42 символов он считает обязательными: по сокращённым проверить нечего.

Действие 5.2. Написать и проверить инструкцию по запуску

Шаг 5.2.1

Делаем

Пишем инструкцию как runbook: восемь-десять команд подряд, каждая с ожидаемым выводом. Порядок: geth account new → genesis.json → geth init → запуск ноды → solc → деплой → инициализация → прогон сценария. Для каждой команды указываем рабочий каталог и то, что должно появиться в выводе, чтобы читатель не гадал, сработало ли. Инструкция пишется сразу после деплоя, пока команды ещё в истории терминала.

Зачем

Инструкция по запуску — прямое требование КЗ («должна быть дана инструкция по запуску и использованию решения»), и она входит в блок документации. Формат runbook выбран потому, что его можно проверить: эксперт или другой участник проходит по шагам и получает работающую систему без ваших пояснений.

Как проверить

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

Типичная ошибка

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

Что видит эксперт

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

Шаг 5.2.2

Делаем

Проверяем инструкцию на чистоте: создаём новый каталог node2, копируем туда только genesis.json, password.txt и скрипты, и проходим все шаги заново. Всё, чего не хватает (каталог keystore, переменная окружения, настройка MetaMask), дописываем в инструкцию. На это уходит 10–12 минут, и это единственный способ узнать, что документ полный. Прогон делается до записи видео.

Зачем

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

Как проверить

Система поднимается с нуля не дольше 15 минут, деплой проходит, инициализация выполняется, пункты 1–4 таблицы 2 отрабатывают. Ни одна команда не требует правки путей или подстановки значений. Засеките время прогона: если оно больше 15 минут, инструкцию надо сокращать или автоматизировать.

Типичная ошибка

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

Что видит эксперт

Смотрит, есть ли в README раздел про требования к окружению и версии Node, geth и solc; это ценится выше объёма текста. Прогон на чистом каталоге он может попросить повторить при сдаче.

Шаг 5.2.3

Делаем

Дописываем раздел «Ограничения и известные проблемы»: нода одна, поэтому сеть не отказоустойчива; период блока 5 секунд означает, что скидка зависит от момента включения транзакции в блок; при большом числе участников finish упирается в блок-газ; ключи лежат в keystore без аппаратной защиты; строковое поле info хранится в каждом изменении состояния.

Зачем

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

Как проверить

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

Типичная ошибка

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

Что видит эксперт

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

Действие 5.3. Записать демонстрацию по таблице 2

Шаг 5.3.1

Делаем

Готовим видеозахват: OBS Studio, 1920×1080, 30 кадров в секунду, микрофон проверен на уровне около −12 dB. На экране три окна: консоль geth attach с балансами, Remix с задеплоенным контрактом и README с таблицей 3. Перед записью распечатываем таблицу 2 и отмечаем 14 пунктов карандашом — запись идёт по списку без импровизаций. Отдельно проверьте, что в кадр попадает список аккаунтов с балансами.

Зачем

Модуль В — 15 баллов за демонстрацию, и оценивают его по полноте прохождения таблицы 2: пропущенный пункт виден сразу, а порядок действий задан в КЗ. Подготовка окон экономит главное — время записи: одна перезапись из-за невидимого курсора или мелкого шрифта стоит пяти минут и сбивает подготовленный текст.

Как проверить

Пробная запись 20 секунд: текст читается при просмотре в 720p, курсор виден, звук без эха, балансы на экране различимы. Все три окна помещаются без перекрытия ключевых областей — списка аккаунтов и панели функций.

Типичная ошибка

Писать одним окном Remix без консоли: изменения балансов не видны, а именно их требует показывать КЗ. Вторая ошибка — начинать запись без списка шагов и сбиваться на четвёртом пункте, после чего переписывать всё заново.

Что видит эксперт

Смотрит видео целиком и сверяет с таблицей 2; отсутствие видимых изменений состояния сети — главная причина низких баллов за модуль В. Качество картинки он оценивает по читаемости адресов и балансов.

Шаг 5.3.2

Делаем

Записываем проход по 14 пунктам: баланс банка (1000 eth), баланс страховой (0 eth), регистрация Романова (стаж 6 лет, 1 ДТП, 50 eth), добавление ему удостоверения 222, Петрову — 333, Романову — 444, оформление страховки Дмитриевым и Семеновым, баланс страховой, штраф по удостоверению 111, ДТП по 111, штраф по 555, оплата штрафа Романовым, финальные балансы страховой и банка. После каждого действия показываем личный кабинет и сообщения.

Зачем

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

Как проверить

В видео 14 отмеченных пунктов, на каждом видно изменение состояния: баланс, статус удостоверения, сообщение в личном кабинете. Длительность 8–12 минут при спокойном темпе — ускорять не нужно, важнее читаемость и внятный комментарий.

Типичная ошибка

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

Что видит эксперт

Отмечает по ходу видео, какие пункты таблицы 2 показаны; за комментарии дают часть из 15 баллов, и они должны быть по существу. Молчаливое переключение аккаунтов он оценивает ниже, чем короткое объяснение происходящего.

Шаг 5.3.3

Делаем

Проверяем запись перед сдачей: проигрываем с начала, сверяя с таблицей 2, и выписываем таймкоды всех 14 пунктов в описание видео. Проверяем, что таблица 3 заполнена и адреса совпадают с теми, что на экране. Файл называем по шаблону Фамилия_Блокчейн_МодульВ.mp4 и кладём в папку участника вместе с решением и инструкцией. Перед сдачей откройте видео на другом устройстве и проверьте звук.

Зачем

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

Как проверить

Все 14 пунктов имеют таймкод, таблица 3 заполнена, адреса в ней совпадают с адресами на видео. Файл воспроизводится на другом компьютере и открывается стандартным плеером — проверьте это, а не только на своём ноутбуке.

Типичная ошибка

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

Что видит эксперт

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