Как сделать смарт контракт

Как создать
Содержание
  1. Создаем первый смарт-контракт на Ethereum менее чем за 60 минут
  2. Смарт-контракт: общие сведения
  3. Предварительные настройки: локальный блокчейн Ganache и MyEtherWallet
  4. Смарт-контракт: написание и компиляция кода в Remix
  5. Запуск сервера блокчейна
  6. Развертывание смарт-контракта
  7. Настройка взаимодействий с контрактом
  8. Тестирование смарт-контракта
  9. Заключение
  10. Как написать смарт-контракт для ICO за 5 минут
  11. Solidity
  12. Смарт-контракты
  13. Готовим окружение
  14. Фигачим контракт
  15. Миграции
  16. Тестирование и деплой
  17. Заключение
  18. Бонус
  19. Как создать смарт-контракт: Инструкция для начинающих
  20. Проектирование смарт-контракта
  21. Выбор DApp-платформы
  22. Создание смарт-контракта
  23. На что обратить внимание
  24. Интеграция с JavaScript
  25. Создание автоматизированных смарт-контрактов, не требующих сервера
  26. Проблема: смарт-контракты не являются самоисполняющимися
  27. Небольшое отступление на тему самоисполнения
  28. Области, где можно применить автоматизацию смарт-контрактов
  29. 1. Автоматические триггеры
  30. 2. Мониторинг состояний и событий
  31. Решение – бессерверные функции?
  32. Быстрый старт: переход на бессерверную платформу с бессерверным фреймворком
  33. 1. Функции
  34. 2. События
  35. Введение в serverless-ethers (бессерверные эфиры)
  36. 1. Интерфейсы ABI смарт-контракта
  37. 2. Функции
  38. 3. serverless.yml
  39. Локальный запуск
  40. Развертывание в AWS
  41. В заключение
  42. Ну и на десерт: поддержка ChatOps с помощью Slack
  43. Дополнительно: мониторинг Событий смарт-контрактов

Создаем первый смарт-контракт на Ethereum менее чем за 60 минут

Расскажем, как создать смарт-контракт на блокчейне Ethereum при помощи сервера Ganache и программы на ЯП смарт-контрактов Solidity.

Смарт-контракт: общие сведения

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

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

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

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

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

Предварительные настройки: локальный блокчейн Ganache и MyEtherWallet

Первым делом необходимо установить Ganache — инструмент для создания приватного блокчейна, работающего на вашем компьютере. Советуем загрузить версию 1.0.2, так как последняя версия по нашему опыту пока некорректно обрабатывает запросы смарт-контрактов. Также вам понадобится локальная копия MyEtherWallet (url-сайт на в рассматриваемом случае не подойдет). По последней ссылке вам нужно загрузить пакет с названием вида etherwallet-v3.xx.x.x.zip.

Смарт-контракт: написание и компиляция кода в Remix

После того как у вас имеется все необходимое, переходим на сайт https://remix.ethereum.org/ и видим следующий экран онлайн-IDE Remix.

Онлайн-редактор Remix содержит компилятор для языка Solidity. При первом посещении страницы редактор для наглядности загружается с некоторым кодом. Этот код можно безболезненно стереть и заменить программой контракта Counter:

При переносе кода в Remix он будет автоматически скомпилирован (по умолчанию на сайте стоит галочка Auto compile).

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

Запуск сервера блокчейна

Запустите предварительно установленное приложение Ganache. Обратите внимание на ссылку на RPC SERVER. Она также нам вскоре понадобится.

Разархивируйте сохраненную ранее zip-папку MyEtherWallet и откройте index.html в веб-браузере. В правом верхнем углу находится кнопка с надписью Network ETH. По умолчанию в качестве сети выбирается основная сеть Ethereum (mainnet). Для изменения этого параметра, в выпадающем списке выбираем Add Custom Network / Node.

При этом откроется окно, в котором вы можете вставить информацию о RPC Server, предоставленную Ganache. Имя узла (Node Name) можно выбрать произвольное.

С этого момента локальная копия MyEtherWallet подключится к вашему блокчейн серверу на Ganache.

Развертывание смарт-контракта

Воспользуемся MyEtherWallet, чтобы загрузить смарт-контракт Counter. Для этого в верхней навигационной панели нажимаем на Contracts и на открывшейся странице контрактов выбираем Deploy Contract.

Видим, что MyEtherWallet запрашивает байт-код контракта. Возвращаемся в Remix IDE и нажимаем кнопку “Details”.

При этом появится окно со множеством деталей о контракте Counter. Для того, чтобы скомпилировать байт-код, скопируйте его из параметра object раздела BYTECODE (удобнее всего скопировать весь блок при помощи соответствующей иконки, а потом удалить все лишнее).

Переносим байт-код в MyEtherWallet. Параметр Gas Limit определится автоматически.

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

Копируем ключ, выбираем Private Key и вставляем значение

Теперь, если нажать Unlock, MyEtherWallet попросит нас подтвердить транзакцию.

При нажатии Sign Transaction под кнопкой добавятся Raw Transaction и Signed Transaction. Нажимаем на Deploy Contract.

Соглашаемся с предупреждением.

В результате транзакции в Ganache в разделе текущих обрабатываемых блоков (Current Blocks) число изменится с 0 на 1. Также на 1 возрастет счетчик для выбранного ключа.

Теперь смарт-контракт загружен в локальный блокчейн.

Настройка взаимодействий с контрактом

Для того, чтобы провзаимодействовать со счетчиком контракта, возвращаемся в MyEtherWallet и выбираем раздел Interact With Contract.


Как видим, MyEtherWallet запрашивает адрес контракта и бинарный интерфейс приложения (Application Binary Interface, ABI). Адрес контракта хранится в Ganache, в разделе Transactions.

При выборе соответствующего раздела откроется лог всех проведенных транзакций.

При нажатии на запись о транзакции будет выведена вся информация о ней, среди которой необходимый адрес контракта – Created Contact Address.

Копируем адрес и вставляем в соответствующее поле MyEhtherWallet.

Все, что осталось – это найти ABI – то, что сообщает MyEtherWallet как взаимодействовать с нашим контрактом. Для этого возвращаемя к тому месту, где мы остановились в Remix (Details), в разделе ABI копируем информацию в буфер обмена, переносим в MyEtherWallet и нажимаем Access. При этом появится раздел Read / Write Contract, у которого при помощи выпадающего списка станет доступен выбор функций из тех, что мы записали в нашей программе.

Тестирование смарт-контракта

То есть функция работает корректно. Функция инкремента предполагает активное действие с нашей стороны – осуществление транзакции. При выборе функции нажимаем Write и соглашаемся с запросом транзакции.

В результате при новом запросе функции getCount видим 1 вместо 0 (и выросшее число транзакций в Ganache).

Заключение

Итак, мы запустили блокчейн на нашем компьютере, развернули на нем смарт-контракт и провзаимодействовали с ним. Это очень близко к тому, как на начальном этапе происходит процесс профессиональной разработки смарт-контрактов на Ethereum. Когда вы становитесь готовы к тому, чтобы другие пользователи могли взаимодействовать с вашим смарт-контрактом без использования реальных денег (как в сети mainnet), вы можете загрузить смарт-контракт в Ethereum test network, (testnet).

Источник

Как написать смарт-контракт для ICO за 5 минут

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

Читайте также:  Как сделать садовый вар жидким

Solidity

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

Смарт-контракты

А если вы пометите функцию в контракте словами Constant или View (означают одно и то же, разрешают только читать состояние), либо Pure (то же самое, только даже состояние не читает), то на исполнение этой функции даже кефир тратить не нужно будет! Даже больше скажу, эти функции не нужно вызывать транзакциями — ведь любой клиент кефира, теоретически, сможет ее выполнить у себя — и никому больше об этом знать не нужно (в блокчейн ведь ничего не пишется).

А еще есть две важные штуки в солидити: множественное наследование и модификаторы функций. Про них тоже нужно знать.

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

Перейдем к практике.

Готовим окружение

Если вы не знаете, что такое Терминал — почитайте вот эту статью. Если вы на окнах, ставьте себе Терминал через WLS. Если вы уже знакомы с Терминалом, продолжим. Алсо, сразу поставьте себе Node.js — он будет необходим для следующих шагов. Лучше ставить LTS, но, на самом деле, абсолютно без разницы, какую из современных версий ноды ставить.

Если вам выплюнуло версию geth — все в ажуре, продолжаем туториал. Если нет — хреново, исправляйте; придется, похоже, заняться любовными ласками с Терминалом и своей операционной системой — но вам не впервой, разберетесь. Как установите geth, запускайте в Терминале команду:

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

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

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

Фигачим контракт

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

Сделайте cd в какую-нибудь безопасную папку и после пропишите:

В этой папке и будем работать. Создадим здесь заглушку для нашего смарт-контракта:

Дальше нам нужно забрать текущий код смарт-контрактов из npm и, собственно говоря, начать сам проект:

Ага, вот вам и весь ERC20 интерфейс. Сложно? Не думаю. Дает возможность глянуть, сколько было выпущено токенов, проверить баланс адреса и перевести токенов на другой адрес, выплюнув в сеть событие перевода для легких клиентов кефира. И все это вы получаете фор фри в вашем MyToken.sol благодаря работе OpenZeppelin — они молодцы.

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

Вот и все — у вас есть готовые контракты вашего собственного ERC20 токена и даже смарт-контракт ICO, который настраивается по вашему желанию и раздает ваши токены за кефир. Алсо, его поддерживают все ERC20 кошельки — ляпота! Перейдем к ручным тестам и деплою.

Миграции

Заметка про web3.eth.accounts[0] : когда деплоите смарт-контракт, убедитесь, что geth или testrpc имеют правильный кошелек в web3.eth.accounts[0] — не теряйте приватный ключ к нему, хоть это никак вам не навредит, но вдруг владельцу что-нибудь потом нужно будет сделать, а ключа уже нет?

Тестирование и деплой

Йес, контракты готовы, миграции написаны, осталось только задеплоить и проверить. Как geth (тестовый и реальный), так и testrpc управляются одинаково через truffle console — так что опишу способ проверки для testrpc и просто расскажу, как включить geth после. И так, запускаем тестовый локальный блокчейн кефира:

Эм… вот и все. У вас локально работает симуляция блокчейна кефира.

Теперь открываем новое окошко Терминала ( testrpc не закрываем — он должен работать) и прописываем в папке проекта:

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

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

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

Заключение

Удачи в разработке смарт-контрактов! Остались вопросы? Милости прошу в комментарии — с удовольствием на все отвечу и постараюсь помочь с проблемами.

Бонус

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

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

Источник

Как создать смарт-контракт: Инструкция для начинающих

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

Смарт-контракты — это способ вести бизнес в новой децентрализованной экономике. Большинство смарт-контрактов заключаются на платформах децентрализованных приложений (DApp), например, Ethereum, Lisk или Cardano, а крупные технологические компании вроде IBM начинают создавать собственные предприятия в этой области. И действительно, многим заказчикам спокойнее иметь дело со всемирно известной компанией со столетней историей, нежели самостоятельно пробовать совершенно новую технологию.

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

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

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

Проектирование смарт-контракта

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

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

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

Выбор DApp-платформы

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

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

Однако у нее есть и недостаток: для написания смарт-контрактов там используется собственный язык под названием Solidity.

Есть другой вариант, Lisk — на этой DApp-платформе используется Javascript, поэтому новый синтаксис учить не придется. Кроме того, здесь есть собственный DApp-магазин (что-то вроде Google Play или iTunes), где вы можно опубликовать готовое приложение.

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

Тем не менее пока ограничим наш выбор Ethereum и Lisk.

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

Но не стоит списывать Ethereum со счетов. У этой платформы такое обширное сообщество разработчиков, что новизна Solidity будет с избытком компенсирована легкостью получения нужной информации. Кроме того, для Ethereum есть фреймфорк Truffle от Consensys, позволяющий интегрировать и тестировать смарт-контракты.

Создание смарт-контракта

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

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

На что обратить внимание

Уникальность Solidity — в адресации. Все учетные записи Ethereum имеют уникальные адреса, и эти адреса представляют стороны, заключающие контракт.

В нашем примере контракта на продажу билетов организатор мероприятия будет

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

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

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

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

Интеграция с JavaScript

Самая сложная часть работы с Solidity — интеграция контракта с Javascript. Это делается с помощью фреймворка Truffle.

Сначала нужно выполнить развертывание контракта и перенести его в тестовую сеть. Truffle предоставляет для этого собственную отдельную тестовую сеть Ethereum, которая называется Ganache. Теперь мы получаем версию контракта в JSON-представлении, и можем вызывать ее с помощью адресов тестовой сети из Javascript-приложения.

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

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

Поскольку блокчейн все же похож на базу данных, нам нужно подключить контракт к своему серверу, и, поскольку у системы развитый API, получить доступ к информации с клиентской стороны не сложнее, чем совершить AJAX-запрос — на сайте Truffle есть хороший пример.

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

И здесь снова приходит на помощь огромное сообщество разработчиков Ethereum — вероятнее всего, на любой ваш вопрос уже есть ответ на Ethereum Stack Exchange, а если его нет, другие разработчики с готовностью помогут вам с вашим смарт-контрактом.

Источник

Создание автоматизированных смарт-контрактов, не требующих сервера

В этой статье мы выстроим решение этой проблемы. Вы узнаете:

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

Бессерверные эфиры (открытый исходный код доступен на Github. Просто скопируйте и нажмите кнопку развернуть!)

Дальше вы узнаете, зачем нам нужна автоматизация и как она работает.

Проблема: смарт-контракты не являются самоисполняющимися

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

Как это можно сделать?

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

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

Читайте также:  Как сделать ребрышки в рукаве

Тем не менее, кто-то все еще должен вызвать смарт-контракт в первую очередь для запуска кода.

Небольшое отступление на тему самоисполнения

Чисто технически для автоматического выполнения определенных операций можно использовать модификаторы функций. Одним из примеров этого является распределение блокчейн-компанией Compound управляющих токенов COMP среди пользователей одноименного протокола. Как только условно взятый адрес заработает 0,001 COMP, при каждой транзакции в сети Compound (будь то отправка актива или перевод токена) на его кошелек автоматически будут поступать токены COMP.

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

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

Наконец, кто-то все еще должен вызвать смарт-контракт для запуска кода.

Области, где можно применить автоматизацию смарт-контрактов

Протоколы DeFi уже в некоторой степени прибегают к внесетевой автоматизации смарт-контрактов. MakerDAO использует сторонних Киперов для мониторинга коэффициентов обеспечения долговых позиций и ликвидации любых недозагруженных позиций. Другие протоколы DeFi имеют аналогичные потребности.

Существуют два часто пересекающихся варианта использования внесетевой автоматизации смарт-контрактов:

1. Автоматические триггеры

Рассматрим примеры, когда вам нужно исполнять контракт периодически или на определенных условиях, а именно:

2. Мониторинг состояний и событий

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

Решение – бессерверные функции?

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

Быстрый старт: переход на бессерверную платформу с бессерверным фреймворком

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

Давайте быстро рассмотрим, как работает бессерверная платформа.

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

Все лямбда-функции и события в вашем Бессерверном сервисе можно найти в конфигурационном файле, называемом serverless.yml. В нем определены функции и события сервиса.

Под свойством functions вы устанавливаете свои бессерверные функции. В приведенном выше примере:

У вас может быть несколько функций в одном сервисе.

1. Функции

Функция – это функция AWS Lambda. Это самостоятельная единица развертывания вроде микросервиса. Это просто код, развернутый в облаке, который чаще всего пишется для выполнения одной задачи.

2. События

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

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

Вы также можете задать график с помощью выражений cron schedule:

Это все, что вам нужно знать на данный момент.

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

С азами бессерверного фреймворка закончили, давайте теперь перейдем к сервису serverless-ethers.

Введение в serverless-ethers (бессерверные эфиры)

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

Проект serverless-ethers структурирован следующим образом:

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

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

Смарт-контракт DummyStorage имеет следующие функции:

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

1. Интерфейсы ABI смарт-контракта

Каталог контрактов содержит ABI контрактов, с которыми взаимодействуют функции. В образце проекта он содержит ABI для контракта DummyStorage.

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

Структура контрактов / каталогов позволяет нам импортировать как ABI, так и адрес контракта следующим образом:

Они нам понадобятся в нашей работе.

2. Функции

Функция exec использует эфиры для загрузки ABI контракта и вызова смарт-контракта:

Загрузка ABI и адреса контракта дает нам абстракцию ethers.Contract со всеми функциями нашего смарт-контракта, включая get() и put().

На примере функции exec мы вызываем contract.put() с помощью случайного целого числа.

3. serverless.yml

Прежде чем вы сможете запустить функцию exec, вам нужно будет указать некоторые переменные среды в вашем serverless.yml:

serverless-ethers использует следующие переменные среды:

Вы можете на ходу менять переменные среды развернутой функции с помощью консоли AWS Lambda.

Важное примечание: убедитесь, что ваши ключи хранятся не в открытом источнике. Используйте безопасное хранилище типа AWS Secrets Manager для хранения учетных данных, таких как мнемоника и ключи API. Поскольку каждый проект имеет свои собственные требования по безопасности и настройке, мы оставляем читателям право решать, как они хотят подойти к вопросу хранения чувствительной информации.

Локальный запуск

Вы можете использовать бессерверную команду CLI invoke local для локального запуска ваших функций. Она отлично подходит для тестирования!

Развертывание в AWS

Развертывание выполняется так же просто, как и бессерверное развертывание:

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

В заключение

Поздравляю! Теперь вы знаете:

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

Пример приложения serverless-ethers с открытым исходным кодом доступен на Github. Добавляйте репозитарий в избранное, если вы нашли его полезным!

Ну и на десерт: поддержка ChatOps с помощью Slack

В комплект serverless-ethers входит функция postToSlack, которая поможет вам интегрироваться с Slack.

Функция postToSlack позволяет использовать переменную среды SLACK_HOOK_URL, которую вы можете извлечь из консоли Slack. После настройки вы сможете оправлять уведомления в Slack о каждом успешном выполнении операции.

Это удобный и простой способ контролировать свои функции.

Дополнительно: мониторинг Событий смарт-контрактов

Пока мы успели реализовать только вариант использования «автоматического триггера». А как насчет мониторинга состояний и событий смарт-контракта?

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

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

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

Источник

Оцените статью
Полезные советы и лайфхаки для жизни