Базовый курс по Solidity

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

Урок 1 - Введение в Solidity

Урок 2 - Типы данных: Bool, uint, int

Урок 3 - Типы данных: String, address, mapping

Урок 4 - Типы данных: array, enum, bytes, struct

Урок 5 - Функции

Урок 6 - События и модификаторы

Урок 7 - Работа с терминалом, основы node.js и npm

Урок 8 - Тестирование с Hardhat, Ethers & Waffle

Урок 9 - Оптимизация смарт-контрактов

Урок 10 - Вопросы для собеседования. Часть 1

Урок 11 - Наследование

Урок 12 - Интерфейсы и библиотеки

Урок 13 - Древо Меркла

Урок 14 - Низкоуровневые вызовы

Урок 15 - Работа с памятью в Solidity

Урок 16 - Hardhat tasks

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

На что обращать внимание во время обучения разбора смарт-контрактов

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

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

Иногда просят выполнить тестовое задание и написать смарт-контракт прямо на собеседовании. Тебе говорят, мол:

"Вам нужно написать контракт, который будет создавать объект голосования и принимать на входе массив с валидированными адресами. Эти адреса могут голосовать за проект эфиром. Победитель забирает все, а контракт - комиссию. Добавить проверки функций."

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

Вот для этого я и хочу заняться разборами контрактов, чтобы мы могли переводить такой текст задания в код и понимать: " Так, объект это скорее всего через struct, список адресов через mapping. Потом проверки. " Как-то так.

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

На что я предлагаю обращать внимание в смарт-контрактах:

1. Общую задачу
2. Надобность переменных или за что они отвечают
3. Различные require
4. Наследования других контрактов
5. Подключенные import

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

Начинаем уже завтра.

Урок 17 - Голландский аукцион

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

Стрим - аукцион.

Так как это новый формат обучения, я еще не совсем уверен, какие скрины делать.

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

Приятного дня и легкого обучения!

#голландскийаукцион #аукцион #урок

В видео были показаны две переменные "constant" и "immutable", после которых имя переменных писалось капсом (большими буквами). Их особенность в том, что данные переменные уже нельзя будет нигде изменять.

Так вот, если мы пишем "constant" по значение переменной мы должны указать сразу.

Если же мы используем "immutable", то создать переменную можно в начале, а присвоить значение один раз позже.

#constant #immutable

Solidity поддерживает некоторые не стандартные форматы записи даты и времени.

Обычно во многих языках нужно указывать продолжительность времени в секундах или миллисекундах. И если мы хотим обозначить день, то нужно писать что-то типа - 60*60*24.

Однако в данном языке можно писать "3 hours", "5 minutes" или "2 weeks".

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

#date #time #formats

Хочу обратить внимание на упрощенную запись условия if\else, которое носит название тернарное выражение.

Это также, к слову, о красивом коде.

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

#тернарноевыражение #тернарное

"С начала эпохи Unix" - произнес лектор в видео.

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

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

Время Unix никогда не двигается назад.

#unix

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

this.timeout(5000)

где 5000 - это 5 секунд.

Добавить функцию delay, как в примере на скрине. А затем вызвать ее уже в самом тесте.

#delay #timeout

Ethers из урока

ethers.utils.parseEther("0.001") - функция принимает значение в эфире и правильно конвертирует в единицу Wei.

ethers.provider.getBlock(#) - получить информацию о блоке в блокчейне

return (ethers.provider.getBlock(#)).timestamp - возвращает метку времени данного блока

#ethers

Добавление и настройка Solidity-Coverage

В уроке также упоминался npm пакет для проверки покрытия тестами вашего контракта по названием Solidity-Coverage.

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

Это удобно, в случае разработки больших контрактов на 500+ строк кода, когда ошибка может таиться в любом месте.

Итак, для установки пакета в консоли, в папке вашего проекта, потребуется прописать команду:

npm install --save-dev solidity-coverage

Затем следует открыть файл hardhat.config.js и в начале добавить строку:

require ("solidity-coverage")

После выполнения данных действий, вам становится доступна новая команда в hardhat

npx hardhat coverage

Также можно зайти в директорию вашего проекта -> Coverage и открыть index.html. Откроется веб страница, где вы также сможете увидеть покрытие тестами своего контракта.

#npm #coverage

Описание контракта из стрима. Часть 1

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

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

Прежде всего мы определили 3 переменных:

1. Это владелец контракта, который и будет получать комиссию.
2. Продолжительность аукциона по умолчанию, так как он по факту не может быть бесконечным.
3. Нашу комиссию.

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

Дальше мы прорабатываем аукционы.

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

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

А вот чтобы хранить все созданные аукционы в одном месте, мы создаем массив (array). Более того, массив поможет нам быстро находить нужный аукцион и взаимодействовать с ним.

В следующем посте мы разберем функции контракта.

#разбор

Описание контракта из стрима. Часть 2

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

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

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

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

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

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

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

Далее пишем формулу расчета цены на товар в данный период времени.

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

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

Ну, и последняя функция - это покупка товара и распределение денег.

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

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

Если же все ок, то мы останавливаем аукцион и устанавливаем финальную цену.

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

При желании порождаем еще одно событие.

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

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

Далее мы разберем тесты контракта.

#разбор

Описание контракта из стрима. Часть 3

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

Создаем новый файл в tests и подключаем наши библиотеки chai и hardhat, а затем пишем подготовку к тестам.

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

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

Ну, а теперь можно писать тесты.

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

Тут надо также напомнить что, чтобы проверить покупку нам нужно сначала создать транзакцию, а уже после ее выполнения (через await) проверять, что изменилось. По сути, также и с созданием аукциона. Сначала создаем аукцион через транзакцию, а потом проверяем его.

Вот собственно и все по данному контракту и проверкам. Честно говоря, сам не ожидал, что это займет столько постов. Тем не менее, если что-то отложится в голове, то это будет просто замечательно!  

#разбор

Урок 18 - ERC20

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

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

Если слово "токен" вам ничего не говорит, то как насчет того, что одна из самых обеспеченных криптовалют в мире USDT - и есть токен ERC20?

Другими словами после этого стрима мы научимся создавать и выпускать свои криптовалюты в сети Эфира.

Видео урок - работа с ERC20

А чуть более подробно про ERC20 можно прочитать тут.

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

#урок #erc20

Описание стандарта ERC20. Часть 1

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

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

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

Decimals я понимаю, но сложно переложить в текст мысли.

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

Стоимость газа определяется в gwei - 9 нулей, а минимальная величина wei - 18 нулей. Очень грубо говоря, это как в 1 рубле - 100 копеек.

И вот этот decimals определяет стоимость нашего токена в количестве нулей после запятой. И вот когда лектор определил число "18" в одноименной функции, он фактически приравнял стоимость своего токена к 1 wei.

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

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

В mapping allowances есть свой вложенный mapping, в котором uint и отображает количество токенов, которые он может перечислять. Соответственно, если значение "0", то разрешения нет.

#erc20

Описание стандарта ERC20. Часть 2

Пройдемся по функциям.

Ну, с первыми функциями name(), symbol(), decimals(), totalSupply(), balanceOf() - все просто, они возвращают только то, что чего предназначены, не выполняя никаких дополнительных действий внутри себя.

Дальше два модификатора на проверку владельца и количества токенов на каком-либо адресе.

Затем вызывается конструктор, чтобы создать токен. В него как раз и нужно передать название и символ токена, а также владельца. После чего запустить чеканку (mint) токена.

В mint() создаются токены и отправляются на адрес магазина.

В burn() они уничтожаются, отправляясь на нулевой адрес.

С transfer() и fransferFrom() у меня были некоторые пролемы та тему, зачем их два. Потом я понял, что transfer() вызываем мы сами, по сути как владелец всех токенов, а transferFrom() - вызывают другие продавцы для перевода токенов.

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

Далее идет функция allowance(), которая возвращает uint. И как я выше писал, если количество "0" - то разрешения нет.

И две функции approve, одна из которых вызывает другую, служебную.

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

По сути, она всего лишь разрешает какому-то аккаунту передавать наши токены.

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

#erc20

Описание стандарта ERC20. Часть 3

А теперь попытаемся расписать контракт магазина для продажи наших токенов.

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

Далее, в конструкторе, мы через объект токена, с помощью функции "new MCSToken(address(this))", разворачиваем смарт-контракт нашего токена MCSToken, который в свою очередь при помощи наследования разворачивает ERC20.

Образно говоря, сначала мы создали некий объект, назвав его token для простоты, а затем наполнили его через контракт токена.

Благодаря этому действию, мы можем создать функцию tokenBalance(), которая возвращает нам количество токенов на каком-либо адресе, используя объект token и функцию из ERC20 balanceOf().

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

Тут мы делаем пару проверок на присланную сумму и количество токенов для перевода, и затем, с помощь объекта token вызываем функцию перевода - transfer().

Также тут представлена функция sell(), которая позволяем нашему магазину продавать токены с одного аккаунта на другой.

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

Именно поэтому мы вызываем дальше функцию не просто transfer(), а transferFrom().

Ну, и в завершении перечисляем деньги продавцу токена.

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

В случае каких-либо вопросов, можете смело писать их в комментариях. 

#erc20