Alzheimer🤬

The Best GitHub: лучшие советы и полная настройка

alzheimer — Wed, 01 Mar 2023 08:00:13 GMT

Создание профиля GitHub README 👋

Файл README находится в репозитории GitHub, имя которого совпадает с именем пользователя вашей учетной записи GitHub. Чтобы создать репозиторий, выполните следующие действия:

Войдите в GitHub .
Нажмите значок + в правом верхнем углу страницы и выберите «Новый репозиторий» .

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

Установите флажок «Общедоступный» в разделе «Тип репозитория», чтобы сделать файл README профиля GitHub видимым для всех, кто посещает страницу профиля GitHub. Если вы не хотите, чтобы пользователи видели README вашего профиля GitHub, пока он еще находится в разработке, вы можете выбрать Private . Когда вы закончите разработку README, обязательно измените видимость на Public .
Установите флажок Добавить файл README . Это добавит README.mdфайл, в который мы добавим содержимое профиля. Значения полей должны выглядеть примерно так, как показано на рисунке ниже.

Нажмите на кнопку «Создать репозиторий» . Специальный репозиторий успешно создан. Перейдите в репозиторий, который вы только что создали, и вы увидите файл, README.mdдобавленный в репозиторий.

В следующих нескольких разделах мы добавим содержимое в наш README.mdфайл. Мы будем использовать файловый редактор GitHub для записи и предварительного просмотра изменений. Вы можете использовать любой другой удобный текстовый редактор.

Чтобы использовать редактор файлов GitHub, откройте README.mdи щелкните значок «Редактировать этот файл» (значок карандаша) в правом верхнем углу страницы. Подробнее о редактировании файлов GitHub можно прочитать в официальной документации GitHub по редактированию файлов .

Добавление GIF-баннера и раздела «Обо мне»

Заголовок профиля GitHub

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

После вставки простого заголовка, чтобы предоставить ссылки на мои различные учетные записи, такие как LinkedIn, Medium, Dev.to, а также на мой сайт-портфолио, я хотел сделать это минималистичным и бестекстовым способом. Итак, я решил использовать иконки. Существует множество доступных онлайн-инструментов, которые предоставляют тысячи бесплатных иконок для использования. Я использовал IconFinder и лично мне понравилось. Есть много других популярных опций, которые вы можете использовать, например Shields.io , markdown-badges , vector-logo-zone , simple-icons и т. д.

Просто нужно импортировать исходный файл значка в формате png в тег , как показано ниже :

Теперь самое интересное — добавить эту великолепную гифку! GIF-файлы делают наш профиль более динамичным и привлекательным . Честно говоря, вы можете разместить любую GIF, которую хотите. Это может быть популярный мем, гифка о программировании, культовая сцена из фильма или телешоу или что-то, что немного рассказывает людям о ваших увлечениях. В моем случае это аниме, так что я выбрал его. Популярные веб-сайты для обмена gif-файлами, такие как Giphy и Tenor, можно использовать для извлечения любого понравившегося вам gif-файла, и это работает так же, как добавление значков, просто скопируйте адрес изображения и вставьте его в атрибут «src» тега .

Раздел «Обо мне» 👨‍💻

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

Раздел «Обо мне»

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

```yaml * ЗДЕСЬ ИДЕТ ВАШ ТЕКСТ * ```

Инструменты и технические вещи 🧰

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

Вы можете использовать все, что я упомянул выше, например IconFinder , Shields.io , markdown-badges , vector-logo-zone , simple-icons и т. д. Но для этого раздела я бы лично рекомендовал DevIcon . В отличие от других ресурсов, DevIcon создан для предоставления значков, связанных исключительно с языками программирования и инструментами разработки, что делает его идеальным.

Раздел навыков GitHub

Просто скопируйте источник изображения SVG с веб-сайта DevIcon и вставьте его в тег

, чтобы отобразить несколько значков!

🚀 Some Tools I Have Used and Learned

Ваша история GitHub 📈

Наконец, в конце файла README вашего профиля вы можете указать практически что угодно. Некоторые разработчики размещают то, что сейчас играет, в своем профиле Spotify , некоторые добавляют свою статистику GitHub , а некоторые добавляют забавную маленькую игру в змейку на вашем графике вкладов GitHub, как я, и я покажу вам, ребята, как разместить!

Статистика на GitHub

Я начну с двух статистических карточек GitHub ReadMe. Один показывает мое общее количество звезд, коммитов и пулреквестов и т. д. А другой отображает мои наиболее используемые языки программирования в процентах. Вы, ребята, можете получить эти карты из популярного репозитория GitHub ReadMe Stats Repo , и самое приятное в них то, что они полностью настраиваются с различными настройками и темами!

Далее, вероятно, моя любимая вещь из всех элементов моего профиля. Создание игры «Змейка» из вашего графика вкладов GitHub . Его довольно легко настроить, и он выглядит очень удовлетворительно, когда змея поглощает ваш график коммитов.

Чтобы настроить его для вашего профиля, мы собираемся использовать то, что называется GitHub Actions. GitHub Actions — это инструменты CI/CD в GitHub, с помощью которых вы можете инициировать рабочие процессы, которые автоматически запускают, развертывают и создают ваши материалы.

![Snake animation]( https://github.com/thepiyushmalhotra/thepiyushmalhotra/blob/output/github-contribution-grid-snake.svg )

Первый шаг — скопировать эту строку выше и добавить ее в файл README вашего профиля. Не забудьте изменить имя пользователя на свое, а не на мое.
Теперь нам нужно создать рабочий процесс GitHub, чтобы график вклада в анимации змеи обновлялся в соответствии с заданием cron, которое мы настроим.
Перейдите на вкладку «Действия» в репозитории README и создайте новый рабочий процесс. Это создаст новую папку в вашем репозитории с именем «.github/workflows», а после этого внутри нее будет создан новый файл с именем «main.yml».

Настройте новый рабочий процесс

файл main.yml

Удалите все внутри только что созданного файла main.yml и добавьте в него этот код ниже:

name: Generate Datason:  schedule: # execute every 12 hours    - cron: "* */12 * * *"  workflow_dispatch:jobs:  build:    name: Jobs to update datas    runs-on: ubuntu-latest    steps:      # Snake Animation      - uses: Platane/snk@master        id: snake-gifwith:          github_user_name: thepiyushmalhotra          svg_out_path: dist/github-contribution-grid-snake.svg      - uses: crazy-max/ghaction-github-pages@v2.1.3        with:          target_branch: output          build_dir: dist        env:          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Не забудьте заменить мое имя пользователя на ваше. Здесь мы используем cronjob , который обновляется каждые 12 часов, поэтому всякий раз, когда у вас есть новый коммит, он будет добавлен в вашу анимацию змеи.
Последний шаг — вернуться на страницу «Действия» файла README, щелкнуть только что созданный рабочий процесс «Создать данные» или любое имя, которое вы ему дадите, и нажать кнопку «Запустить рабочий процесс».

Запустите свой рабочий процесс

И вуаля! Теперь ваш график вклада Snake в GitHub активен. Наслаждайтесь просмотром, как эта змея съедает вашу тяжелую работу! Чтобы завершить все это, я просто добавил еще одну анимацию рендеринга капсулы в нижний колонтитул, которая выглядела хорошо, как вы можете видеть в GIF выше.

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

Awesome-GitHub-Profile-Readme — список замечательных файлов Readme от многих талантливых разработчиков!
GitHub Readme Generator — простой способ быстро создать базовый шаблон дизайна для вашего профиля.
Узнайте больше о действиях GitHub , если вы заинтересованы в автоматизации.
Создавайте различные метрики GitHub , которые можно встраивать где угодно.
Если вам нужен быстрый и простой способ создания cronjobs и узнать о них больше, то Crontab Guru — довольно хороший ресурс, и вы узнаете точное время, когда будет выполняться ваш рабочий процесс.

Как внедрить стандарт Diamond

alzheimer — Wed, 22 Feb 2023 11:20:12 GMT

Diamond Standard, EIP-2535, был создан Ником Маджем как стандартизированная архитектура для реализации смарт-контрактов через прокси. В этой статье мы рассмотрим плюсы использования Diamond Standard и принципы его работы.

Общий обзор

Алмазный стандарт работает путем развертывания контракта под названием Diamond.sol. Diamond.sol, затем вызывает другие смарт-контракты через delegatecall(). Это позволяет Diamond.solвыполнять код вызываемого контракта в контексте Diamond.sol. Все контракты, которые вызываются с помощью, delegatecall()называются фасетами. Фасеты можно заменять, удалять и добавлять с течением времени, что позволяет разработчикам создавать модульные приложения на блокчейнах, совместимых с EVM. Алмазный стандарт требует от вас реализации DiamondLoupeFacet.sol. DiamondLoupeFacet.solотвечает за документирование других аспектов вашего протокола. DiamondLoupeFacet.solобеспечивает прозрачность, позволяя пользователям видеть адреса и функции фасетов. Еще одно требование Алмазного стандарта DiamondCutFacet.sol. DiamondCutFacet.solотвечает за все обновления вашего приложения.DiamondCutFacet.solтакже генерирует события при вызове, обеспечивая другой уровень прозрачности для пользователей протокола. Хотя это и не является обязательным требованием, LibDiamond.solэто библиотека, которая предоставляет множество вспомогательных функций для написания приложения с помощью стандарта Diamond. При создании приложения с помощью Diamond Standard вы можете использовать один из двух способов сохранения переменных состояния. Их называют App Storageи Diamond Storage. Мы рассмотрим все компоненты Diamond Standard более подробно в оставшейся части статьи.

Алмазный стандарт имеет три различных варианта реализации. К счастью, если вы решите, что выбрали неправильную реализацию, можно обновить приложение до другой реализации. diamond-1является самой базовой реализацией. Сложность diamond-1проще всего понять, а затраты на газ самые низкие. Не рекомендуется вызывать DiamondLoupeFacet.solфункции по цепочке с diamond-1(или diamond-2) из-за высоких затрат на газ. diamond-3, с другой стороны, выбирает оптимизацию DiamondLoupeFacet.solфункций вызова в цепочке. Компромисс заключается в том, что звонки обходятся дороже DiamondCutFacet.sol. diamond-2очень похоже наdiamond-1, но оптимизирует затраты на газ по сравнению со сложностью для понимания. Вам, как разработчику, решать, какая из этих реализаций лучше всего подходит для вашего приложения.

Из-за сложности Diamond Standard рекомендуется следовать общему шаблону при создании приложений. Я свяжу эти шаблоны внизу статьи вместе с дополнительными материалами для чтения.

Зачем использовать Алмазный стандарт?

Основная критика стандарта Diamond — его сложность (надеюсь, я смогу помочь решить эту проблему). Несмотря на сложность, Diamond Standard обеспечивает следующие преимущества:

Практических ограничений на размер вашего приложения нет. Все смарт-контракты имеют максимальный размер 24 КБ. Поскольку Diamond Standard использует Diamond.solсвои delegatecall()грани, размер контракта остается относительно небольшим.
Вы используете только один адрес для множества функций. Опять же, благодаря delegatecall(), вы можете добавить все необходимые функции в один смарт-контракт. Это включает в себя реализацию токенов с тем же адресом, что и ваш протокол.
Он обеспечивает организованный способ обновления ваших смарт-контрактов. Это может помочь аудиторам понять и защитить ваше приложение.
Это позволяет вам постепенно обновлять свои смарт-контракты. Вместо повторного развертывания всего контракта вы можете просто добавить, заменить или удалить фасет, чтобы обеспечить желаемую функциональность вашего приложения.
Это обеспечивает высокий уровень прозрачности для вашего прокси-контракта. Как упоминалось ранее, DiamondLoupeFacet.solпозволяет пользователям видеть, где находятся ваши функции в блокчейне и что они выполняют. Посетите https://louper.dev/ , чтобы проанализировать функциональность смарт-контрактов, использующих преимущества Diamond Standard.
Практически нет ограничений на количество аспектов, которые можно использовать в вашем приложении. Единственный способ, которым вы не сможете добавить больше фасетов в свой протокол, — это Diamond.solнехватка места для хранения данных фасетов. Для этого потребуется смехотворно большое количество граней, вплоть до того, что это практически невозможно.
Фасеты могут быть повторно использованы несколькими Diamond.solконтрактами. Это позволяет экономить на газе при развертывании приложений, которые заимствуют функциональные возможности.
При желании вы можете запустить оптимизатор с более высокими настройками. Оптимизатор Solidity помогает оптимизировать затраты газа при вызове внешних функций. Однако это увеличивает байт-код развертывания контракта. Это может привести к тому, что ваш смарт-контракт превысит максимальный размер смарт-контракта. Поскольку вы можете развертывать столько аспектов, сколько хотите, вы можете настроить оптимизатор на столько запусков, сколько пожелаете, не беспокоясь о том, что ваш контракт слишком велик.

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

Хранилище приложений и алмазное хранилище

Архитектура переменных состояния — один из наиболее важных аспектов вашего блокчейн-приложения. Я решил сначала рассмотреть этот раздел, чтобы дать вам хорошее представление о том, как переменные состояния управляются с помощью Diamond Standard. Очевидно, что прокси в значительной степени полагаются на delegatecall()выполнение кода из ваших фасетных контрактов в контексте вашего основного контракта ( Diamond.sol). Поскольку все хранилище наших переменных состояния хранится в Diamond.sol, нам нужно убедиться, что наши переменные не перезаписывают друг друга. Прежде чем мы рассмотрим правильный способ организации наших переменных состояния, давайте рассмотрим пример неправильного способа управления переменными состояния.

pragma solidity^0.8.17;0.8.17;

contract Main {
uint256 public verySpecialVar;
uint256 public notSoSpecialVar;
// delegate calls SpecialVarManager to update verySpecialVar
function setVerySpecialVar(address _specialVarManager) external {
_specialVarManager.delegatecall(
abi.encodeWithSignature("writeSpecialVar()")
);
}
// delegate calls NotSpecialVarManager to update notSoSpecialVar
function setNotSoSpecialVar(address _notSpecialVarManager) external {
_notSpecialVarManager.delegatecall(
abi.encodeWithSignature("writeNotSpecialVar()")
);
}

}
contract SpecialVarManager {
uint256 verySpecialVar;
function writeSpecialVar() external {
verySpecialVar = 100;
}
}
contract NotSpecialVarManager {
uint256 notSoSpecialVar;
function writeNotSpecialVar() external {
notSoSpecialVar = 50;
}
}

Если вы позвоните, setVerySpecialVar()вы увидите, verySpecialVarчто был обновлен до 100! Теперь давайте позвоним setNotSoSpecialVarи посмотрим, что произойдет. Мы видим, notSoSpecialVarчто он все еще не инициализирован и равен 0. Если мы проверим, то verySpecialVarувидим, что сейчас он установлен на 50. Почему? Ну, в схеме хранения NotSpecialVarManagerнет verySpecialVar. Поэтому, когда мы вызываем writeNotSpecialVar()via, delegatecall()мы сообщаем Mainоб обновлении слота хранения с 0 до 50. Solidity не заботится о том, как вы называете свои переменные; он смотрит только на положение слота для хранения.

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

Diamond Storage использует количество слотов для хранения Solidity в смарт-контракте (2²⁵⁶). Теория, лежащая в основе Diamond Storage, заключается в том, что, поскольку слотов для хранения так много, что если мы хэшируем уникальное значение, мы получим случайный слот для хранения, который почти наверняка не будет конфликтовать с другим слотом для хранения. Это может показаться рискованным, но на самом деле это тот же процесс, который Solidity использует для хранения отображений и динамических массивов. Diamond Storage дает возможность вашим фасетам сохранять переменные состояния, специфичные для их контракта, а также позволяет фасетам совместно использовать переменные состояния, если это необходимо.

Поскольку сложность Diamond Standard требует небольшой настройки, для этих примеров хранения я не буду использовать Diamond Standard. Основная цель этого раздела — понять принципы хранения переменных состояния. Реализация в Diamond Standard в основном такая же.

pragma solidity^0.8.17;0.8.17;

library SharedLib {
// struct that with state variable
struct DiamondStorage {
uint256 sharedVar;
}
// returns a storage variable with our state variable
function diamondStorage() internal pure returns(DiamondStorage storage ds) {
// gets a "random" storage positon by hashing a string
bytes32 storagePosition = keccak256(abi.encode("Diamond.Storage.SharedLib"));
// assigns our struct storage slot to storage position
assembly {
ds.slot := storagePosition
}

}
}
// not the actual Diamond Standard
contract PseudoDiamond {
// delegate calls Facet1 to update sharedVar
function writeToSharedVar(address _facet1, uint256 _value) external {
// writes via delegate call
_facet1.delegatecall(
abi.encodeWithSignature("writeShared(uint256)", _value)
);
}
// delegate calls Facet2 to read sharedVar
function readSharedVar(address _facet2) external returns (uint256) {
// returns result of delegate call
(bool success, bytes memory _valueBytes) = _facet2.delegatecall(
abi.encodeWithSignature("readShared()")
);
// since return value is bytes array we use assembly to retrieve our uint
bytes32 _value;
assembly {
let location := _valueBytes
_value := mload( add(location, 0x20) )
}
return uint256(_value);
}
}
contract Facet1 {
function writeShared(uint256 _value) external {
// initializes the storage struct by calling library function
SharedLib.DiamondStorage storage ds = SharedLib.diamondStorage();
// writes to shared variable
ds.sharedVar = _value;

}
}
contract Facet2 {

function readShared() external view returns (uint256) {
// initializes the storage struct by calling library function
SharedLib.DiamondStorage storage ds = SharedLib.diamondStorage();

// returns shared variable
return ds.sharedVar;

}
}

Если вы позвоните PseudoDiamond.writeSharedVar(), то PseudoDiamond.readSharedVar()увидите свое значение. Используя библиотеку и индексируя «случайный» слот для хранения, мы можем обмениваться переменными между двумя смарт-контрактами. Когда мы используем delegatecall()оба аспекта, он смотрит на позицию хранения структуры DiamondStorageдля доступа к этой переменной. Благодаря явной связи между аспектами того, где мы хотим хранить наши данные, мы предотвращаем коллизии переменных состояния. Если вы хотите иметь переменные состояния только для одного из ваших аспектов, вы можете просто создать библиотеку, аналогичную SharedLib, и реализовать ее только в этом конкретном аспекте.

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

pragma solidity^0.8.17;

// struct with state variable
struct StateVars {
uint256 sharedVar;
}
// our app storage struct
struct AppStorage {
StateVars state;
}
// not the actual Diamond Standard
contract PseudoDiamond {
AppStorage s;
// delegate calls Facet1 to update sharedVar
function writeToSharedVar(address _facet1, uint256 _value) external {
// writes via delegate call
_facet1.delegatecall(
abi.encodeWithSignature("writeShared(uint256)", _value)
);
}
// delegate calls Facet2 to read sharedVar
function readSharedVar(address _facet2) external returns (uint256) {
// returns result of delegate call
(bool success, bytes memory _valueBytes) = _facet2.delegatecall(
abi.encodeWithSignature("readShared()")
);
// since return value is bytes array we use assembly to retrieve our uint
bytes32 _value;
assembly {
let location := _valueBytes
_value := mload( add(location, 0x20) )
}
return uint256(_value);
}
}
contract Facet1 {
AppStorage s;
function writeShared(uint256 _value) external {
// writes to our state variable in storage
s.state.sharedVar = _value;
}
}
contract Facet2 {
AppStorage s;

function readShared() external view returns (uint256) {
// returns state variable from app storage
return s.state.sharedVar;
}
}

Если вы посмотрите на значение в слоте хранения 0 для PseudoDiamond, вы увидите 100, что является нашим значением! Важное замечание о App Storage: если вам нужно обновить AppStorage после развертывания, обязательно добавьте новые переменные состояния в конец AppStorage, чтобы предотвратить коллизии хранилища. Лично я предпочитаю App Storage для организации Diamond Storage, но оба они выполняют свою работу. Также стоит отметить, что Diamond Storage и App Storage не являются эксклюзивными. Даже если вы используете App Storage для управления переменными состояния LibDiamond.sol, используйте Diamond Storage для управления данными аспектов.

Diamond.sol

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

Давайте сначала посмотрим, что происходит в конструкторе diamond-1.

// This is used in diamond constructor
// more arguments are added to this struct
// this avoids stack too deep errors
struct DiamondArgs {
address owner;
address init;
bytes initCalldata;
}

contract Diamond {
constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {
LibDiamond.setContractOwner(_args.owner);
LibDiamond.diamondCut(_diamondCut, _args.init, _args.initCalldata);
// Code can be added here to perform actions and set state variables.
}
// rest of code
}

Во-первых, вне контракта у нас есть структура, которая форматирует наши данные. Затем мы передаем эту структуру в качестве параметра вместе с другой структурой, которая выглядит так:

struct FacetCut {
address facetAddress;address facetAddress;
FacetCutAction action;
bytes4[] functionSelectors;
}

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

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

contract Diamond {

constructor(address _contractOwner, address _diamondCutFacet) payable {
LibDiamond.setContractOwner(_contractOwner);
// Add the diamondCut external function from the diamondCutFacet
IDiamondCut.FacetCut[] memory cut = new IDiamondCut.FacetCut[](1);
bytes4[] memory functionSelectors = new bytes4[](1);
functionSelectors[0] = IDiamondCut.diamondCut.selector;
cut[0] = IDiamondCut.FacetCut({
facetAddress: _diamondCutFacet,
action: IDiamondCut.FacetCutAction.Add,
functionSelectors: functionSelectors
});
LibDiamond.diamondCut(cut, address(0), "");
}
// rest of code
}

На этот раз мы передаем только владельца контракта и адрес DiamondCutFacet.sol. Далее мы назначаем владельца Алмаза. После этого мы добавляем diamondCut()функцию, чтобы мы могли добавить больше аспектов. Мы делаем это, сначала инициализируя массив памяти одним элементом типа struct FacetCut, который мы видели ранее. Затем мы инициализируем другой массив одним элементом. На этот раз это массив bytes4, и он используется для хранения diamondCut()селектора функций . Затем мы назначаем селектор функции массиву, вызывая функцию интерфейса Diamond Cut diamondCutи получая ее селектор. После этого мы можем назначить cut[0]. Мы используем адрес DiamondCutFacet.sol, add (потому что мы хотим добавить эту грань к нашему Алмазу) и массив селекторов функций. Наконец, мы фактически добавляемdiamondCut. Это много незнания того, что происходит под капотом, поэтому, если это поможет, вы можете перечитать этот раздел после того, как мы пройдемся по DiamondCut.sol. Пока просто поймите, что мы добавляем фасеты в конструкторе.

Последняя часть — Diamond.solэто fallback()функция. Вот как мы будем называть наши грани в Diamond Standard. Он выглядит почти одинаково во всех трех реализациях Diamond Standard, так что давайте рассмотрим его!

// Find facet for function that is called and execute the
// function if a facet is found and return any value.
fallback() external payable {
LibDiamond.DiamondStorage storage ds;
bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;
// get diamond storage
assembly {
ds.slot := position
}
// get facet from function selector
address facet = address(bytes20(ds.facets[msg.sig]));
require(facet != address(0), "Diamond: Function does not exist");
// Execute external function from facet using delegatecall and return any value.
assembly {
// copy function selector and any arguments
calldatacopy(0, 0, calldatasize())
// execute function call using the facet
let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)
// get any return value
returndatacopy(0, 0, returndatasize())
// return any return value or error back to the caller
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}

Первое, что мы делаем, это инициализируем Diamond Storage. Здесь мы будем хранить данные нашего фасета. Далее, где находится разница в fallback()s. Мы смотрим diamond-2выше. Во всех трех мы проверяем, существует ли адрес фасета.
Вот как мы регистрируемся diamond-1:

// get facet from function selector
address facet = ds.facetAddressAndSelectorPosition[msg.sig].facetAddress;
if(facet == address(0)) {
revert FunctionNotFound(msg.sig);
}

Вот как мы регистрируемся diamond-3:

// get facet from function selector
address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;
require(facet != address(0), "Diamond: Function does not exist");

Основное различие в трех реализациях заключается в том, что diamond-2мы храним селекторы в сопоставлении 32-байтовых слотов памяти.

Наконец, мы используем Yul для delegatecall()наших аспектов, копируя данные вызова, которые были отправлены на Diamond.sol, и проверяя, был ли вызов успешным.

На этом наш раздел о Diamond.sol. Далее мы рассмотрим, что происходило, когда мы звонили diamondCut().

DiamondCut.sol

Как мы уже обсуждали, DiamondCut.solотвечает за добавление, удаление и замену граней в нашем Алмазе. Все три реализации используют несколько иной подход, но достигают одной и той же цели. Давайте посмотрим, как diamond-1работает.

contract DiamondCutFacet is IDiamondCut {
/// @notice Add/replace/remove any number of functions and optionally execute/// @notice Add/replace/remove any number of functions and optionally execute
/// a function with delegatecall
/// @param _diamondCut Contains the facet addresses and function selectors
/// @param _init The address of the contract or facet to execute _calldata
/// @param _calldata A function call, including function selector and arguments
/// _calldata is executed with delegatecall on _init
function diamondCut(
FacetCut[] calldata _diamondCut,
address _init,
bytes calldata _calldata
) external override {
LibDiamond.enforceIsContractOwner();
LibDiamond.diamondCut(_diamondCut, _init, _calldata);
}
}

Как видите, этот контракт сильно зависит от LibDiamond.sol. Все, что мы делаем, исходя из общего обзора, — это проверяем, что владелец контракта сделал этот вызов, а затем вызываем diamondCut(). Давайте посмотрим, что происходит в LibDiamond.sol. Прежде чем мы это сделаем, я должен указать на одну большую деталь о LibDiamond.sol. LibDiamond.solиспользует исключительно internalфункции. Это добавляет байт-код к нашему контракту, избавляя нас от необходимости использовать другой файл delegatecall().

Хорошо, теперь, когда мы понимаем, как сэкономить на топливе в LibDiamond.sol, давайте посмотрим на код diamondCut().

// Internal function version of diamondCut
function diamondCut(
IDiamondCut.FacetCut[] memory _diamondCut,
address _init,
bytes memory _calldata
) internal {
for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {
bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;
address facetAddress = _diamondCut[facetIndex].facetAddress;
if(functionSelectors.length == 0) {
revert NoSelectorsProvidedForFacetForCut(facetAddress);
}
IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;
if (action == IDiamond.FacetCutAction.Add) {
addFunctions(facetAddress, functionSelectors);
} else if (action == IDiamond.FacetCutAction.Replace) {
replaceFunctions(facetAddress, functionSelectors);
} else if (action == IDiamond.FacetCutAction.Remove) {
removeFunctions(facetAddress, functionSelectors);
} else {
revert IncorrectFacetCutAction(uint8(action));
}
}
emit DiamondCut(_diamondCut, _init, _calldata);
initializeDiamondCut(_init, _calldata);
}

Мы берем те же параметры, что и раньше для этой функции. Сначала мы прокручиваем нашу FacetCutструктуру. Внутри цикла мы получаем наш селектор функций и адрес фасетной функции. Мы удостоверяемся, что селектор фасета действителен, и возвращаемся в противном случае. Затем нам нужно проверить действие, которое мы выполняем с этой конкретной функцией (добавить, заменить или удалить). Найдя действие, мы вызываем вспомогательную функцию, которая коррелирует с этим действием. Затем мы создаем событие, чтобы обеспечить прозрачность для наших пользователей. Наконец, мы проверяем, работает ли наш фасет, initializeDiamondCut()проверяя, имеет ли наш контракт код и может ли он быть вызван через delegatecall()with _calldata.

Теперь, когда мы знаем, как это diamondCut()работает, давайте посмотрим, как мы выполняем каждое действие, начинающееся с Add.

Входными параметрами являются адрес фасетного контракта и селектор конкретной функции, с которой мы работаем. Мы хотим убедиться, что этот контракт существует, проверив, является ли адрес нулевым адресом. Далее мы инициализируем Diamond Storage. Затем мы получаем количество селекторов, которые уже есть у нашего Алмаза. После этого мы проверяем, есть ли у нашего фасета код контракта. Теперь нам нужно убедиться, что этой функции еще нет в Diamond. Мы делаем это, перебирая селекторы функций и проверяя, существует ли уже адрес. В противном случае мы нажимаем наш селектор на наши сохраненные селекторы.

Теперь давайте посмотрим, как заменить грань!

Как вы могли заметить, Replaceзапускается так же, как Add. Мы инициализируем Diamond Storage, проверяем, имеет ли фасет допустимый адрес и размер кода, затем прокручиваем селекторы. Во-первых, мы проверяем, является ли селектор неизменным. Затем мы проверяем, является ли функция, которую мы хотим заменить, той же функцией, которую мы добавляем. После этого мы проверяем, действителен ли адрес фасета. В противном случае мы заменяем нашу грань.

Теперь давайте проверим наше последнее действие, Remove.

function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal { removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {
DiamondStorage storage ds = diamondStorage();
uint256 selectorCount = ds.selectors.length;
if(_facetAddress != address(0)) {
revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);
}
for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {
bytes4 selector = _functionSelectors[selectorIndex];
FacetAddressAndSelectorPosition memory oldFacetAddressAndSelectorPosition = ds.facetAddressAndSelectorPosition[selector];
if(oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {
revert CannotRemoveFunctionThatDoesNotExist(selector);
}

// can't remove immutable functions — functions defined directly in the diamond
if(oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {
revert CannotRemoveImmutableFunction(selector);
}
// replace selector with last selector
selectorCount--;
if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {
bytes4 lastSelector = ds.selectors[selectorCount];
ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;
ds.facetAddressAndSelectorPosition[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;
}
// delete last selector
ds.selectors.pop();
delete ds.facetAddressAndSelectorPosition[selector];
}
}

Опять же, мы начинаем с инициализации Diamond Storage, проверяя, имеет ли фасет действительный адрес, а затем прокручиваем селекторы. Затем мы получаем селектор функций и позицию в памяти. Мы проверяем, что он действительно существует, а затем проверяем, что он не является неизменным. После этого мы перемещаем наш селектор в конец массива и выполняем операцию pop()для его удаления.

diamond-2и diamond-3обе достигают той же цели, что и diamond-1функция diamondCut(), но используют другой синтаксис и архитектуру. Для простоты этой статьи мы не будем останавливаться на них. Однако, если достаточное количество людей будет заинтересовано в том, чтобы узнать, как они работают, я могу написать новую статью в будущем, в которой будут более подробно описаны различия в реализациях.

LoupeFacet.sol

Теперь, когда мы понимаем, как обновлять функции в нашем Алмазе, давайте рассмотрим, как мы можем просматривать наши грани. Помните, что for diamond-1и diamond-2не рекомендуется вызывать эти функции по цепочке. diamond-3, однако сильно оптимизирован для вызова этих функций в цепочке. Опять же, мы будем только повторяться diamond-1, но если вы понимаете, что происходит, вы должны быть в состоянии как понять, так и реализовать любую из других реализаций Diamond Standard.

Сначала мы рассмотрим facets(). facets(), возвращает все грани и их селекторы для Diamond.

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

struct Facet {
address facetAddress;address facetAddress;
bytes4[] functionSelectors;
}

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

Следующая функция, которую мы рассмотрим, это facetFunctionSelectors(). facetFunctionSelectors()возвращает селекторы функций для определенного аспекта. Он принимает в качестве параметра адрес целевого фасета и возвращает массив, bytes4[]представляющий селекторы функций.

Снова инициализируем Diamond Storage. Затем мы получаем количество селекторов функций и инициализируем наш возвращаемый массив. Далее мы прокручиваем селекторы. Здесь мы проверяем, совпадает ли адрес селектора с нашим целевым аспектом. Если это так, мы сохраняем этот селектор функций. Наконец, мы сохраняем количество селекторов и возвращаемся.

Теперь рассмотрим facetAddresses(), который возвращает массив адресов граней нашего Алмаза.

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

Последняя функция, которую мы рассмотрим, DiamondLoupeFacet.solэто facetAddress. Эта функция возвращает адрес фасета, предоставленного селектором функции.

function facetAddress(bytes4 _functionSelector) external override view returns (address facetAddress_) {facetAddress(bytes4 _functionSelector) external override view returns (address facetAddress_) {
LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();
facetAddress_ = ds.facetAddressAndSelectorPosition[_functionSelector].facetAddress;
}

Эта функция довольно проста. Мы инициализируем Diamond Storage и используем то, как мы храним наши селекторы, чтобы вернуть наш адрес фасета.

На этом мы завершаем наш раздел, посвященный аспекту лупы. Теперь мы знаем, как Diamond Standard обеспечивает прозрачность для своих пользователей. Далее мы рассмотрим, как работает развертывание Diamond Standard.

Как развернуть Diamond Standard

При развертывании Diamond вам необходимо развернуть фасеты, а затем развернуть файлы Diamond.sol. Таким образом, вы можете сообщить своему Бриллианту, какие контракты он будет вызывать. Самый простой способ развернуть Diamond — с помощью пакета npm diamond-util. Вот как его установить:

npm i diamond-utili diamond-util

После его установки вы можете развернуть свой Diamond с помощью следующего кода.

// eslint-disable-next-line no-unused-vars
const deployedDiamond = await diamond.deploy({
diamondName: 'LeaseDiamond',
facets: [
'DiamondCutFacet',
'DiamondLoupeFacet',
'Facet1',
'Facet2'
],
args: [/* your parameters */]
})

// init facets
const diamondCutFacet = await ethers.getContractAt('DiamondCutFacet', deployedDiamond.address)
const diamondLoupeFacet = await ethers.getContractAt('DiamondLoupeFacet', deployedDiamond.address)
const facet1 = await ethers.getContractAt('Facet1', deployedDiamond.address)
const facet2 = await ethers.getContractAt('Facet2', deployedDiamond.address)

Эта библиотека берет на себя большую часть работы за нас! Все, что нам нужно сделать, это перечислить наши аспекты, и библиотека развернет их вместе с бриллиантом. Обратите внимание, что когда мы инициализируем наши контракты, ethers.jsмы устанавливаем адрес на Diamond.solадрес .

Если вы хотите добавить новый аспект, вы можете сделать это, вызвав DiamondCutFacet.sol. Вот пример.

const FacetCutAction = { Add: 0, Replace: 1, Remove: 2 }

const Facet3 = await ethers.getContractFactory('Facet3')
const facet3 = await Facet3.deploy()
await facet3.deployed()
const selectors = getSelectors(facet3).remove(['supportsInterface(bytes4)'])
tx = await diamondCutFacet.diamondCut(
[{
facetAddress: facet3.address,
action: FacetCutAction.Add,
functionSelectors: selectors
}],
ethers.constants.AddressZero, '0x', { gasLimit: 800000 }
)

receipt = await tx.wait()

Как видите, сначала мы развертываем наш фасет. Затем мы используем наш пакет npm для получения селекторов функций. Затем мы вызываем DiamondCutFacet.solобновить наш Diamond. Replaceработает аналогично, за исключением того, что вы должны убедиться, что заменяемые селекторы уже есть в Diamond. Remove, также работает аналогично, но убедитесь, что вы передаете именно те селекторы, которые хотите удалить.

Поздравляем! Теперь вы знаете, как создать и развернуть приложение блокчейна с помощью Diamond Standard!

Заключение

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

Интернет-сообщества

alzheimer — Sat, 11 Feb 2023 07:32:25 GMT

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

Форумы

r/ethereum — все, что связано с Ethereum

r/ethfinance — финансовая сторона Ethereum, включая DeFi

r/ethdev — сосредоточен на разработке Ethereum

r/ethtrader — тенденции и анализ рынка

r/ethstaker — добро пожаловать всем, кто интересуется стейкингом на Ethereum

Fellowship of Ethereum Magicians — сообщество, ориентированное на технические стандарты Ethereum.

Ethereum Stackexchange — обсуждение и помощь разработчикам Ethereum

Ethereum Research — самая влиятельная доска объявлений для криптоэкономических исследований

Чаты

Ethereum Cat Herders — сообщество, ориентированное на предоставление поддержки управления проектами для разработки Ethereum.

Ethereum Hackers — чат Discord, которым управляет ETHGlobal: онлайн-сообщество для хакеров Ethereum со всего мира.

CryptoDevs — сообщество Discord, ориентированное на разработку Ethereum

EthStaker Discord — сообщество, ориентированное на предоставление поддержки управления проектами для разработки Ethereum.

Команда веб-сайта Ethereum.org — зайдите и пообщайтесь в чате веб-разработки и дизайна ethereum.org с командой и людьми из сообщества.

Web3 University — сообщество, ориентированное на изучение разработки Web3

Matos Discord — сообщество создателей web3, где тусуются строители, промышленные лидеры и энтузиасты Ethereum. Мы увлечены разработкой, дизайном и культурой web3. Приходите строить вместе с нами.

Solidity Gitter — чат для разработки солидности (Gitter)

Solidity Matrix — чат для развития солидности (Матрица)

Ethereum Stack Exchange — форум вопросов и ответов

Peeranha — децентрализованный форум вопросов и ответов

Ютуб и Твиттер

Ethereum Foundation — будьте в курсе последних новостей от Ethereum Foundation

@ethereum — Официальный аккаунт Ethereum Foundation

@ethdotorg — портал Ethereum, созданный для нашего растущего глобального сообщества.

Список влиятельных твиттер-аккаунтов Ethereum

Доп. источники:

r/ethdev/ — тема на форуме по разработке Ethereum и DApps
Solidity Forum — на форуме обсуждается много тем связанных с Solidity

Polygon vs Ethereum vs Polkadot: что выбрать для разработки?

alzheimer — Thu, 26 Jan 2023 19:27:14 GMT

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

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

Polygon против Ethereum против Polkadot: чем они отличаются

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

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

Блокчейн Ethereum: обзор

Эфириум внес большой вклад в изменения на рынке, переключив внимание с криптовалют как просто эквивалентной формы денег на то, что они рассматриваются как неотъемлемый компонент dApps. Фактически, эта сеть остается крупнейшей в мире экосистемой dApp и второй по величине PoW (Proof-of-Work) в мире, уступая только Биткойну.

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

Плюсы и минусы сети Ethereum:

Плюсы:

Децентрализованный дизайн
Быстрое развертывание
Частные транзакции
Большое сообщество
Нулевое время простоя
Эфириум 2.0 грядет

Минусы:

Низкая масштабируемость
Сравнительно высокая плата за газ
Механизм Proof-of-Work (в настоящее время)
Проблемы конфиденциальности транзакций

Блокчейн-проекты Ethereum:

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

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

Одними из самых популярных проектов на основе Ethereum сегодня являются Compound (платформа заимствования и кредитования DeFi), NFT (платформа для добычи токенов), The Sandbox (метавселенный эквивалент Minecraft), Opensea (торговая платформа NFT) и так далее.

Идеи проекта для создания на Ethereum: платформы метавселенной, протоколы DeFi и решения DEX, автоматические маркет-мейкеры (AMM), агрегаторы криптобирж, веб-браузеры, торговые площадки NFT и другие.

Блокчейн Polygon: обзор

Сеть Polygon — это блокчейн третьего поколения, который, в отличие от Ethereum, использует модель консенсуса PoS — более эффективную и безвредную для окружающей среды, чем PoW. Еще одна уникальная особенность Polygon заключается в том, что он построен на основе Ethereum и обладает большей масштабируемостью по сравнению со своим предшественником 2-го поколения. Более того, поскольку MATIC является токеном ERC-20, он полностью совместим с другими цифровыми валютами на основе Ethereum.

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

Как это работает?

Сеть Polygon работает на основе блокчейна Ethereum и предназначена для подключения проектов на базе Ethereum. Несмотря на свой стереотип «убийцы Эфириума», изначально он был разработан, чтобы в первую очередь помочь повысить эффективность, безопасность, размер и полезность.

Проще говоря, Polygon применяет различные технологии для создания быстрой параллельной цепочки блоков, связанной с основной цепочкой блоков на основе Ethereum. В целом, структура PoS MATIC позволяет пользователям зарабатывать на нем деньги с помощью ставок на основе двух основных компонентов: валидаторов и делегаторов. Валидаторы используются для проверки новых транзакций и добавления их в блокчейн, в то время как делегаторы косвенно размещают токен Polygon через доверенных валидаторов.

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

Плюсы и минусы сети Polygon:

Плюсы:

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

Минусы:

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

Проекты Polygon:

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

Благодаря своим многочисленным преимуществам это блокчейн-решение может подключать платежные системы, DEX, AMM и другие приложения с меньшими затратами. Одними из самых популярных проектов, использующих экосистему Polygon для своей работы, являются AAVE, Curve, QuickSwap, SportX, Clover Finance и многие другие.

В целом ожидается, что сеть блокчейнов будет иметь огромное преимущество на рынках NFT и DeFi по сравнению с Ethereum.

Типы проектов на основе Polygon, которые следует учитывать : dApps, службы хранения файлов, децентрализованные протоколы, торговые платформы и рынки предсказаний, решения DEX и многое другое.

Блокчейн Polkadot: обзор

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

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

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

Как это работает?

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

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

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

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

Плюсы и минусы сети Polkadot:

Плюсы:

Высокая совместимость и масштабируемость
Технология шардинга
Технология Proof-of-Stake
Более высокие вознаграждения за стекинг
Большая гибкость и отсутствие вилок
Мультичейн архитектура
Смарт-контракты

Минусы:

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

Проекты Polkadot:

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

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

Вот несколько проектов, созданных в среде Polkadot, которые вы, возможно, захотите изучить: Octopus Network (многоцепочечная совместимая криптосеть для запуска и работы цепочек приложений Web3.0), Kusama (масштабируемая сеть специализированных блокчейнов), Acala (универсальная -one DeFi hub), PolkaFoundry (фреймворк для создания бесшовных децентрализованных приложений DeFi и NFT без границ на Polkadot), Robonomics (решение для хранения более 1 миллиона цифровых двойников IoT) и многие другие.

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

Какую сеть выбрать: Polygon, Ethereum или Polkadot?

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

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

Также стоит сказать, что Polkadot на самом деле применяет вариант концепции PoS — Nominated Proof of Stake. Это включает в себя две переменные, валидаторы и номинаторы, которые в значительной степени способствуют честности и высокой безопасности сети.

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

Масштабируемость:

С точки зрения скорости транзакций и масштабируемости Polygon в настоящее время является абсолютным победителем. Он способен обрабатывать до 65 000 транзакций в секунду, что больше, чем у Polkadot (пока что), не говоря уже об Ethereum, который способен выполнять только до 30 транзакций.

Однако сеть Polkadot все еще находится на ранней стадии разработки. Согласно его документации, ожидается, что в ближайшие годы блокчейн достигнет 1 000 000 транзакций в секунду, что будет более чем конкурентоспособным с Polygon.

Децентрализация:

Подобно Ethereum, блокчейны Polygon и Polkadot сами по себе являются децентрализованными платформами. Они позволяют разработчикам создавать масштабируемые и удобные для пользователя приложения dApp с достойным уровнем безопасности. Поскольку Polygon присутствует на рынке некоторое время, он уже доказал свою ценность с точки зрения децентрализации.

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

Несмотря на сильные и слабые стороны всех трех сетей, считается, что они будут сосуществовать и дополнять друг друга в децентрализованном будущем. Разработчики могут использовать преимущества Polygon, Ethereum и Polkadot при создании конкретных децентрализованных проектов, таких как платформы социальных сетей, метавселенная или решения DeFi.

Окончательный вердикт:

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

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

Как Создать Автоматический Аудитор Смарт-Контракта для Web

alzheimer — Thu, 08 Dec 2022 19:48:29 GMT

В наши дни стоимость аудита продвинутого смарт-контракта может составлять от 50 000 до 100 000 долларов, а иногда и больше, к тому же на проведение комплексного аудита часто уходят месяцы. Так почему бы не переложить большую часть этого процесса на автоматизированного программного аудитора? Мы, разработчики, знаем одну вещь: когда речь идет о проверке сложных и очень подробных вещей, таких как код, компьютеры способны выполнять работу гораздо эффективнее. Я не говорю, что нам не нужны человеческие аудиторы безопасности, я просто считаю, что человеческий аудит должен быть последним шагом после комплексного автоматизированного аудита.

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

Давайте приступим. Я создал фронт-энд аудитора на React, но этот учебник будет в основном посвящен бэк-энд, чтобы сделать его коротким и читабельным. Я начну с общего объяснения того, как я создал аудитора, а затем рассмотрю пример того, как я включил логику аудита в код. В настоящее время аудитор может сканировать код, написанный на solidity, а в будущем планируется расширить его на языки смарт-контрактов Move и Vyper. Я предположу, что вы знаете основы react, terminal, node.js и JavaScript.

Front End: Для фронтальной части я использовал React (create-react-app).
Back End: Node.js / java script. Server: Я развернул свой код на Netflify(serverless). Вы также можете взглянуть на мое веб-приложение здесь и исходный код здесь для более подробной информации.

Базовая установка

Перейдите в нужный каталог в командной строке и создайте новый проект react.

terminal: create-react-app auditorTutorial

Удалите все файлы в папке src в только что созданном проекте.

Создайте файл index.js и папку components, а в ней - файл app.js. Вы можете настроить свою папку src по своему усмотрению, но вы также можете посмотреть мою папку здесь.

Установите несколько модулей и библиотек.
BrowserSolc: обертка Solidity, которая может компилировать смарт-контракты в браузере.
Web3: будет использоваться для получения дополнительной информации из блокчейна ethereum, такой как примерная стоимость газа. Я использовал infura в качестве провайдера для подключения к узлу ethereum.

terminal: npm i BrowserSolc, web3, semantic-ui-react

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

пример: state = {value: “ ”, contract: “”}; //обновление состояния контракта на основе пользовательского ввода handleChangesToContract=(event)=>{ this.setState({ contract:event.target.value }); }

render(){{this.handleChangesToContract} />}</code> </li> <li id="aot3">Извлечение кода договора и сохранение в формате массива //пример того, когда запускать аудит, предполагая, что у вас есть кнопка отправки, которая вызывает функцию onSubmit(){ let data = this.state.contract;} Далее я использовал метод javascript '.split("\n")', чтобы разделить код смарт-контракта на массив на основе каждой новой строки. onSubmit(){ let data = this.state.contract; let dataArray = source.split(“\n”)} ; </li> <li id="ELh6">Компилировать код Бэкэнд аудитора состоит из двух различных частей. Во-первых, компилятор solidity запускает код смарт-контракта и предоставляет информацию о любых ошибках и успешной компиляции, во-вторых, набор логики, который проверяет уязвимости безопасности. Убедитесь, что BrowserSolc и web3 определены в вашем файле app.js (или там, где вы компилируете файл смарт-контракта). BrowserSolc может быть включен в качестве скрипта в ваш 'public.index.html путем включения : <script src=”./browser-solc.min.js” type=”text/javascript”></script> Web3 может быть определен как компонент вашего приложения: импортировать Web3 из 'web3'; Далее мы компилируем код нашего смарт-контракта, который сохраняется в состоянии. Мое состояние хранится под именем 'data'. Вам также понадобится учетная запись infura. Чтобы создать учетную запись, нажмите <a href="https://infura.io/" target="_blank">здесь</a>. <code>//Загрузка выбранной версии компилятора window.BrowserSolc.loadVersion(this.state.currentCompiler, async function (compiler){ let optimize = 1; let result = compiler.compile(data, optimize); const provider = new Web3.providers.HttpProvider( ‘<a href="https://rinkeby.infura.io/v3/" target="_blank">https://rinkeby.infura.io/v3/</a>(здесь ваш номер инфуры)' ) const web3 = new Web3(provider); let bytecode = result.contracts[“:SampleContract”].bytecode; }</code> С помощью web3 и байткода, полученного в результате успешной компиляции, можно обращаться к блокчейну ethereum для получения дополнительных данных, таких как расчетная стоимость газа. </li> <li id="wzXo">Выполнить аудит смарт-контракта Создайте отдельный файл вне компонента приложения и назовите его auditor.js . Это файл, который будет содержать всю логику аудита. Мы будем отправлять массив нашего смарт-контракта в этот файл, проводить аудит и затем отправлять его обратно в наш компонент. Вы можете определить свой файл audit.js следующим образом: <code>export default(dataArray)=>{ //определяем одно предупреждение и массив всех обнаруженных предупреждений let warn; let warnings=[]; return warnings; }</code> Исходя из моих исследований, лучшими источниками для поиска логики аудита являются более ранние взломы, такие как взлом <a href="https://www.coindesk.com/understanding-dao-hack-journalists" target="_blank">DAO</a> и <a href="https://blog.zeppelin.solutions/on-the-parity-wallet-multisig-hack-405a8c12e8f7" target="_blank">Parity</a>, а также шаблоны, основанные на "лучших практиках смарт-контрактов Ethereum", например, опубликованное компанией <a href="https://consensys.github.io/smart-contract-best-practices/known_attacks/" target="_blank">consensys руководство</a> по защите смарт-контрактов. В этом руководстве мы будем использовать руководство Consensys в качестве источника логики аудита. Давайте разберем код на предмет <a href="https://consensys.github.io/smart-contract-best-practices/known_attacks/" target="_blank">атаки Reentrancy</a>, которая встречается довольно часто. Отрывок с <a href="https://consensys.github.io/smart-contract-best-practices/known_attacks/" target="_blank">веб-сайта Consensys</a> об атаках на реентерабельность - "Одна из главных опасностей <a href="https://consensys.github.io/smart-contract-best-practices/recommendations#external-calls" target="_blank">вызова внешних контрактов</a> заключается в том, что они могут взять на себя поток управления и внести изменения в ваши данные, которых вызывающая функция не ожидала. Этот класс ошибок может принимать различные формы, и обе основные ошибки, которые привели к краху DAO, были ошибками такого рода". "Реентерабельность на одной функции": Первая замеченная версия этой ошибки касалась функций, которые могли вызываться многократно, до завершения первого вызова функции. Это может привести к тому, что различные вызовы функции будут взаимодействовать разрушительным образом." В принципе, можно очень быстро выполнить несколько вызовов функции контракта до того, как вся логика функции будет завершена. Например, злоумышленник может сделать несколько снятий средств со счета сверх фактического баланса счета, если баланс счета (состояние) не обновляется перед каждым вызовом функции снятия средств. Один из способов предотвратить это - использовать <a href="https://consensys.github.io/smart-contract-best-practices/recommendations#send-vs-call-value" target="_blank">use <code>send()</code> вместо <code>call.value()()</code></a>. Это ограничит выполнение любого внешнего кода. Чтобы перевести это в логику, мы можем просто найти в массиве кода нашего смарт-контракта набор строк “<code><a href="https://consensys.github.io/smart-contract-best-practices/recommendations#send-vs-call-value" target="_blank">call.value()()</a>". //определите строку, которую вы хотите найти let dangerousCalls1 = ‘.call.value()’; //просмотреть смарт-контракт построчно и сохранить все найденные предупреждения в //массив for (let index=0; index<dataArray.length; index++) { if (dataArray[index].includes(dangerousCalls1)) { warn = {key:(index), value:"Помните, что использование '.call.value()', подвержено атакам повторного входа, по возможности используйте send() или transfer(). Также не забудьте установить баланс вашего нового счета перед переводом"}; warnings.push(warn); } } </code>Затем мы можем вернуть результаты в наш компонент и отобразить все предупреждения пользователю. Это очень простой пример поиска уязвимостей в коде, но в принципе любой шаблон можно разбить на строительные блоки и добавить в логику auditor.js. Следует учитывать и другие факторы, например, искомая строка в конкретной строке может быть не вся в одной строке, так в примере выше ".call." и ".value()" могут быть вызваны на разных строках, поэтому более детальная проверка может разделить поиск каждой строки отдельно и проверить следующую "активную" строку, если она содержит определенную строку. Как вы можете заметить, для создания надежного бесплатного открытого публичного аудитора потребуется довольно обширная база данных логики, которая может быть создана за счет вклада сообщества в логику аудита.</li> </ol> </article> </main></body></html>