Учебник по Solidity. Все об адресах

Продолжаем серию статей про язык Solidity и платформу Ethereum. В этой статье будет рассказываться про адреса в Ethereum. Статья была написана в августе 2019 года, с той порой язык изменился, поэтому несоответствия в описании автора были исправлены.

Во введении проведено сравнение Ethereum адресов с почтовыми адресами в реальном мире.

Техническая часть начинается с раздела "Что такое (технически) адрес в Ethereum?"

Оглавление

1. Введение

2. Что такое (технически) адрес Ethereum?

3. Основы адресов в Solidity

4. address vs address payable

5. Методы доступные при работе с адресами

6. Преобразование типов address и address payable

7. Методы возвращающие тип address

8. Нулевой адрес

   Ссылки

1. Введение

На август 2021 года в блокчейне Ethereum насчитывается почти 166 миллионов уникальных адресов!

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

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

Хорошим способом намекнуть ему об этом будет отправка открытки с изображением Суздальского Кремля.

Вы идете на почту, и почтальон спрашивает вас: "Куда отправить?", на что вы отвечаете: "Моему другу, Алексу Цветкову".

Сотрудник за стойкой обязательно скажет, что:

1. он не знает, КТО этот ваш друг и 

2. он не знает, ГДЕ он живет.

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

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

Когда письмо прибудет в Москву, почтальон возьмет его и опустит в почтовый ящик Алекса Цветкова: это его домашний адрес.

Простые аналогии

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

Адрес в Ethereum имеет схожие характеристики с почтовыми адресами. Благодаря использованию криптографии с открытым ключом.

Уникальность адреса

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

Даже если в мире существует несколько Алексов Цветковых, но есть только один Алекс Цветков, проживающий по адресу "RU, 121552, Москва, ул. Ярцевская, д. 30".

Почтовый адрес - это как этикетка на почтовом ящике, которая соответствует имени человека и месту, где находится этот почтовый ящик.

Ethereum адрес - это последние 20 байт хэша (хэш функция keccak-256) открытого ключа.

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

Личное и секретное

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

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

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

Аналогично в Ethereum, ваш закрытый ключ хранится в вашем кошельке. Только вы должны знать его и никогда не делиться им!

Управление секретным (закрытым) ключом

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

В Ethereum вы можете использовать свой аккаунт с уникальным закрытым ключом.

Заметка: закрытый или секретный ключ? По сути это одно и тоже. Если вы говорите про “открытый ключ”, то в пару к нему говорите “закрытый ключ”. Если говорите “публичный ключ”, то говорите “секретный ключ”. Зависит от ваших предпочтений как использовать русский язык. Далее по тексту будет использоваться “закрытый” ключ.

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

Закрытые ключи в Ethereum позволяют отправлять ether путем подписания транзакций. Единственным исключением являются смарт-контракты, как мы увидим позже.

Различные типы адресов

Ethereum адрес - это то же самое, что и почтовый адрес: он представляет собой адресата сообщения.

Адрес в платежной части транзакции Ethereum - это то же самое, что и счет получателя при банковском переводе.

Виды адресов в Ethereum: Externally owned accounts, contract accounts

External owned accounts (учетные записи, принадлежащие внешним пользователям, EOA): контролируются закрытыми ключами.

Закрытый ключ даёт контроль над ether на счёте и над процессами аутентификации, необходимой счёту при взаимодействии со смарт-контрактами. Они (закрытые ключи) используются для создания цифровых подписей, которые требуются для транзакций по расходованию любых средств на счете.

Contract accounts (учетные записи смарт-контрактов, CA): самоуправляемы своим своим кодом.

В отличие от EOA, у смарт-контрактов нет открытых или закрытых ключей. Смарт-контракты поддерживаются не закрытым ключом, а присущим им кодом. Можно сказать, что они "владеют собой".

Адрес каждого смарт-контракта определяется в ходе выполнения транзакции по созданию смарт-контракта, как результат функции от источника транзакции и nonce. Ethereum адрес смарт-контракта можно использовать в транзакции в качестве получателя, отправляя средства на смарт-контракт или вызывая одну из функций смарт-контракта.

2. Что такое (технически) адрес Ethereum?

Хэш-функции являются ключевым элементом при создании адресов. Ethereum использует хэш-функцию keccak-256 для генерации адресов.

В Ethereum и Solidity адрес имеет размер в 20 байт (160 бит или 40 шестнадцатеричных символов). Он соответствует последним 20 байтам хэша (keccak-256) открытого ключа. Адрес всегда имеет префикс 0x, поскольку он представлен в шестнадцатеричном формате (нотация base16).

Это определение довольно техническое и звучит сложно. Я выделил жирным шрифтом основные элементы адресного типа. Однако я считаю, что объяснять эти 3 элемента по отдельности - не лучший подход. Скорее, я бы выбрал альтернативный путь, который даст вам более полную картину. Пошагово посмотрим как создаётся адрес в Ethereum.

Как создается адрес Ethereum?

Очень полезно понять процесс создания адреса в Ethereum. Это позволит по-другому взглянуть и понять, как устроена платформа Ethereum.

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

Процесс создания адресов в Ethereum можно разделить на два типа: создание EOA адресов и создание адресов смарт-контрактов.

Как создаются EOA адреса?

Давайте используем спецификацию Yellow Paper и создадим адрес Ethereum с нуля. Мы будем использовать эту статью Винсента Кобеля в качестве пошагового руководства по созданию адреса Ethereum.

1. Начнём с открытого ключа (128 символов / 64 байта)

pubKey = 6e145ccef1033dea239875dd00dfb4fee6e3348b84985c92f103444683bae07b83b5c38e5e...

Примечание: открытый ключ получается из закрытого ключа с помощью ECDSA (алгоритм цифровой подписи на эллиптической кривой). Ethereum использует тот же тип кривой, что и биткоин: secp256k1.

Как выглядит кривая? См. ответ Питера Вуйля на сайте bitcoin.stackexchange.com 

Почему они выбрали именно схему ECDSA? См. обсуждение на форуме Ethereum 

2. Применим хэш (keccak-256) к открытому ключу. Должна получиться строка длиной 64 символа / 32 байта.

Keccak256(pubKey) = 2a5bc342ed616b5ba5732269001d3f1ef827552ae1114027bd3ecf1f086ba0f9

3. Возьмем последние 40 символов / 20 байт из полученного хэша или отбросьте первые 24 символа / 12 байт.

Эти 40 символов / 20 байт являются адресом.

2a5bc342ed616b5ba5732269001d3f1ef827552ae1114027bd3ecf1f086ba0f9

Address = 0x001d3f1ef827552ae1114027bd3ecf1f086ba0f9

С префиксом 0x адрес фактически становится длиной 42 символа. Кроме того, важно отметить, что они нечувствительны к регистру. Все кошельки должны понимать адреса Ethereum, выраженные заглавными или строчными символами. (Начиная с EIP-55, адреса в верхнем регистре используются для проверки контрольной суммы)

0x001d3f1ef827552ae1114027bd3ecf1f086ba0f9 или 0X001D3F1EF827552AE1114027BD3ECF1F086BA0F9

Как создаются адреса смарт-контрактов?

Адреса смарт-контрактов создаются по-другому. Они детерминировано вычисляются из двух вещей:

• Адрес создателя смарт-контракта: sender

• Сколько транзакций отправил создатель: nonce

Ниже описаны шаги по созданию адреса смарт-контракта

1. Возьмите значения sender и nonce.

2. Закодируйте их с помощью RLP

3. Захэшируйте результат с помощью Keccak-256

Вы также можете прочитать больше об этой теме в этом ответе на сайте ethereum.stackexchange.com

Адреса в кратком изложении

В целом, основными характеристиками адресного типа в Solidity являются:

• Длина 20 байт (160 бит): как уже было сказано, Ethereum адрес соответствует последним 20 байтам хэша Keccak-256 связанного с ним открытого ключа.

• Шестнадцатеричный формат (нотация base16): Ethereum адрес содержит ровно 40 символов (2 символа = 1 байт) из шестнадцатеричного диапазона (0 1 2 3 4 5 6 7 8 9 или a b c d e f).

• Префикс 0x: поскольку это шестнадцатеричный формат, он должен иметь префикс 0x. Поэтому его общая длина составляет 42 символа, если считать 0x.

3. Основы адресов в Solidity

Как определить переменную адресного типа?

Чтобы определить переменную адресного типа, укажите ключевое слово address перед именем переменной.

address user = msg.sender;

Мы использовали встроенную функцию Solidity msg.sender для получения адреса текущего аккаунта, взаимодействующего со смарт-контрактом.

Но вы можете жёстко закодировать определенные адреса в коде Solidity, используя адресные литералы. Они описаны в следующем разделе.

Адресные литералы

Адресные литералы - это шестнадцатеричное представление Ethereum адреса, жёстко закодированное в файле Solidity.

Вот пример того, как объявить литерал адреса в Solidity.

address owner = 0xc0ffee254729296a45a3885639AC7E10F9d54979;

Как уже отмечалось ранее, литерал адреса должен:

1. содержать 40 символов (длиной 20 байт), и

2. должны иметь префикс 0x.

3. имеют правильную контрольную сумму

Что касается пункта 3), адресные литералы должны иметь правильную контрольную сумму. Если они не проходят тест на контрольную сумму, Remix или компилятор Solidity выдадут предупреждение и будут рассматривать их как обычные интервалы чисел. Формат контрольной суммы адреса в смешанном регистре определен в EIP-55.

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

4. address vs address payable?

Различие между address и address payable было введено в Solidity версии 0.5.0. Идея заключалась в том, чтобы разграничить адреса, которые могут получать ether, и теми, которые не могут (используются для других целей). Проще говоря, address payable может получать ether, а обычный address - нет.

В Solidity, с точки зрения отправителя:

• Вы можете отправить ether в переменную, определенную как address payable

• Вы не можете отправить ether в переменную, определенную как address

Вы можете использовать ключевое слово payable перед именем переменной типа address, чтобы позволить переменной принимать ether.

contract Vaults {
    // Золотовалютные запасы (не могут получать ether)
    address FortKnox;
    // адрес этого смарт-контракта
    address payable etherVault;
}

Примечание: Тип, возвращаемый msg.sender, является типом address payable.

5. Методы, доступные при работе с адресами

Примечание: количество ether в _amount, указанное в качестве параметра в приведенных ниже методах, выражается в Wei (18 нулей):

1 ether = 1¹⁸ wei = 1 000 000 000 000 000 000 000 000 000 000 wei

Все методы типа address в Solidity:

<address>.balance(uint256)

<address>.code(bytes memory)

<address>.codehash(bytes32)

<address payable>.transfer(uint256 _amount)

<address payable>.send(uint256 _amount) returns (bool)

<address>.call(bytes memory) returns (bool, bytes memory)

<address>.delegatecall(bytes memory) returns (bool, bytes memory)

<address>.staticcall(bytes memory) returns (bool, bytes memory)

Мы разделим методы, связанные с адресами, на 3 категории и 2 типа транзакций:

• методы связанные с ether: balance(), transfer() и send()

• методы связанные с взаимодействием со смарт-контрактами: call() , delegatecall() и staticcall()

• методы связанные с возможным кодом внутри адрес: code(), codehash()

Методы, связанные с ether

Метод: address.balance

возвращает баланс счета в wei.

Любая переменная, определенная как address, имеет метод balance(). Этот метод позволяет получить количество ether, хранящегося на счете, принадлежащем внешнему владельцу (EOA / пользователю) или смарт-контракту. Возвращаемое число представляет собой количество ether в wei.

В приведенном ниже коде показано, как получить ether баланс вашего адреса. В примере мы используем msg.sender.

    // Покажи мне мои деньги!
    address my_account = msg.sender;
    uint256 my_ether_balance = my_account.balance;
    uint256 my_ether_balance = msg.sender.balance;

На самом деле существует два способа посмотреть баланс Ethereum адреса.

    // поиск баланса по _account (Метод 1)
    uint256 public sender_balance = _account.balance;
    
    // поиск баланса с использованием явного преобразования (Метод 2)
    uint256 public sender_balance = address(_account).balance;

Если вы хотите получить остаток по текущему смарт-контракту, мы можем использовать address(this) (это явное преобразование).

    // поиск остатка по текущему контракту (Метод 2)
    uint256 public contract_balance = address(this).balance;

Утверждение типа <address>.balance считается способом чтения информации из состояния, поскольку оно обращается к данным блокчейна. Поэтому любая функция в Solidity, возвращающая <address>.balance, может быть определена как view.

Метод: address.transfer(uint256)

• Переводит указанное количество ether (в wei) на указанный address.

• Возвращает при неудаче и выбрасывает исключение при ошибке.

• Потребляет 2 300 gas.

Под капотом функция transfer() запрашивает баланс адреса, применяя свойство balance, перед отправкой ether.

Метод: address.send(uint256) returns (bool)

send - это низкоуровневый аналог transfer. При неудачном выполнении текущий смарт-контракт не прекратится с выбросом исключением, просто send вернет false.

Использование send сопряжено с некоторыми опасностями: передача не состоится, если глубина стека вызовов равна 1024 (это всегда может быть принудительно исправлено вызывающей стороной), а также если у получателя закончится gas. Поэтому для безопасных переводов ether всегда проверяйте возвращаемое значение send, используйте transfer или даже лучше: используйте шаблон, в котором получатель снимает деньги.

• Аналогичнен address.transfer(uint256)

• Возвращает false при неудаче (Внимание: всегда проверяйте возвращаемое значение send).

• Потребляет газ в размере 2300.

Методы взаимодействия со смарт-контрактами

Solidity предлагает удобный способ вызова функций удалённых смарт-контрактов (например: targetContract.doSomething(...)). Однако этот высокоуровневый синтаксис доступен только в том случае, если интерфейс удалённого смарт-контракта известен на этапе компиляции.

В EVM представлено 4 специальных операционных кодов (opcode) для взаимодействия с другими смарт-контрактами, из которых 3 доступны, как методы типа address: call, delegatecode и staticcall.

Примечание: callcode устарел, но все еще доступен в низкоуровневых ассемблерных вставках.

Все низкоуровневые функции, определенные ниже, принимают один аргумент: необработанное сообщение (Может быть создано в библиотеке web3 с помощью encodeABI()).

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

• Мы рассматриваем сценарий, в котором смарт-контракт A взаимодействует с смарт-контрактом B

• Кто вызывает функции удалённого смарт-контракта (отправляет сообщения)? Хранилище какого смарт-контракта обновляется?

• Технические детали (возвращаемые значения, передаваемый gas и т.д.)

Метод: address.call(bytes memory) returns (bool, bytes memory)

Типичный случай: смарт-контракт A хочет выполнить функцию смарт-контракта B, которая обращается или изменяет хранилище смарт-контракта B. Вызов B.function() может обновить только хранилище B.

ПРЕДУПРЕЖДЕНИЕ: НЕБЕЗОПАСНО! Получатель может (случайно или злонамеренно) израсходовать весь ваш газ, в результате чего ваш смарт-контракт остановится с исключением out of gas (OOG); всегда проверяйте возвращаемое значение метода call.

Следует избегать использования .call() при выполнении функции другого смарт-контракта, так как она обходит проверку типов, проверку существования функции и упаковку аргументов.

Спецификация

• Отправляет сообщение (низкоуровневый CALL, см. опкод OxF1), передавая полезную нагрузку полученную в аргументе и помеченную как memory.

• Передаёт весь доступный газ.

• Возвращает кортеж с:

  • истинностное значение результата вызова (true при успехе, false при неудаче или ошибке).

  • данные в байтовом формате.

Метод: address.callcode(__payload__)

Предупреждение: callcode() устарел, вместо него используется .delegatecall(). Однако его все еще можно использовать в assembly вставках в коде смарт-контракта.

Типичный случай: смарт-контракт A по сути копирует себе функцию B. Выполнение функции смарт-контракта В будет происходить в контексте смарт-контракта A, возможно взаимодействие со хранилищем смарт-контракта А. Вызов B.function() обновит хранилище A.

Спецификация

• Низкоуровневая функция CALLCODE, подобная address(this).call(...), но с заменой кода этого смарт-контракта на код адреса.

• Возвращает false при ошибке.

Метод: address.delegatecall(bytes memory) returns (bool, bytes memory)

Типичный случай: смарт-контракт A хочет выполнить функцию смарт-контракта B, при этом функция будет выполнена в контексте смарт-контракта А. При этом функция B может перезаписать хранилище A и выдать себя за A для любого другого смарт-контракта. Тогда msg.sender будет адресом A, а не B.

В этом случае смарт-контракт A по сути делегирует вызов функции смарт-контракту B. Разница с прежним методом callcode заключается в том, что использование delegatecall позволяет не только перезаписать хранилище смарт-контракта A. Но и если смарт-контракт B вызовет другой смарт-контракт C, смарт-контракт C увидит, что отправителем msg.sender является смарт-контракт A.

Спецификация

• Низкоуровневая операция DELEGATECALL (см. опкод OxF4) (с полным контекстом msg, видимым текущим смарт-контрактом), передавая полезную нагрузку полученную в аргументе и помеченную как memory.

• Передаёт весь доступный газ

• Возвращает кортеж с:

  • истинностным значением как результатом вызова (true при успехе, false при неудаче или ошибке).

  • данные в байтовом формате.

Метод: address.staticcall(bytes memory) returns (bool, bytes memory)

Спецификация

• Низкоуровневая операция STATICCALL (см. опкод OxF4) (с полным контекстом msg, видимым текущим смарт-контрактом), передавая полезную нагрузку полученную в аргументе и помеченную как memor.

• Возвращает кортеж с:

  • истинностным значением как результат вызова (true при успехе, false при неудаче или ошибке).

  • данные в байтовом формате.

• Передаёт весь имеющийся газ

Дополнительные параметры для вызовов низкого уровня

При взаимодействии с смарт-контрактами в Solidity через низкоуровневые вызовы call(...), delegatecall(...) и staticcall(...) у вас есть возможность добавить некоторые пользовательские параметры (немного похоже на web3js). Это позволит вам указать, например, сколько ether вы хотите отправить по адресу, указанному в вызове (value), а также сколько gas вы готовы использовать.

В приведенном ниже фрагменте кода приведен пример.

address(contractRecipient).call{value: 0, gas: 8000}(_data);

6. Преобразование типов address и address payable

• Допускаются неявные преобразования из address payable в address

• Неявные преобразования из address в address payable невозможен (за исключением address payable к address payable).

Примечание: для версии 0.5.* способ преобразования из address в address payable заключался в промежуточном преобразовании в uint160 (160 бит = 20 байт, размер Ethereum адреса). Для версии 0.6.* можно использовать ключевое слово payable, как функцию и передать в неё адрес - payable(address).

• Явное преобразование из и в address разрешено для: целых чисел uint160, целочисленных литералов, bytes20 и типа contract.

• Только выражения типа address и contract могут быть преобразованы в тип address payable с помощью явного преобразования payable(...). Для типа contract это преобразование допустимо только в том случае, если смарт-контракт может получать ether, т.е. смарт-контракт либо имеет функцию receive, либо функцию fallback c payable. Обратите внимание, что payable(0) допустимо и является исключением из этого правила.

Контракты как address

Начиная с версии 0.5.0 Solidity, смарт-контракты больше не cодержат тип address, но все еще могут быть явно преобразованы в address или address payable (если у них есть функция receive или fallback payable).

Примечание: преобразование выполняется с использованием address(переменная) и payable(address(переменная)).

Операторы используемые с address

С address доступны следующие операторы: <=, <, ==, !=, >= и >.

7. Методы, возвращающие тип address

msg.sender

msg.sender() возвращает address payable.

Как следует из названия, функция msg.sender возвращает адрес, который инициировал вызов этого смарт-контракта. Однако важно отметить следующее:

msg.sender возвращается в текущем вызове. Он не обязательно возвращает отправителя EOA, который отправил транзакцию.

• Если смарт-контракт A вызван непосредственно в транзакции отправленной с EOA, то в msg.sender будет адрес EOA.

• Если смарт-контракт A вызван другим смарт-контрактом B, где B был вызван транзакцией отправленной с EOA, то в msg.sender будет адрес смарт-контракта B.

tx.origin

Предупреждение: небезопасно!

tx.origin() возвращает address.

tx.origin возвращает EOA адрес отправителя изначальной транзакции. Таким образом, возвращается полная цепочка вызовов.

block.coinbase

block.coinbase() возвращает address payable.

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

ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) returns (address)

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

• r = первые 32 байта подписи

• s = вторые 32 байта подписи

• v = последний 1 байт подписи

ecrecover возвращает address, а не address payable.

8. Нулевой адрес

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

Так какой же адрес следует указывать в качестве получателя, когда речь идет о создании смарт-контракта?

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

Раздел, связанный с нулевыми адресами из YellowPaper.

Виртуальная машина Ethereum (EVM) понимает, что транзакция направлена на создание нового смарт-контракта, если в поле получателя указан этот нулевой адрес. Этот адрес также имеет длину 20 байт, но содержит только пустые байты 0x0.

В сети Ethereum майнеры выполняют такую транзакцию (содержащую нулевой адрес), как инструкцию по созданию нового смарт-контракта.

Серия статей

1. Учебник по Solidity. Всё о модификаторах

2. Учебник по Solidity. Все об адресах

Ссылки

1. How are ethereum addresses generated? 

2. Create full Ethereum wallet, keypair and address 

3. What is an 'EOA' account? 

4. Difference between CALL, CALLCODE and DELEGATECALL 

5. EIPs/eip-55.md at master · ethereum/EIPs · GitHub: standard to propose backward compatible checksum for Ethereum addresses, by modifying the capitalization of the hexadecimal address.

6. How is the address of an Ethereum contract computed?