Как написать смарт контракт на etherium

Интерактивная инструкция по использованю Web3 v1.0

Web3.js — официальная библиотека для работы с блокчейном Ethereum. В версии 1.0 добавлены важные и полезные фичи, делающие работу с библиотекой удобной и приятной: добавлены расширенные промисы (PromiEvents), появилась возможность подписываться на события (к сожалению не поддерживатся текущей версией Metamask), произошло структурирование на функциональные модули и многое другое.

Web3 позволяет нам абстрагироваться от внутренней механики Ethereum и работать с сетью и смарт-контрактами так, будто это обычные javascript-объекты. Если вы еще не знаете, что такое смарт-контракты, то можете представить их как некие классы, экземпляры которых живут в сети Ethereum — на самом деле это действительно классы языка Solidium, который, внешне очень похож на javascript. Процесс выглядит следующим образом: код смарт-контракта пишется на Solidium, потом компилируется в байт-код и этот байт-код записывается в сеть. Как вновь созданный объект javascript получает свой адрес в «куче», так размещённый нами контракт получает свой адрес в сети Ethereum, используя который мы теперь можем вызывать его методы и читать свойства. Ну почти. На самом деле для всех публичных свойств автоматически создаются геттеры — одноимённые методы для получения значения этих свойств. Любое обращение к смарт-контракту происходит через вызов его методов. И теперь самое важное — есть два типа методов: те, которые меняют состояние смарт-контракта и те, которые не меняют. Первые требуют на своё выполнение затрат эфира, т.к. приводят к записи данных в сеть Ethereum, а вторые совершенно бесплатны, их ещё называют view-методы. Как упоминалось выше, они автоматически создаются для всех публичных свойств смарт-контракта. Как видите, всё просто, нам остаётся подключиться к смарт-контракту, получив от web3 javascript-объект, представляющий его абстракцию. У этого объекта есть свойство methods, которое представляет набор методов смарт-контракта. View-методы вызываются методом .call(), остальные методом .send(). Эти (не-view) методы возвращают нам объект класса PromiEvent — мутант промиса и ивент-эмиттера. Смысл в том, что в случае записи данных этот промис разрешится только тогда, когда данные будут записаны в сеть, ждать чего может прийтись от десятков до сотен секунд. В это время мы можем слушать различные события, происходящие в процессе выполнении нашего метода и реагировать на них.

Для подключения к блокчейну, мы должны предоставить библиотеке web3 так называемый провайдер — сущность, которая непосредственно будет обмениваться данными с узлом Ethereum на машинном языке, в который web3 переведёт наши команды. Есть несколько способов получить этого провайдера: установить браузерное раcшиение Metamask (работает как прокси между вами и вашим адресом в сети, позволяя не инсталлировать свой полноценный узел) или установить на локальную машину узел Ethereum (для тестирования можно использовать его эмулятор, например Ganache) В данной инструкции мы рассмотрим самый простой, первый вариант. Для того, чтобы не тратить реальные деньги, подключаться будем не к основной сети Ethereum, а к её тестовой копии — Rinkeby. Она позволяет получить бесплатные виртуальные Эфиры, которые вы потом сможете тратить: Ссылка.

2. Настройка

Для начального сетапа своего проекта вы можете использовать непосредственно данный туториал, мы специально сделали его максимально простым. Итак, первым делом установите Metamask. Используя Метамаск, зарегистрируйте себе новый кошелек Ethereum или подключите уже имеющийся, импортировав его секретный ключ.

Импортируйте удобным для вас способом библиотеку web3. Мы использовали этот CDN.

Теперь давайте подключимся к сети Ethereum, для чего «попросим» Метамаск поделиться с нами своим провайдером:

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

2. Подключение.

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

В кратце, данный смарт-контракт (далее для удобства будем истользовать термин’класс’) определяет некий объект, которым можно обмениваться с другими пользователями. Если посмотреть код, вы увидите, что эти характеристики определяются в базовом классе ERC20Token (файл ERC20Token.sol) — классы в Solidity поддерживают наследование. Класс ERC20DividendsToken расширяет ERC20Token функционалом, позволяющим начислять на нашу сущность дивиденды в эфирах, так что все, кто имеет эти токены в своём Ethereum-кошельке, получает свою долю пропорционально количеству имеющихся токенов. Если проводить аналогию с реальным миром, это фактически выпуск акций — представьте, что размещая контракт в сети, вы выпускаете определённое количество акции своей компании, после чего можете их передавать другим лицам и начислять на них дивиденды. Наконец, в классе VendingToken, унаследованном от ERC20DividendsToken, мы выпускаем 100 наших акций-токенов. Назначение данного смарт-контракта — «токенизация» некоего актива, причём 1 токен представляет 1% стоимости этого актива.

Мы опустим процесс компиляции и сразу возьмём байт-код скомпилированного контракта, чтобы задеплоить его в сеть. Если вы решите сами получить необходимые для деплоя байткод и ABI(Application Binary Interface), то самый простой путь — забрать себе проект, установить npm пакет ‘remixd’ и открыть доступ к папке с контрактами командой ‘remixd -s contracts’, затем открыть в браузере онлайн IDE для Solidity Remix, подключиться к открытой ранее папке (нажать на иконку с цепью), открыть файл VendingToken.sol, скомпилировать его кнопкой ‘Start to compile’ (убедитесь, что в селекте выбран правильный контракт), потом нажать кнопку ‘Details’. В появившемся всплывающем окошке нас интересуют две сущности — ‘BYTECODE’, а именно подраздел «object», копируем его значение и сохраняем в переменную. Теперь находим раздел ‘ABI’ и сохраняем его в другую переменную. ABI позволит web3 «расшифровать» параметры методов нашего скомпилированного контракта, иначе он для нас останется бессвязным набором символов. Все вышеперечисленные действия мы уже произвели и сохранили байткод и ABI в файле data.js

Итак, используя уже созданниый инстранс web3, «заряженный» провайдером, взятым у Метамаска, создадим инстанс абстракции контракта и получим от Метамаска адрес текущего кошелька (понадобится далее):

Если бы у нас уже был задеплоенный контракт, то было бы дастаточно указать его адрес вторым параметром метода Contract(), но мы хотим сами его задеплоить и для этого используем имеющийся у нас байткод и метод deploy(). Перед деплоем убедитесь, что вы вошли в Метамаск и переключились на тестовую сеть Rinkeby!

Код вспомогательных функций resetContractData(), onTransactionHashReceived(), resetVisualEffects() можно посмотреть в файле connect.js, разберём процесс деплоя подробнее. Любая запись информации в блокчейн происходит посредством формирования и отправки специального объекта, называемого транзакцией, который майнеры помещают в новый блок. Отправка производится методом send(), который возвращает объект класса PromiEvent, позволяющий не только ждать окончания майнинга нового блока, но и контролировать этот процесс. Майнеры получают вашу транзакцию и, если она их устраивает, начинают записывать её в следующий блок, предварительно вернув вам «расписку в получении» — transaction hash. По окончаню процесса майнинга блока PromEvent резолвится и мы получаем наш новенький только что задеплоенный контракт.

Transaction hash:

Contract address: Сохранить адрес контракта

* данные по ссылкам могут отображаться с задержкой

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

3. Работа со смарт-контрактом.

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

Подключиться к контракту

Contract address: Сохранить адрес контракта

Для начала давайте попробуем перевести немного токенов на какой-нибудь адрес (напоминаю, после деплоя у нас их ровно сто).
Посмотрите на интерфейс базового класса нашего смарт-контракта (файл ERC20TokenInterface.sol):

Ивенты отложим для следующего раздела и остановимся на методах, в частности нас интересует функция transfer. Модификатор external обозначает, что метод можно вызывать извне и, как видите, им помечены все методы, перечисленные в интерфейсе, что логично. View — методы помечены модификатором view, у transfer его нет, значит при его вызове будет происходить запись данных в блокчейн. Теперь важный момент — в Solidity нет дробных чисел, поэтому перед записью в блокчейн чисел, которые могут оказаться не целочисленными, их предварительно домножают на 10 в степени 18. Если вы посмотрите на конструктор нашего смарт-контракта в файле VendingToken.sol, то увидите, что наши 100 токенов перед записью домножились ровно на это значение. Поэтому нам придётся убирать 18 нулей при чтении данных и добавлять столько же при записи.

Еще нам пригодятся view-методы totalSuply и balanceOf, первый из которых возвращает изначальное количество выпущенных токенов (в нашем случае 100), а второй — баланс токенов на выбранном кошельке. В отличае от send(), метод call() возвращает обычный промис:

Зарегистрируйте в Метамаске второй кошелёк и попробуйте, переключаясь между кошельками, поперебрасывать туда-обратно токены. Благодаря тому, что мы используем домножение на 10 в 18 степени, можно использовать дробные значения. Не забывайте перегружать страницу после смены кошелька. Для того, чтобы каждый раз не копипастить адресс контракта, после первого подключения его можно сохранить в локальном хранилище и использовать после обновления страницы.

Использовать сохранённый адрес контракта

Проверить свой баланс

Проверить баланс контрагента

Transaction hash:

Если вы перейдёте по ссылке и посмотрите на содержимое транзакции, то заметите что это на самом деле просто зашиврованый вызов метода transfer: первые 4 байта — это сигнатура метода и далее по 32 байта на значение каждого атрибута. Давайте прочитаем 3-х символьное название токена. Оно задано в файле VendingToken.sol так: string public symbol = «VEND»; Как уже упомяналось, для всех публичных свойств контракта во время компиляции автоматически создаются одноимённые view-методы, поэтому запрос значения публичного свойства контракта выглядит как обычный вызов view-метода:

Пришло время использовать дивидендный функционал нашего смарт-контракта. Он описан в файле ERC20DividendsTokenInterface.sol :

Метод dividendsRightsOf позволяет проверить накопившиеся дивиденды, а releaseDividendsRights — эти дивиденды вывести на свой кошелёк. Но для начала давайте переведём на наш смарт-контракт немного эфира — для этого в Метамаске нажмите «Отправить», укажите в графе «Получатель» адрес смарт-контракта и, если кнопка отправки не активизировалась, поднимите в настройках цену на газ. После пополнения можно провенить начисленные дивиденды — они начислены на все адреса пропорционально проценту токенов на балансе.

Transaction hash:

5. События смарт-контракта.

Как видите, всё оказалось достаточно просто — благодаря web3 работа с сетью Ethereum похожа на работу с обычным бэкендом, API которого представлено публичными методами смарт-контракта. Но есть нюанс. Мы не можем сохранять данные в блокчейн так, как бы мы делали при работе с обычной базой данных. Это будет слишком дорого. Представьте, что нам потребовалось где-то хранить историю переводов наших токенов, а так же историю всех начислений и списаний дивидендов. Если мы будем при любой операции добавлять соответствующую запись в некий список, созданный для этого внутри смарт-контракта, то на каждой транзакции придётся перезаписывать этот список в сеть с добавлением новой записи — со временем такие транзакции станут золотыми. Для решения данной проблемы можно использовать events — события смарт-контракта, аналогичные EventEmitter в javascript. В коде смарт-контракта мы генерируем собитие, в коде нашего клиента — слушаем его. В нашей задаче вместо того, чтобы слушать текущие события, мы будем анализировать уже произошедшие и из них собирать список изменений, призошедших с токенами и дивидендами.

Если посмотреть на реализацию метода transfer, находящийся в файле ERC20Token.sol, то можно увидеть, что он вызывает внутренний метод transfer_, добавив к передаваемыми нами параметрам адрес кошелька, с котрого пришёл вызов. Вот код метода transfer_:

Модификатор internal означает, что метод может вызываться только изнутри текущего класса и классов-наследников. Внутри метода, после проведения серии проверок (см. require), у отправителя отнимается указанное количество токенов, а у получателю они добавляются. В предпоследней строчке генерируется событие, которое нас и будет интересовать. Давайте получим список всех событий Transfer, в которых учавствовал адрес нашего колешька — для этого у абстракции смарт-контракта есть метод getPastEvents(). Он возвращает список произошедших событий смарт-контракта, удовлетворяющих определённым условиям. Параметры, с которыми было вызвано событие, находятся в свойстве returnValues:

Пишем смарт-контракт Ethereum — это просто: Часть 1 — введение

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

Смарт контракты Ethereum можно писать на разных языках. Мы же будем использовать solidity как наиболее распространенный на момент написания статьи. Версия 0.4.18.

1. Познакомимся с языком solidity
2. Познакомимся со средой Remix
3. Напишем наш первый смарт-контракт
4. Научимся запускать наш смарт-контракт в тестовой среде

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

Слева — список файлов. Центральное окно — место куда мы будем писать свой код. А справа инструменты.

Итак, наш первый смарт-контракт по традиции будет выводить приветствие «Hello, world»:

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

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:

Он содержит одну переменную count и три функции. Переменная представляет собой целое число и является локальной – доступна только в пределах контракта Counter. Первая и вторая функции incrementCounter() и decrementCounter() изменяют значение count : повышают или понижают на единицу. Третья функция getCount() возвращает текущее значение переменной count .

При переносе кода в 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, у которого при помощи выпадающего списка станет доступен выбор функций из тех, что мы записали в нашей программе.

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

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

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

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

Аналогичным образом вы можете протестировать поведение функции decrementCount() .

Заключение

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

Hello World Smart Contract for Beginners

If you are new to blockchain development and don’t know where to start, or if you just want to understand how to deploy and interact with smart contracts, this guide is for you. We will walk through creating and deploying a simple smart contract on the Goerli test network using a virtual wallet MetaMask (opens in a new tab) ↗ , Solidity (opens in a new tab) ↗ , Hardhat (opens in a new tab) ↗ , and Alchemy (opens in a new tab) ↗ (don’t worry if you don’t understand what any of this means yet, we will explain it).

In part 2 (opens in a new tab) ↗ of this tutorial we’ll go through how we can interact with our smart contract once it’s deployed here, and in part 3 (opens in a new tab) ↗ we’ll cover how to publish it on Etherscan.

If you have questions at any point feel free to reach out in the Alchemy Discord (opens in a new tab) ↗ !

Step 1: Connect to the Ethereum network

There are many ways to make requests to the Ethereum chain. For simplicity, we’ll use a free account on Alchemy, a blockchain developer platform and API that allows us to communicate with the Ethereum chain without having to run our own nodes. The platform also has developer tools for monitoring and analytics that we’ll take advantage of in this tutorial to understand what’s going on under the hood in our smart contract deployment. If you don’t already have an Alchemy account, you can sign up for free here (opens in a new tab) ↗ .

Step 2: Create your app (and API key)

Once you’ve created an Alchemy account, you can generate an API key by creating an app. This will allow us to make requests to the Goerli test network. If you’re not familiar with testnets, check out this page.

1. Navigate to the “Create App” page in your Alchemy Dashboard by hovering over “Apps” in the nav bar and clicking “Create App”

1. Name your app “Hello World”, offer a short description, select “Staging” for the Environment (used for your app bookkeeping), and choose “Goerli” for your network.

1. Click “Create app” and that’s it! Your app should appear in the table below.

Step 3: Create an Ethereum account (address)

We need an Ethereum account to send and receive transactions. For this tutorial, we’ll use MetaMask, a virtual wallet in the browser used to manage your Ethereum account address. More on transactions.

You can download and create a MetaMask account for free here (opens in a new tab) ↗ . When you are creating an account, or if you already have an account, make sure to switch over to the “Goerli Test Network” in the upper right (so that we’re not dealing with real money).

Step 4: Add ether from a Faucet

In order to deploy oursmart contract to the test network, we’ll need some fake Eth. To get Eth you can go to the Goerli faucet (opens in a new tab) ↗ and log into your Alchemy account and enter your wallet address, then click “Send Me Eth.” It may take some time to receive your fake Eth due to network traffic. (At the time of writing this, it took around 30 minutes.) You should see Eth in your Metamask account soon after!

Step 5: Check your Balance

To double check our balance is there, let’s make an eth_getBalance (opens in a new tab) ↗ request using Alchemy’s composer tool (opens in a new tab) ↗ . This will return the amount of ETH in our wallet. After you input your MetaMask account address and click “Send Request”, you should see a response like this:

NOTE: This result is in wei not ETH. Wei is used as the smallest denomination of ether. The conversion from wei to ETH is: 1 eth = 10 18 wei. So if we convert 0x2B5E3AF16B1880000 to decimal we get 5 * 10¹⁸ which equals 5 ETH.

Phew! Our fake money is all there .

Step 6: Initialize our project

First, we’ll need to create a folder for our project. Navigate to your command line and type:

Now that we’re inside our project folder, we’ll use npm init to initialize the project. If you don’t already have npm installed, follow these instructions (opens in a new tab) ↗ (we’ll also need Node.js so download that too!).

It doesn’t really matter how you answer the installation questions, here is how we did it for reference:

Approve the package.json and we’re good to go!

Hardhat is a development environment to compile, deploy, test, and debug your Ethereum software. It helps developers when building smart contracts and dapps locally before deploying to the live chain.

Inside our hello-world project run:

Step 8: Create Hardhat project

Inside our project folder run:

You should then see a welcome message and option to select what you want to do. Select “create an empty hardhat.config.js”:

This will generate a hardhat.config.js file for us which is where we’ll specify all of the set up for our project (on step 13).

Step 9: Add project folders

To keep our project organized we’ll create two new folders. Navigate to the root directory of your project in your command line and type:

• contracts/ is where we’ll keep our hello world smart contract code file
• scripts/ is where we’ll keep scripts to deploy and interact with our contract

Step 10: Write our contract

You might be asking yourself, when the heck are we going to write code?? Well, here we are, on step 10.

Open up the hello-world project in your favorite editor (we like VSCode (opens in a new tab) ↗ ). Smart contracts are written in a language called Solidity which is what we will use to write our HelloWorld.sol smart contract.‌

1. Navigate to the “contracts” folder and create a new file called HelloWorld.sol
2. Below is a sample Hello World smart contract from the Ethereum Foundation that we will be using for this tutorial. Copy and paste in the contents below into your HelloWorld.sol file, and be sure to read the comments to understand what this contract does:

This is a super simple smart contract that stores a message upon creation and can be updated by calling the update function.

Step 11: Connect MetaMask & Alchemy to your project

We’ve created a MetaMask wallet, Alchemy account, and written our smart contract, now it’s time to connect the three.

Every transaction sent from your virtual wallet requires a signature using your unique private key. To provide our program with this permission, we can safely store our private key (and Alchemy API key) in an environment file.

To learn more about sending transactions, check out this tutorial on sending transactions using web3.

First, install the dotenv package in your project directory:

Then, create a .env file in the root directory of our project, and add your MetaMask private key and HTTP Alchemy API URL to it.

• Follow these instructions (opens in a new tab) ↗ to export your private key
• See below to get HTTP Alchemy API URL

Copy Alchemy API URL

Your .env should look like this:

To actually connect these to our code, we’ll reference these variables in our hardhat.config.js file on step 13.

Step 12: Install Ethers.js

Ethers.js is a library that makes it easier to interact and make requests to Ethereum by wrapping standard JSON-RPC methods with more user friendly methods.

Hardhat makes it super easy to integrate Plugins (opens in a new tab) ↗ for additional tooling and extended functionality. We’ll be taking advantage of the Ethers plugin (opens in a new tab) ↗ for contract deployment (Ethers.js (opens in a new tab) ↗ has some super clean contract deployment methods).

In your project directory type:

We’ll also require ethers in our hardhat.config.js in the next step.

Step 13: Update hardhat.config.js

We’ve added several dependencies and plugins so far, now we need to update hardhat.config.js so that our project knows about all of them.

Update your hardhat.config.js to look like this:

Step 14: Compile our contract

To make sure everything is working so far, let’s compile our contract. The compile task is one of the built-in hardhat tasks.

From the command line run:

You might get a warning about SPDX license identifier not provided in source file , but no need to worry about that — hopefully everything else looks good! If not, you can always message in the Alchemy discord (opens in a new tab) ↗ .

Step 15: Write our deploy script

Now that our contract is written and our configuration file is good to go, it’s time to write our contract deploy script.

Navigate to the scripts/ folder and create a new file called deploy.js , adding the following contents to it:

Hardhat does an amazing job of explaining what each of these lines of code does in their Contracts tutorial (opens in a new tab) ↗ , we’ve adopted their explanations here.

A ContractFactory in ethers.js is an abstraction used to deploy new smart contracts, so HelloWorld here is a factory for instances of our hello world contract. When using the hardhat-ethers plugin ContractFactory and Contract instances are connected to the first signer by default.

Calling deploy() on a ContractFactory will start the deployment, and return a Promise that resolves to a Contract . This is the object that has a method for each of our smart contract functions.

Step 16: Deploy our contract

We’re finally ready to deploy our smart contract! Navigate to the command line and run:

You should then see something like:

If we go to the Goerli etherscan (opens in a new tab) ↗ and search for our contract address we should able to see that it has been deployed successfully. The transaction will look something like this:

The From address should match your MetaMask account address and the To address will say “Contract Creation” but if we click into the transaction we’ll see our contract address in the To field:

Congrats! You just deployed a smart contract to the Ethereum chain ��

To understand what’s going on under the hood, let’s navigate to the Explorer tab in our Alchemy dashboard (opens in a new tab) ↗ . If you have multiple Alchemy apps make sure to filter by app and select “Hello World”.

Here you’ll see a handful of JSON-RPC calls that Hardhat/Ethers made under the hood for us when we called the .deploy() function. Two important ones to call out here are eth_sendRawTransaction (opens in a new tab) ↗ , which is the request to actually write our contract onto the Goerli chain, and eth_getTransactionByHash (opens in a new tab) ↗ which is a request to read information about our transaction given the hash (a typical pattern when transactions). To learn more about sending transactions, check out this tutorial on sending transactions using Web3

That’s all for part 1 of this tutorial, in part 2 we’ll actually interact with our smart contract (opens in a new tab) ↗ by updated our initial message, and in part 3 we’ll publish our smart contract to Etherscan (opens in a new tab) ↗ so everyone will know how to interact with it.

Want to learn more about Alchemy? Check out our website (opens in a new tab) ↗ . Never want to miss an update? Subscribe to our newsletter here (opens in a new tab) ↗ ! Be sure to also follow our Twitter (opens in a new tab) ↗ and join our Discord (opens in a new tab) ↗ .