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

Время на прочтение
7 мин

Количество просмотров 27K

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

Для экономии времени я написал контракт заранее. Давайте разберем его по шагам.

Смартконтракт является программой написанной на языке программирования. В нашем случае на языке Solidity. Для разработки простых контрактов я использую онлайн редактор и компилятор Remix.

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

/*
This file is part of the EasyCrowdsale Contract.

The EasyCrowdsale Contract is free software: you can redistribute it and/or
modify it under the terms of the GNU lesser General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

The EasyCrowdsale Contract is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU lesser General Public License for more details.

You should have received a copy of the GNU lesser General Public License
along with the EasyCrowdsale Contract. If not, see <http://www.gnu.org/licenses/>.

@author Ilya Svirin <i.svirin@prover.io>
*/

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

pragma solidity ^0.4.0;

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

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

contract owned {

    address public owner;

    function owned() payable {
        owner = msg.sender;
    }
    
    modifier onlyOwner {
        require(owner == msg.sender);
        _;
    }

    function changeOwner(address _owner) onlyOwner public {
        owner = _owner;
    }
}

Контракт «owned» содержит лишь одно публичное поле «owner», значение которого инициализируется в конструкторе значением поля «sender» глобальной структуры «msg», таким образом, изначально владельцем контракта становится тот, кто осуществил его деплой.

Логично предусмотреть возможность смены владельца на случай, если наш private key будет скомпрометирован, для этого предусмотрена функция «changeOwner», которая получает в качестве параметра адрес нового владельца. Следует обратить на модификатор «onlyOwner», который определен внутри этого же смартконтракта. Модификаторы представляют собой очень удобную конструкцию, позволяющую сгруппировать и присвоить название условиям вызова функций смартконтракта. Модификатор «onlyOwner» проверяет, что вызов функции осуществляется с адреса, который сохранен в поле «owner».

Контракт «owned» полностью работоспособен и предельно прост, однако несет в себе одну скрытую угрозу, ведь при вызове функции «changeOwner» мы можем по ошибке указать несуществующий адрес, а значит, потеряем контроль над контрактом. Чтобы исправить этот недостаток, достаточно ввести еще поле, назовем его «candidate», а при вызове функции «changeOwner» будем сохранять новое значение сначала в «candidate», а перемещать его в «owner» будем, как только кандидат подтвердит свое вступление в права, вызвав со своего адресу функцию «confirmOwner».

Следующий в иерархии контракт – «Crowdsale», отвечает непосредственно за сбор средств и выдачу токенов и наследует рассмотренный ранее контракт «owned».

contract Crowdsale is owned {
    
    uint256 public totalSupply;
    mapping (address => uint256) public balanceOf;

    event Transfer(address indexed from, address indexed to, uint256 value);

    function Crowdsale() payable owned() {
        totalSupply = 21000000;
        balanceOf[this] = 20000000;
        balanceOf[owner] = totalSupply - balanceOf[this];
        Transfer(this, owner, balanceOf[owner]);
    }

    function () payable {
        require(balanceOf[this] > 0);
        uint256 tokensPerOneEther = 5000;
        uint256 tokens = tokensPerOneEther * msg.value / 1000000000000000000;
        if (tokens > balanceOf[this]) {
            tokens = balanceOf[this];
            uint valueWei = tokens * 1000000000000000000 / tokensPerOneEther;
            msg.sender.transfer(msg.value - valueWei);
        }
        require(tokens > 0);
        balanceOf[msg.sender] += tokens;
        balanceOf[this] -= tokens;
        Transfer(this, msg.sender, tokens);
    }
}

Особое внимание следует обратить на следующие элементы контракта:

• Публичное поле «totalSupply», которое должно содержать общее количество токенов, выпущенных смартконтрактом;
• Публичная карта «balanceOf», которое содержит информацию о балансах всех держателей токенов;
• Событие Transfer, которое должно испускаться смартконтрактом при каждой операции перемещения токенов между держателями токенов.

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

Конструктор смартконтракта «Crowdsale» предельно прост. Прежде всего инициализируется значение поля «totalSupply». Наш контракт выпускает 21 миллион токенов, из которых 20 миллионов сразу будут перемещены на баланс смартконтракта. Будем считать, что токены с адреса смартконтракта как раз и доступны для продажи. Оставшиеся токены, в нашем случае 1 миллион, будут записаны на адрес владельца контракта. Ну и в конце конструктора испускается событие «Transfer», которое помещается в блокчейн и информирует пользователей контракта о том, что с баланса контракта на баланс владельца контракта переведено соответствующее количество токенов. Именно испускание этого события позволит etherscan.io корректно отобразить держателей токенов и их балансы.

Ну и самая главная функция смартконтракта «Crowdsale», так называемая fallback функция, которая вызывается каждый раз, когда эфир поступает на адрес нашего смартконтракта. В самом начале осуществляется проверка, что на балансе смартконтракта есть хоть какое-то количество токенов для продажи. Далее устанавливаем фиксированную цену токенов – 5000 штук за 1 эфир. Затем вычисляем, сколько токенов необходимо отправить отправителю эфира. Количество переданных в транзакции средств записано в поле «value» глобальной структуры «msg» и указано оно в «wei», поэтому при определении количества токенов осуществляем перевод «wei» в «ether».

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

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

contract EasyToken is Crowdsale {
    
    string  public standard    = 'Token 0.1';
    string  public name        = 'EasyTokens';
    string  public symbol      = "ETN";
    uint8   public decimals    = 0;

    function EasyToken() payable Crowdsale() {}

    function transfer(address _to, uint256 _value) public {
        require(balanceOf[msg.sender] >= _value);
        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value;
        Transfer(msg.sender, _to, _value);
    }
}

Прежде всего определим 4 публичных поля, которые сейчас практически не используются никакими кошельками, но для порядка все же определим их. Здесь укажем полное и сокращенное наименование токена, а также количество дробных знаков. В нашем случае токен является неделимым, т.к. значение поля «decimals» установлено равным 0.

И наконец, единственной функцией смартконтракта «EasyToken», ради которой мы создавали этот контракт, является «transfer», которая также является частью стандарта ERC20 и позволит кошелькам пользователей осуществлять передачу токенов друг другу, переводить их на биржу и выводить их с нее. Реализация функции крайне проста, проверяется достаточность количества токенов на балансе отправителя, после чего баланс отправителя уменьшается, а баланс получателя увеличивается на запрошенное количество токенов. В конце испускается событие «Transfer». Теперь наш токен является операбельным и осталось сделать самое главное – предоставить владельцу контракта возможность вывести собранные эфиры. Это мы сделаем в контракте «EasyCrowdsale».

contract EasyCrowdsale is EasyToken {

    function EasyCrowdsale() payable EasyToken() {}
    
    function withdraw() public onlyOwner {
        owner.transfer(this.balance);
    }
}

Функция «withdraw» имеет модификатор «onlyOwner», т.е. может быть вызвана только владельцем смартконтракта. Единственное, что она делает – переводит весь баланс смартконтракта на адрес владельца смартконтракта.

Несмотря на то, что рассмотренный нами смартконтракт является полностью функционально законченным и работоспособным, использовать его в реальном проекте я бы не рекомендовал. Чрезмерное упрощение логики контракта привело к тому, что такой контракт не обеспечивает защиту интересов инвесторов в должной мере, а именно, не устанавливает срок проведения crowdsale, не устанавливает минимальной границы сбора, не возвращает средства инвесторам в случае недостижения минимальной границы, а также содержит ряд известных уязвимостей на уровне компилятора языка Solidity, например, подвержен так называемой short address attack.

Многие из этих недостатков устранены в смартконтракте нашего проекта PROVER. Контракт PROOF загружен в Ethereum по этому адресу вместе с исходным кодом, с которым можно познакомиться. Можно даже проверить, как работает контракт, отправив на него реальный эфир, у нас как раз сейчас идет Pre-ICO:). На самом деле, мы будем рады, если вы присоединитесь к presale нашего проекта PROVER, который продлится до конца сентября. PROVER – это уникальная технология подтверждения подлинности видеоматериалов на базе блокчейн и видеоаналитики.

Полезные ссылки:

• Полный код разобранного в данном посте смартконтракта
• Моя видеопрезентация по созданию простого смартконтракта для ICO
• ERC20 Token standard
• Мой проект PROVER — идет Pre-ICO!!!
• Еще пост про мой проект PROVER
• Видеопрезентация проекта PROVER (англ)
• Смарт контракты Ethereum: что делать при ошибке в смартконтракте или техники миграции

Лучший способ разобраться в чём-то – попытаться это что-то объяснить другому

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

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

В этом уроке:

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

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

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

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

Вставьте этот код в среду Remix и выполните следующие действия.

1. Переключитесь на вкладку «compile» в панели справа
2. Выполните «start compile»
3. Переключитесь на вкладку  «run»
4. В поле «Environment» поставьте «JavaScript VM»  — это тестовая среда в которой мы будем исполнять наши контракты
5. Выберите в списке контрактов тот, который будете заливать (сейчас это HelloWorld)
6. Нажмите на кнопку «create» — таким образом мы создаем контракт внутри сети Ethereum

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

После этих процедур панель справа должна выглядеть примерно так

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

Результатом работы будет.

Теперь мы видим нашу строку приветствия «Hello, world.»

Наш первый смарт-контракт написан и успешно выполнен!

Теперь разберем наш код.

В самой первой строчке указывается язык «solidity» и его версия 0.4.18.

Сам контракт описывается просто. Для тех кто знаком с ООП в программировании — контракт покажется похожим на класс.

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

Следует отметить что слово «constant» не обязательно, но его желательно ставить если функция не меняет внутреннего состояния контракта. Также не обязательно указывать слово public, так как  все функции по-умолчанию считаются public. Однако хорошим стилем считается указание public.

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

Если функция ничего не возвращает, то убираем все что после названия функции.

Соответственно если функция ничего не принимает на вход то убираем входные_параметры.

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

или так, если нужно сразу задать значение переменной

Типы переменных мы будем рассматривать по мере надобности.

Если что-то не понятно не переживайте, на практике станет все на свои места.

Давайте сделаем так чтобы контракт хранил строку «Hello, world» в переменной.

Теперь наша строка приветствия хранится в переменной wellcomeString. И тип у нее string.

Усовершенствуем наш контракт так чтобы строку приветствия можно было менять.

У нас появилась дополнительная функция setData которая принимает на вход новую строку приветствия и присваивает ее переменной wellcomeString.

Залейте контракт в сеть. После этого на правой панели внизу появятся две кнопки «getData» и «setData» которые соответствуют нашим функциям.

Напишите в поле рядом с кнопкой setData какую-нибудь строчку в двойных кавычках. Например «wellcome»  и нажмите setData. А затем getData. Если вы все правильно сделали, то getData вернет вашу строку.

На этом вводная часть заканчивается. Продолжение читать тут.

Если у вас возникли вопросы то можете смело писать на электронную почту (раздел «контакты»). Также приветствуется критика.

Если статья показалась вам полезной и вы желаете отблагодарить автора, то это можно сделать отослав немного эфира на адрес 0xEA15Adb66DC92a4BbCcC8Bf32fd25E2e86a2A770.

Полный список уроков тут.

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

Готовясь к ICO вы должны понимать, что ICO — чистой воды маркетинговое событие. Если вы думаете, что для проведения вам понадобится штаб программистов, вы заблуждаетесь. Вам понадобится штаб маркетологов(или просто людей, готовых выполнять ваши поручения), а также нормальное количество валюты, чтобы привлечь внимание общественности. Да, существуют ICO, выехавшие без серьезных вложений (за счет своей идеи/опыта/связей), но давайте не будем тешить себя надеждами и лукавить — для сбора миллиона долларов вам придется вложить тысячи долларов в ICO.

Проработку ICO оставим на следующую статью, а пока создадим наш ERC20 токен на базе Ethereum максимально быстро.

Техническая часть

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

Скажу честно — я лукавил. Вам не нужно разбираться в Solidity. Для запуска своего токена вам необходимо взять исходник токена ERC20, поменять пару строк и залить контракт в сеть одним из клиентов(оф.клиент Ethereum/Metamask/etc).

Что представляет собой смарт-контракт токена?

1. Это структура данных(читай таблица), состоящая из связи адреса Ethereum = количество токенов(целое число).

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

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

ERC20 на пальцах

Из-за появления кучи бажных смарт-контрактов, пытающихся выполнить одни и те же действия, была предпринята попытка(удачная) стандартизировать выпускаемые токены. Сделано это было в первую очередь, чтобы:

Для выпуска токена стандарта ERC20 вам необходимо:

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

Деплоим наш токен

Теперь эти данные нам необходимо внести в смарт-контракт, доступный по ссылке. Скачиваем оба .sol файла. Переходим в редактор remix. Загружаем оба файла.

Открываем NewToken.sol, ставляем вместо переменных в <скобках> нужные значения:

Должно получиться что-то в духе:

Сохраняем. Осталось задеплоить контракт в сеть. Для тестирования задеплоим в Ropsten test net. Для деплоя потребуется какой-либо клиент. Воспользуемся MetaMask — он не умеет компилировать смарт-контракты на Solidity, поэтому сперва произведем компиляцию.

В правой части редактора remix открываем вкладку compile. По умолчанию контракт компилируется автоматически. Выбрав свой контракт в select’е и нажав Details вы можете просмотреть байт-код и прочую информацию.

Для деплоя жмем Run, выбираем Injected Web3, выбираем Account, которым будем деплоить(он должен подгрузиться автоматически, если у вас установлен MetaMask в браузер). Вводим нужную информацию в поля(газ, value), жмем Create.

Жмем Submit. Ваш контракт задеплоен(после внесения в блокчейн, конечно). Деплой подтверждается в MetaMask’е иконкой с документом(она ведет на страницу транзакции) и надписью «Contract published».

Производим операции с нашим токеном

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

Производить операции с нашим токеном(передавать его, например) мы можем либо на странице контракта на etherscan(ссылка в MetaMask’е), либо на странице remix.

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

… Profit!

Вот и всё, развлекайтесь!

Буду рад ответить на ваши вопросы в комментариях или (комментарии на vc.ru можно оставлять не всегда) в чате t.me/chainchain.

В следующей статье рассмотрим как запустить свое ICO в течение 10 минут.

Я осознаю, что сейчас кому-то обломаю бизнес, но это слишком просто, чтобы брать за это деньги, имхо

Если вы создаете dApp на основе Ethereum или токен стандарта ERC20, вам нужно выучить язык Solidity. В нашем уроке мы дадим вам основы программирования cмарт контрактов.

Содержание

• Понимание основ умного контракта
• Выбор IDE и версии Solidity
• Написание вашего первого умного контракта
• Что такое Wei и Gas
• Создание и развертывание собственного токена ERC20
• Послесловие

За последнее десятилетие блокчейн-программирование стало одной из самых высокооплачиваемых и сложных программных сфер. Хотя блокчейны не зависят от языка и многие из существующих языков, такие как C ++ и JavaScript (JS), используются блокчейн инженерами, есть некоторые задачи, которые не могут быть удобно реализованы существующими языками, что открыло спрос на новые, крипто-специфичные опции. Одним из таких языков является Solidity.

Solidity появился как основная часть экосистемы Эфириума. Он вобрал в себя C ++, JavaScript и Python. У него есть много современных особенностей как библиотеки и объектно-ориентированность. Solidity предназначен для написания программ, взаимодействующих с учетными записями Ethereum, которые называются умными контрактами. Смарт контракты выполняются на виртуальной машине Ethereum (EVM), что позволяет пользователям, использующим их выполнять децентрализованные задачи, такие как краудфандинг, слепые аукционы, голосование и многие другие. Самым известным приложением умных контрактов было децентрализованное финансирование в ICO , что положило начало ралли на криптовалют в 2017 году.

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

Документация Solidity

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

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

В отличие от учетных записей пользователей, учетные записи смарт-контракта не являются внешними по отношению к соответствующим сетям. Другими словами, вы можете использовать свой кошелек в различных сетях, таких как Kovan и Ropsten, но вы не можете сделать это с помощью умного контракта. Умные контракты являются внутренними.

Каждый смарт-контракт имеет источник, который хранится на устройстве автора и экземпляры, которые хранятся в блокчейне. Чтобы создать экземпляр (учетную запись) умного контракта, нам нужно развернуть его в сети. Он очень напоминает отношения между классами и экземплярами в традиционном объектно-ориентированном программировании (ООП) и представляющих его языках (JS, Ruby). Чтобы дать вам более наглядное представление, давайте создадим класс Bike и добавим его экземпляр.

Bike class & instance

Мы напишем определение контракта, которое затем будет запускаться через компилятор, который создаст два файла: байт-код и двоичный интерфейс приложения (ABI). Байт-код — это то, что будет фактически передано в EVM, а ABI — это слой между байт-кодом и обычным кодом JavaScript, который позволяет создавать пользовательский интерфейс (UI).

Выбор IDE и версии Solidity

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

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

Initial Remix window

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

Creating a new project in Remix

Поскольку у нас есть пустой документ. sol, мы должны указать версию Solidity, которую будет запускать компилятор. На момент написания данного руководства последняя версия была 0.5.7. Если вы не уверены, какую версию использовать, вы можете указать диапазон версий.

2 типа указания версии Solidity

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

Именование контракта

Написание вашего первого смарт контракта

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

Давайте создадим пару переменных: строку (последовательность символов) и целое число (число). В случае Ethereum переменные хранятся в блокчейне вместе с остальными частями контрактов и следовательно могут быть доступны и обновлены из любого места. Другой ключевой характеристикой переменных Solidity является то, что вы можете сделать их приватными, написав «private» рядом с переменными. Наконец, для целых чисел Solidity имеет два типа: подписанный (может быть положительным и отрицательным) и беззнаковый (может быть только положительным). Чтобы указать неподписанную переменную, мы должны просто поставить ‘u’ перед ней.

A private string and an integer

Когда у нас есть переменная name, нам нужно написать методы установки и получения. Это похоже на функцию JS. Помните, что Solidity имеет статическую типизацию, поэтому мы должны определить типы переменных. Теперь любое значение, которое мы помещаем в ‘setName’, будет определять строку ‘name’. Для получения мы будем использовать getName и указать, какую переменную мы ожидаем увидеть. Теперь пришло время сделать то же самое для переменной age. Метод построен аналогично getName.

Name/age setters and getters

Давайте проверим наш маленький кусок кода. Перейдите на вкладку «Выполнить» (Run) компилятора и нажмите «Развернуть» (Deploy) под именем вашего контракта. В самом низу компилятора вы увидите раздел «Развернутые контракты» (Deployed Contracts), в котором доступны наши методы. Чтобы передать имя в значение «newName», нам нужно убедиться, что наша строка записана в JSON, в противном случае «getName» ничего не вернет. Для «setAge» просто укажите свой возраст без кавычек. Как вы видите, теперь мы можем устанавливать и получать переменные name и age через наш умный контракт.

Компилятор, с именем и возрастом

Что такое Wei и Gas

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

Что такое Wei?

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

Что такое Gas?

Gas является неотъемлемой частью механизма умного исполнения контракта. Он имеет два значения для каждой транзакции: потребляемый газ и его цена. Стоит отметить, что пользователь инициирующий транзакцию, определяет сам эти значения. Однако, если установленного значения Gas недостаточно для выполнения определенной операции, то Gas будет потреблен, но транзакция не будет выполнена. Более того, если цена на газ будет установлена слишком низкой для сети в данный момент времени, транзакция не будет обрабатываться узлами, что в конечном итоге сделает ее неудачной. Существует несколько сервисов для проверки оптимальных значений для ваших транзакций, одна из которых — ethgasstation.info. Чтобы лучше понять Gas и то, почему он стоит каких-то денег, давайте начнем кодирование некоторых из них сами.

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

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

Дешевый контракт

Теперь вы можете развернуть его в компиляторе и ввести любые два числа, чтобы получить целое число «c». Чтобы проверить цену нашей транзакции, мы должны взглянуть на терминал, расположенный под разделом кода. Существует стоимость транзакции и стоимость исполнения. Первый относится к тому, сколько данных имеет транзакция. Второй относится к тому, сколько энергии EVM потребовалось для транзакции.

Дешевый контракт

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

Создание и развертывание собственного токена ERC20. Выпуск токенов и создание ICO.

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

 Сначала нам нужно создать еще один файл в Remix и загрузить интерфейс ERC20, а именно:

Стандарт ERC20

Функция totalSupply позволяет нам увидеть, сколько у нас всего токенов. Функция balanceOf используется для получения количества токенов по определенным адресам. Функция transfer позволяет пользователям выполнять транзакции между собой. Функции «TransferFrom», «allowance» и «Approve» позволяют пользователям разрешать другим пользователям инициировать транзакции от их имени. События являются инструментами регистрации для главной книги.

В дополнение к самому интерфейсу нам понадобится отдельный файл. sol для нашего нового токена. Здесь мы импортируем интерфейс ERC20 и указываем символ, имя и десятичные числа нашего токена.

uToday token

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

• Давайте начнем с общего предложения — это постоянная целочисленная переменная, которую мы сделаем приватной. Общий запас наших токенов составит 1 миллион, мы также напишем функцию для возврата этого значения.
• Во-вторых, нам нужно где-то     хранить наш токен. Для этого нам нужно будет указать сопоставление, которое будет возвращать баланс для любого указанного адреса.
•  В-третьих, должна быть функция для передачи токенов, которая по существу будет иметь адрес получателя и количество переданных токенов. Эта функция также должна быть в состоянии проверить, достаточно ли у отправителя количества токенов на его балансе, что можно реализовать с помощью простого оператора if / then. Кроме того, мы установим условия для ‘_value’ таким образом, чтобы пользователи не могли отправлять транзакции с «0» токенами, так как это приведет к засоренью сети разным мусором.
•  В-четвертых, мы должны создать отображение для остальных функций, которое представляет собой отображение целого числа.

Затем мы укажем несколько проверок в функциях «утверждение» (approve) и «допуск» (allowance) и установим условия для ‘transferFrom’.
Наконец, не все токены будут доступны на рынке. Некоторые из токенов обычно оставляются для команд, фондов, консультантов и других целей. Следовательно важно, чтобы мы ясно дали понять, сколько токенов будет циркулировать в системе. Когда мы создали токены, оборотное предложение равняется нашему балансу.

uToday token constraints

Код готов, поэтому давайте проверим его. Перейдите на вкладку «Выполнить» (Run) компилятора и разверните наш токен-контракт. Вы увидите, что у нас есть данные токена, а также общее предложение, остатки и надбавки. Поздравляю, вы создали свой первый токен.
Чтобы наш токен действительно работал в сети, нам нужно развернуть умный контракт (обратите внимание, что это отличается от развертывания его для тестирования в Remix). Для этого урока мы будем использовать Remix и Metamask, но есть и другие способы сделать это. Metamask — это простая, но эффективная программа-кошелек Ethereum с приятным пользовательским интерфейсом, который интегрируется как расширение в некоторые из самых популярных браузеров. В нашем случае мы будем использовать Opera. Сначала перейдите на metamask.io и загрузите расширение. Как только это будет сделано, вы увидите значок лисы в правом верхнем углу вашего браузера.

Загрузка metamask и расположение иконки

 Нажмите на значок и выполните предложенные инструкции для создания кошелька. Не забудьте сохранить секретную фразу! Когда у вас есть кошелек, нажмите на иконку Metamask и измените сеть на «Ropsten», потому что мы не хотим связываться с основной сетью Ethereum.

Изменение metamask на Ropsten

Последним шагом является создание некоторого Ether (к сожалению, вы не сможете использовать его для каких-либо реальных покупок, но они необходимы для тестирования). Зайдите на faucet.metamask.io и запросите 1 эфир.
Теперь у вас все готово. Вернитесь в окно Remix и измените среду на «Injected Web3» в компиляторе. Взгляните также на вкладку учетной записи — ваш адрес должен совпадать с адресом, который вы создали в Metamask. Выберите смарт-контракт, который вы хотите развернуть, который является вашим токен-контрактом, но не интерфейсом ERC20 и нажмите соответствующую кнопку. Появится окно metamask с транзакцией, ее деталями и опциями для взаимодействия с ней. Отправьте транзакцию и наш токен оживет.

Metamask всплывающее окно

Теперь вы можете поиграть со всеми функциями, которые мы указали ранее. Давайте посмотрим на наш контракт с другой стороны, чтобы убедиться, что он работает правильно. Как и любой другой блокчейн, в Ethereum есть несколько block explorers, которые служат основной целью мониторинга того, что происходит в сети. В нашем случае мы будем использовать etherscan , хотя есть несколько других замечательных альтернатив. Обратите внимание, что если вы просто зайдете в etherscan, вы увидите Основную сеть. Поскольку нам нужно увидеть сеть Ropsten, вам нужно будет поставить «ropsten» перед адресом сайта. Найдите свой адрес и вы увидите две транзакции — одна для бесплатного эфира, который вы получили, а другая для развертывания контракта.

Адрес пользователя в Etherscan

Чтобы найти адрес вашего контракта, нажмите на TxHash и перейдите в поле «To». Здесь вы можете проверить транзакции, код и события вашего смарт-контракта. На данный момент нам нужно проверить и опубликовать наш контракт. Перейдите в раздел «Code» и нажмите ссылку «Проверить и опубликовать» ‘Verify and Publish’ . Здесь вам нужно будет снова указать имя вашего токена, версию компилятора (в нашем случае последняя использованная нами версия Solidity была 0.5.7, поэтому мы будем придерживаться соответствующей версии компилятора). Теперь вам нужно скопировать код смарт-контракта токена вместе с кодом интерфейса ERC20 из окна Remix в etherscan и нажать «Подтвердить и опубликовать» ‘Verify and Publish’ в нижней части экрана.

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

Пришло время вернуться к адресу вашего контракта. Код на вкладке «Code» теперь будет подвержен проверке. Кроме того, теперь у вас появятся еще две вкладки: «Читать договор» и «Написать договор» ‘Read contract’ & ‘Write contract’. В разделе чтения мы можем проверить функциональность нашего токена. Введите свой адрес (не адрес контракта) в поле ‘balanceOf’, чтобы увидеть, сколько у вас токенов; должно показать 1 миллион, который мы жестко закодировали как общий запас и передали его в наш кошелек. Это означает, что наш токен теперь корректно работает в тестовой сети.

Получение баланса

Послесловие

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

 Если вы можете кодировать смарт контракты, используя другие языки, Solidity все таки лучше подходит для этих целей. Более того, если вы хотите стать разработчиком Ethereum или создавать токены ICO / ERC20 для своего проекта, это безусловно ваш выбор. Если у вас есть некоторый опыт работы с C ++ или JavaScript, кодирование на Solidity должно быть для вас относительно простым. Вам, однако, придется понимать некоторые различия между клиент-серверной и децентрализованной моделями запуска программного обеспечения. Благодаря Ethereum Foundation и некоторым сторонним организациям разработчикам предоставляется набор удобных инструментов, таких как Remix и Etherscan, для кодирования и развертывания интеллектуальных контрактов.

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

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

Сперва рассмотрим понятие смарт-контракта. Смарт-контракт — это простой компьютерный протокол, кодифицированный для обеспечения согласования контракта на платформе Ethereum.

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

Определение бизнес-идеи

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

После того, как вы определитесь с направлением использования, следующий шаг — это техническая часть. Самый первый шаг для вас изучить Solidity. Виртуальная машина Ethereum (EVM) работает на этом языке программирования. Его структура очень похожа на Javascript и C ++, и как только вы тщательно просмотрели свою документацию, изучили этот язык и поняли, как писать код в Solidity, только тогда вы сможете продолжить работу, чтобы получить доступ к требуемому инструментарию для полной работы вашего смарт-контракта. На просторах интернета есть ряд учебных пособий, который непременно помогут вам в изучении Solidity. Вы также можете получить доступ к официальному руководству Solidity от Ethereum по этой ссылке.

Базовые инструменты

Самое первое, что вам понадобится, это инструмент под названием Truffle. Вы можете получить к нему доступ в Github по этой ссылке. Truffle представляет собой основу разработки для Ethereum, в которой вы будете кодировать свою бизнес-идею, используя язык программирования Solidity. Для написания тестов и их развертывания вам нужно будет использовать Node.js. Теперь для большей эффективности вам понадобится то, что будет управлять вашими учетными записями и токенами, с этой целью был создан клиент Parity, который является быстрым и безопасным клиентом Ethereum. Последний должен иметь инструмент в этом списке Web3.js. Разумеется, вам потребуется что-то, что позволит преодолеть разрыв между вашим ноутбуком и сетью Ethereum. Web3.js делает это только путем создания протокола связи с сетью Ethereum с использованием Javascript API.

Написание смарт-контракта

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

Когда у вас есть хорошие теоретические и практические знания о том, как написать код в Solidity, и вы создали все остальные инструменты на своем ноутбуке, такие как Truffle, Node.js, Parity и Web3.js, вы можете начать кодировать собственный смарт-контракт. Поскольку вы уже определили бизнес-идею, для которой вы бы хотели создать смарт-контракт, вам понадобятся знания и понимание Solidity, чтобы закодировать свою бизнес-идею, реализовав ее в Truffle, используя язык Solidity.

Тестирование и развертывание

После того, как ваш смарт-контракт будет кодифицирован и готов, проверьте его на автоматическом модульном тесте. Скомпилируйте свой проверенный смарт-контракт в Truffle и разверните его в оригинальной сети Ethereum или в тестовой сети Ropsten. Оба этих варианта потребуют некоторое количество газа для оплаты обработки.

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

Источник: bit.news