НОВОЕ: Solana Privacy Rings теперь доступны в мейннете
Как перейти с Ethereum на Solana: руководство для разработчиков
Блог/Исследования

Как перейти с Ethereum на Solana: руководство для разработчиков

Developer Experience Engineer0xIchigo в X0xIchigo в LinkedIn0xIchigo на GitHub
Чтение: 41 мин

О чём эта статья?

Ethereum — одна из важнейших инноваций последнего времени. Впервые в истории появилась децентрализованная глобальная платформа для социальной координации, способная преобразовать множество отраслей. Несмотря на значимость Ethereum, его среда выполнения Ethereum Virtual Machine (EVM) в нынешнем виде не подходит для массовых приложений. Это однопоточная сеть на основе газа с нестабильными комиссиями. Solana, напротив, представляет собой сеть с высокой пропускной способностью и низкой задержкой. Она предлагает параллельную инфраструктуру с низкими и предсказуемыми комиссиями. Solana напрямую устраняет ограничения EVM и совершенствует её исходную архитектуру. Это делает её привлекательным выбором для разработчиков масштабируемых и эффективных приложений.

Эта статья — подробное руководство по миграции для EVM-разработчиков, которые хотят создавать приложения на Solana. В ней рассматриваются фундаментальные различия между платформами: механизмы консенсуса Ethereum и Solana, способы обработки транзакций и языки разработки смарт-контрактов. Затем описывается модель аккаунтов Solana, предлагающая более единообразный и многофункциональный подход к аккаунтам. Также рассматриваются Solang и Neon EVM — два инструмента с поддержкой Solidity, которые упрощают разработку на Solana.

Фундаментальные различия

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

Механизмы консенсуса

Механизмы консенсуса лежат в основе каждой блокчейн-сети. Они определяют, как проверяются транзакции и как блоки безопасно, эффективно и децентрализованно добавляются в блокчейн. Ethereum и Solana относятся к сетям на основе доказательства доли владения (PoS). Хотя обе сети используют PoS, их подходы к достижению консенсуса различаются из-за разных правил подтверждения.

Ethereum использует Gasper — сочетание Casper the Friendly Finality Gadget (Casper-FFG) и алгоритма выбора форка LMD-GHOST. Вместе они образуют механизм консенсуса, который обеспечивает безопасность Ethereum.

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

LMD-GHOST — сокращение от «Latest Message-Driven Greedy Heaviest Observed Sub-Tree». Этот алгоритм определяет, какому форку Ethereum следовать. Для этого он выбирает форк, получивший наибольшую поддержку, то есть «вес», от валидаторов сети — отсюда и «жадное самое тяжёлое поддерево». Затем алгоритм учитывает только последнее сообщение каждого валидатора. При каждом предложении нового блока в Ethereum валидаторы используют это правило, чтобы решить, должен ли блок стать частью канонической цепочки.

Для сравнения, Solana использует хеши доказательства истории (PoH) для достижения консенсуса. Несмотря на неоднозначное название, PoH — не алгоритм консенсуса. Это способ доказать ход времени во враждебной сети. Точнее, это криптографическая функция временных меток, которая позволяет нодам согласовать порядок событий без обмена данными друг с другом. Лидер, то есть валидатор, добавляющий записи в реестр, присваивает блокам временные метки, чтобы подтвердить, что с момента предыдущего блока прошло некоторое время. 

Добавление временных меток формирует историческую запись, поскольку они доказывают, что данные существовали в определённый момент времени. Историческая запись создаётся с помощью последовательной устойчивой к нахождению прообраза хеш-функции, в которой каждый хеш зависит от предыдущего. Функции проверяемой задержки (VDF) играют ключевую роль в формировании этих хешей. Они гарантируют, что каждый хеш основывается на предыдущем и учитывает прошедшее с тех пор время. Интеграция VDF добавляет временное измерение в процесс хеширования и позволяет создать в Solana проверяемую последовательность событий с временными метками.

Разобравшись, как механизм доказательства истории Solana создаёт надёжную последовательность событий с помощью криптографических временных меток, важно понять его интеграцию с механизмом консенсуса Solana — Tower BFT. Tower Byzantine Fault Tolerance (BFT) — это оптимизированная для PoH версия традиционной модели консенсуса с византийской отказоустойчивостью в Solana. Tower BFT использует созданную PoH историческую запись как систему координат. Она позволяет валидаторам эффективно и точно голосовать за состояние реестра. В Tower BFT валидаторы отдают голоса, которые блокируются на длительное время, а с добавлением новых голосов обязательства усиливаются. Благодаря PoH валидаторы могут быстрее принимать обоснованные решения о состоянии реестра без необходимости обмениваться данными друг с другом. Сочетание PoH и Tower BFT ускоряет достижение консенсуса и повышает безопасность и надёжность сети. В результате формируется масштабируемая блокчейн-среда с высокой пропускной способностью и быстрым подтверждением транзакций.

Обработка транзакций и среды выполнения

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

Среда выполнения Ethereum работает как детерминированная однопоточная стековая машина, известная как Ethereum Virtual Machine (EVM). Она ведёт себя как математическая функция. Иными словами, при заданных входных данных EVM выдаёт детерминированный результат. Ethereum удобно представить как функцию перехода состояния: f(S, T) = S’. Получив старое состояние (S) и новый набор допустимых транзакций (T), EVM формирует новое допустимое выходное состояние (S’). Для одного и того же набора транзакций EVM всегда достигает одинакового конечного состояния. Это критически важно для согласованности между нодами сети.

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

Ethereum упрощает среду выполнения смарт-контрактов за счёт однопоточной модели. Разработчики получают предсказуемые изменения состояния, поскольку каждая транзакция обрабатывается последовательно. Благодаря этому среда разработки Ethereum, вероятно, более понятна новичкам: они могут сосредоточиться на логике смарт-контрактов, а не на сложностях выполнения. Однако такая простота затрудняет масштабирование. Последовательная обработка ограничивает пропускную способность сети. Это может приводить к перегрузке, увеличению времени ожидания транзакций и росту комиссий за газ при высоком спросе. Поскольку каждая транзакция расходует газ, разработчикам приходится оптимизировать его использование. Такая оптимизация улучшает пользовательский опыт и помогает бороться с последствиями перегрузки, когда неэффективный код может сделать приложения непригодными для обычных пользователей.

Разработчикам Solana не нужно оптимизировать расход газа, как разработчикам Ethereum. Solana спроектирована как машина состояния с высокой пропускной способностью и низкой задержкой, известная как Solana Virtual Machine (SVM). Важный компонент SVM — Sealevel. Это движок среды выполнения, который обрабатывает транзакции параллельно. В Solana каждая транзакция сообщает среде выполнения, какие части состояния она будет читать или изменять. Среда параллельно обрабатывает неконфликтующие транзакции и транзакции, читающие одно и то же состояние. Sealevel оптимизирует выполнение смарт-контрактов, распределяя нагрузку транзакций между несколькими потоками оборудования валидатора. Поэтому пока валидатор обрабатывает одну транзакцию на одном ядре, другая может одновременно обрабатываться на другом.

Встроенный параллелизм Solana значительно снижает стоимость транзакций. У транзакций Solana две комиссии: базовая и приоритетная. Базовая комиссия фиксирована и составляет 5000 лампортов за подпись; у большинства транзакций только одна подпись. Приоритетная комиссия необязательна и позволяет повысить приоритет транзакции относительно других. Планировщик недетерминированно отдаёт предпочтение транзакциям с более высокой приоритетной комиссией. Комиссии за транзакции часто ниже $0.001 USD, а средняя комиссия за транзакции, не связанные с голосованием, находится в диапазоне от 0.000005 до 0.00007 SOL. Верхняя граница выше обычного из-за недавнего роста использования приоритетных комиссий. При текущей цене SOL около ~$98.96 эта комиссия составляет примерно от $0.000494 до $0.006968 USD. 

Эти комиссии также предсказуемы. Для управления спросом Solana использует локальные рынки комиссий. Пространство блоков организовано так, чтобы ни одна отдельная точка повышенной активности, например популярный минт NFT, не могла занять всё пространство и повысить комиссии во всей сети. Комиссии растут только для транзакций, пытающихся обратиться к конкретной области с высоким спросом. Локальные рынки комиссий позволяют использовать приоритетные комиссии без полномасштабных газовых войн. В этом локализация отличается от сетей на основе газа, таких как Ethereum, где транзакции обрабатываются последовательно, а глобальная перегрузка приводит к нестабильным комиссиям.

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

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

Основной язык разработки смарт-контрактов в Ethereum — Solidity. Это статически типизированный язык с фигурными скобками, предназначенный для создания смарт-контрактов, выполняемых в EVM. На него сильно повлияли JavaScript, C++ и Python, поэтому разработчикам, знакомым с этими языками, легко его освоить.

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

Vyper — популярный Python-подобный язык, ориентированный на простоту и безопасность. В нём намеренно меньше возможностей, чем в Solidity, поскольку его цель — снизить сложность и количество потенциальных уязвимостей. Философия Vyper ставит удобочитаемость и возможность аудита превыше всего. Этот подход вдохновил на создание похожих языков, например Fe, и языков, компилируемых в Vyper, таких как Dasy.

Rust — лингва франка разработки смарт-контрактов, которые в Solana обычно называют программами. Это быстрый и эффективно использующий память язык с производительностью, сопоставимой с C++. Благодаря этим характеристикам он подходит для разработки приложений в сети с высокой пропускной способностью и низкой задержкой. Развитая система типов и модель владения Rust обеспечивают безопасность памяти и потоков, заставляя разработчиков создавать надёжные и защищённые приложения. 

Хотя новичкам в системном программировании освоить Rust непросто, взамен они получают возможность создавать надёжный и эффективный код. Большая часть разработки на Rust ведётся с помощью Anchor. Anchor — структурированный фреймворк, который упрощает разработку программ: сокращает шаблонный код, выполняет различные стандартные проверки безопасности и оптимизирует процесс сериализации и десериализации. Поэтому для начала работы глубокие знания Rust не так важны. Для ориентира: документация Anchor рекомендует ознакомиться с первыми девятью главами Rust Book, то есть знать основы Rust. В Solana Playground доступно несколько руководств по Anchor, которые помогут начать работу.

Хотя предпочтительным языком является Rust, разработчики не ограничены им. Можно использовать C, C++ и любой язык, ориентированный на BPF-бэкенд LLVM, то есть любой язык, который можно скомпилировать в байт-код BPF. Разработчикам, знакомым с Python-подобными языками, такими как Vyper, Seahorse Lang позволяет писать программы на Python. Так они получают простоту Python и сохраняют те же гарантии безопасности, что и при разработке на Rust. Несколько полезных руководств по Seahorse, включая Seahorse University и Seahorse Cookbook, помогут вам начать программировать на Solana уже сегодня.

Разработчики, переходящие с Ethereum, не ограничены Rust. Из-за популярности и гарантий безопасности рекомендуется изучать и использовать такие фреймворки, как Anchor и Seahorse, но это не всегда возможно. Благодаря недавним разработкам Solang и Neon Labs, включая их компилятор и EVM-совместимую среду разработки, при создании программ можно использовать Solidity. У Solidity есть своё место в Solana. Чтобы начать разрабатывать программы на Solidity, необходимо глубже изучить особенности модели программирования Solana. Понимание модели аккаунтов Solana критически важно для разработчиков, совершающих такой переход, поскольку она служит основой для разработки программ и взаимодействия с сетью.

Модель аккаунтов

Ethereum делит аккаунты на две основные категории: аккаунты с внешним владельцем (EOA) и контрактные аккаунты. EOA — стандартный тип аккаунта для пользователей. Они управляются закрытыми ключами, могут хранить баланс Ether, отправлять транзакции и взаимодействовать с контрактными аккаунтами. Операции контрактных аккаунтов, в свою очередь, регулируются встроенным в них кодом смарт-контракта. Они не могут самостоятельно инициировать транзакции и действуют только в ответ на транзакции, полученные от EOA или других контрактных аккаунтов.

Solana использует более единообразную модель аккаунтов и рассматривает их как многофункциональные контейнеры для постоянного хранения данных. В этой модели любой аккаунт может быть программой, что размывает традиционную границу между аккаунтом и смарт-контрактом. В отличие от Ethereum, где код и состояние объединены в одном аккаунте, программы Solana не имеют собственного состояния. Это означает, что они не хранят состояние внутри себя. Вместо этого все необходимые им данные хранятся в отдельном аккаунте и передаются транзакцией по ссылке. Передача аккаунтов по ссылке позволяет развернуть одну универсальную программу, способную взаимодействовать с разными аккаунтами. Модель аккаунтов Solana разделяет код и данные, создавая более эффективную и модульную среду разработки. Это удобно для пользователей, которые хотят взаимодействовать с несколькими протоколами, не перемещая активы между разными программами. В Solana всё является аккаунтом. 

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

Исполняемые аккаунты содержат программы. Программы могут владеть дополнительными аккаунтами, читать данные других аккаунтов или пополнять их, изменять данные или списывать средства с принадлежащих им аккаунтов. Исполняемые аккаунты можно дополнительно разделить на ончейн-программы и нативные программы. Ончейн-программы — это написанный пользователями код, развёрнутый в сети. Их может обновлять центр управления обновлениями — обычно аккаунт, который их развернул. Нативные программы — особая разновидность исполняемых аккаунтов, аналогичная предварительно скомпилированным контрактам Ethereum, но с более широкой функциональностью. Эти программы интегрированы в ядро Solana и предоставляют функциональность, необходимую для работы валидаторов. Пример нативной программы — System Program. Она отвечает за создание новых аккаунтов, выделение памяти под данные аккаунтов, назначение аккаунтов программам, перевод лампортов из принадлежащих ей аккаунтов и оплату комиссий за транзакции. Полный список нативных программ доступен здесь.

Независимо от того, являются ли аккаунты исполняемыми, у всех них одинаковые поля: 

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

Арендная плата — это стоимость хранения, необходимая для поддержания аккаунтов в Solana и их нахождения в памяти валидаторов. Для сохранения активности аккаунты должны поддерживать минимальный баланс. Арендная плата сокращает разрастание состояния, позволяя сети со временем высвобождать неиспользуемые или недостаточно финансируемые аккаунты. После недавних обновлений в основной сети больше нет аккаунтов, которые платят аренду. Вместо этого все аккаунты при создании должны быть освобождены от арендной платы. Аккаунт освобождается от неё, если поддерживает минимальный баланс, эквивалентный арендной плате за два года. Для оценки количества SOL, необходимого для освобождения аккаунта от арендной платы, можно использовать Helius API Playground и подкоманду rent в Solana CLI. Это отличается от системы распределения ресурсов Ethereum, где данные сохраняются, пока их явно не удалят. Подход Solana обеспечивает более предсказуемую структуру стоимости хранения состояния и одновременно сокращает его разрастание.

Адреса и программно-производные адреса (PDA)

Каждый аккаунт идентифицируется своим адресом — уникальным 32-байтовым открытым ключом. Это отличается от модели данных Ethereum, где адреса имеют размер 20 байт. Для создания адресов Solana использует ed25519, то есть схему подписи EdDSA на основе SHA-512 и эллиптической кривой Curve22519. Чтобы аккаунт имел действительную пару ключей, он должен быть точкой на кривой ed25519. 

Программно-производные адреса (PDA) — это аккаунты, создаваемые вне кривой с помощью bump, то есть значения, которое смещает результат за пределы кривой. Для PDA нужны три основных компонента: адрес родительской программы, набор начальных значений и bump. Начальные значения представляют собой массив строк с произвольными значениями. Однако большинство разработчиков создают конкретные начальные значения, связанные с переменными состояния родительской программы, чтобы формировать структуры данных, подобные хеш-таблицам. Таким образом, PDA создаётся путём хеширования ID программы, начальных значений и bump с помощью хеш-функции SHA-512.

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

Взаимодействие с аккаунтом

Транзакция Ethereum — это изменяющее состояние действие, инициированное EOA. Смарт-контракты не могут самостоятельно инициировать транзакции, а могут только реагировать на них. Эти реакции определяются кодом контракта, а стоимость выполнения транзакции измеряется в газе. Пользователи должны предоставить достаточно Ether для оплаты этой комиссии.

Транзакции Ethereum обычно выполняют одну операцию, например вызывают определённую функцию смарт-контракта. Хотя одна транзакция может привести к нескольким изменениям состояния внутри контракта, все они ограничены рамками одного вызова контракта.

В Solana транзакция включает массив аккаунтов для чтения или записи, одну или несколько подписей и одну или несколько инструкций. Инструкция — это директива для одного вызова программы. Она представляет собой минимальную единицу логики выполнения и является основной операционной единицей. Инструкции указывают исполняемую программу, все задействованные аккаунты и операционные данные. Программы интерпретируют данные инструкции и выполняют операции с указанными аккаунтами. Такая структура позволяет одной транзакции атомарно выполнять последовательность действий в нескольких программах. Это означает, что все инструкции либо выполняются успешно, либо завершаются ошибкой вместе. Поток транзакций Solana отличается от модели Ethereum, где транзакция обычно связана с одним смарт-контрактом или действием EOA.

Межпрограммные вызовы (CPI) позволяют одной программе вызывать другую в рамках той же транзакции. Количество байтов данных аккаунта на единицу вычислений, взимаемых во время CPI, составляет 250. При 200 000 единиц это примерно 50 МБ. CPI позволяют использовать программно созданные подписи при вызовах между программами. Это похоже на эффективный и атомарный вызов одним смарт-контрактом Ethereum другого контракта. Однако вызывающая программа приостанавливается, пока вызванная программа не завершит обработку инструкции. Повторный вход ограничен прямой саморекурсией с фиксированной максимальной глубиной 4. Это предотвращает ситуации, когда программа вызывает другую из промежуточного состояния, не зная, что позднее управление может вернуться к ней.

Для повышения эффективности размер транзакций Solana ограничен, как и расход газа в Ethereum. Однако основное внимание уделяется объёму данных. Для гарантии надёжной передачи данных транзакции Solana соответствуют стандартам максимального размера передаваемого блока IPv6 (MTU). После резервирования необходимого пространства под заголовки для данных пакета остаётся 1232 байта. Чтобы преодолеть ограничения размера и поддерживать несколько форматов транзакций, Solana представила версионированные транзакции. Помимо устаревшего формата, то есть исходного формата транзакций, была выпущена Version 0 с поддержкой таблиц поиска адресов (ALT). ALT хранят адреса в табличной структуре данных ончейн, где каждый адрес индексируется однобайтовым индексом u8. Это значительно сокращает размер транзакций, поскольку для каждого аккаунта требуется только 1 байт вместо 32 байт.

Solang

Solang — компилятор Solidity для Solana и Polkadot. Его цель — обеспечить совместимость исходных файлов с версией 0.8 компилятора Solidity для EVM с некоторыми изменениями, учитывающими архитектуру Solana и Polkadot. Важная особенность Solang — использование LLVM, мощной инфраструктуры для компиляторов. Благодаря гибкости LLVM в будущем Solang сможет поддерживать другие языки программирования, упрощая их реализацию и компиляцию. Это соответствует цели Solang: облегчить разработчикам переход на Solana или Polkadot и расширить возможности разработки на Solidity. Solang непрерывно развивается с упором на повышение совместимости, эффективности и удобства использования. Разработчикам Ethereum, которые хотят применить свои навыки в разных блокчейнах, важно понимать особенности и ограничения Solang.

Установка

Установить Solang можно несколькими способами. На Mac пользователи могут загрузить Solang через Brew с помощью частного tap-репозитория:

Код
brew install hyperledger/solang/solang

Другой способ установить Solang — использовать контейнеры Solang. Этот вариант отлично подходит тем, кто предпочитает Docker, поскольку новые образы автоматически публикуются в этих контейнерах. Доступны теги v.0.3.3 и latest:

Код
docker pull ghcr.io/hyperledger/solang:latest

Один из самых простых способов установить и использовать Solang — через Ancor. Сначала убедитесь, что в вашей системе установлены Rust и Node.js. Пользователям Windows также потребуется настроить подсистему Windows для Linux. Теперь нужно установить набор инструментов Solana. На Mac и Linux это можно сделать следующей командой:

Код
 sh -c "$(curl -sSfL https://release.solana.com/v1.17.13/install)"

Если вам нужна другая версия ПО, замените «v1.17.13» соответствующим тегом релиза. Также можно использовать одно из следующих символьных названий каналов: stable, beta или edge. В зависимости от системы может потребоваться обновить переменную среды PATH. Если вы увидите соответствующее сообщение, скопируйте и выполните рекомендованную ниже команду, чтобы обновить PATH. Проверить нужную версию solana можно командой solana --version.

В Windows откройте командную строку от имени администратора. Скопируйте и выполните следующую команду, чтобы загрузить установщик Solana во временный каталог:

Код
cmd /c "curl https://release.solana.com/v1.17.13/solana-install-init-x86_64-pc-windows-msvc.exe --output C:\solana-install-tmp\solana-install-init.exe --create-dirs"

Затем скопируйте и выполните следующую команду, чтобы установить последнюю версию Solana: C:\solana-install-tmp\solana-install-init.exe v1.17.13. После завершения установки нажмите Enter.

Закройте окно командной строки и откройте новое от имени обычного пользователя. Убедитесь, что нужная версия solana установлена, выполнив solana –-version.

Затем установите Anchor.

Рекомендуется устанавливать Anchor с помощью менеджера версий Anchor (avm). Это можно сделать через cargo следующей командой:

Код
cargo install -git https://github.com/coral-xyz/anchor avm --locked --force.

Затем установите и используйте последнюю версию:

Код
avm install latest
avm use latest

# Verify the installation
avm –version

Anchor версии 0.28 позволяет разработчикам выполнять сборку непосредственно с Solang. Создать новый проект Solang можно командой anchor init project_name —solidity. Она создаст новую программу Solang и тестовый файл, демонстрирующий взаимодействие с программой через клиент.

Если вы используете Visual Studio Code, установите расширение Solang для подсветки синтаксиса. Отключите все другие активные расширения Solidity, чтобы расширение Solang работало корректно.

Создание нового проекта

Создайте новый проект командой anchor-init project_name –solidity. Она создаст новый каталог с именем вашего проекта. Флаг Solidity сообщает Anchor, что мы хотим использовать Solang. В каталоге проекта ./solidity будет находиться стартовая программа. Контракт будет выглядеть так:

Код
@program_id("F1ipperKF9EfD821ZbbYjS319LXYiBmjhzkkf5a26rC")
contract test {
    bool private value = true;

    @payer(payer)
    constructor() {
        print("Hello, World!");
    }

    /// A message that can be called on instantiated contracts.
    /// This one flips the value of the stored `bool` from `true`
    /// to `false` and vice versa.
    function flip() public {
            value = !value;
    }

    /// Simply returns the current value of our `bool`.
    function get() public view returns (bool) {
            return value;
    }
}

В этой программе есть constructor для создания программы, инициализации переменной состояния value значением true и записи «Hello, World!» в логи программы. При вызове функция flip обновляет переменную состояния. Функция get возвращает текущее значение переменной состояния. Это похоже на обычный смарт-контракт Solidity, но есть несколько особенностей. Наиболее существенное отличие — использование аннотаций.

Аннотации

Аннотации используются для управления аккаунтами. Обратите внимание на аннотацию @program_id(“...”). Она указывает ончейн-адрес программы, если он известен заранее. Чтобы вызвать контракт через внешний вызов, программа должна либо содержать обозначение @program_id, либо вызываться с аргументом {program_id: … }:

Код
@program_id(“...”);

contract Foo {
	function hello() public pure {
		print(“Hello”);
	}
}

contract Foo2 {
	function bye() public pure {
		print(“Bye”);
	}
}

contract Bar {
	function new_foo() external {
		Foo.new();
	}
}

contract Bar2 {
	function new_foo(address new_foo_id) external {
		Foo2.new{program_id: new_foo_id}();
	}
}

Когда мы создавали новый проект, в предоставленном примере контракта над конструктором была аннотация @payer. Она определяет аккаунт, который оплатит инициализацию аккаунта данных программы. Синтаксис @payer(payer) объявляет аккаунт с именем payer, который потребуется при каждом вызове конструктора.

При создании экземпляра контракта требуется аккаунт программы для хранения исполняемого кода и аккаунт данных для хранения переменных состояния. Аккаунт данных можно создать в клиентском коде, а затем передать в транзакцию, вызывающую конструктор. Также аккаунт данных может создать конструктор. Как минимум необходимо указать аннотацию @payer. Если аккаунт данных будет PDA, необходимо указать seed и bump. Аннотация @seed задает seed для получения PDA. Это может быть строковый литерал или шестнадцатеричная строка в формате hex”1234”. Если аннотация seed находится перед аргументом, она должна ссылаться на аргумент типа bytes, address или на байтовый массив фиксированной длины. Аннотация @bump задает значение для получения адреса вне кривой. Это должен быть один байт типа bytes1. Необязательная аннотация @space позволяет указать размер аккаунта данных. Это выражение uint64, которое может быть константой или использовать один из аргументов конструктора. Согласно документации Solang, значение @space должно быть как минимум равно размеру, указанному при выполнении команды solang -v:

Код
$ solang compile --target solana -v examples/solana/flipper.sol
...
info: contract flipper uses at least 17 bytes account data
…

Если у программы нет конструктора, эти аннотации можно использовать с пустым конструктором. В документации Solang приведен следующий пример:

Код
@program_id("Foo5mMfYo5RhRcWa4NZ2bwFn4Kdhe8rNK5jchxsKrivA")
contract Foo {

    @space(500 + 12)
    @seed("Foo")
    @payer(payer)
    constructor(@seed bytes seed_val, @bump bytes1 bump_val) {
        // ...
    }
}

Аннотации функций используются для объявления аккаунтов, необходимых внешним функциям:

  • @account(foo) объявляет аккаунт foo доступным только для чтения
  • @mutableAccount(bar) объявляет аккаунт bar изменяемым
  • @signer(fizz) объявляет аккаунт fizz подписантом, доступным только для чтения
  • @mutableSigner(buzz) объявляет аккаунт buzz изменяемым подписантом

Аккаунты, объявленные в конструкторе с аннотацией @payer, доступны внутри него. Аккаунты, объявленные аннотациями функций, доступны в векторе tx.accounts. Например, для доступа к аккаунту, объявленному как @account(ichigo), используется tx.accounts.ichigo. Это вернет встроенную структуру AccountInfo. Ее структура соответствует описанной в разделе «Понимание модели аккаунтов». Названия немного отличаются:

  • key: адрес или публичный ключ аккаунта. Имеет тип address
  • lamports: баланс аккаунта в лампортах. Имеет тип uint64
  • data: данные аккаунта. Имеют тип bytes
  • owner: владелец аккаунта. Имеет тип address
  • rent_epoch: следующая эпоха, когда потребуется уплата ренты за аккаунт. Имеет тип uint64
  • is_signer: указывает, подписал ли аккаунт транзакцию. Имеет тип bool
  • is_writable: указывает, доступен ли аккаунт для записи в этой транзакции. Имеет тип bool
  • executable: указывает, является ли аккаунт программой. Имеет тип bool

Ограничения

Основные различия между Solang и традиционной разработкой для Ethereum:

  • msg.sender недоступен в Solana. В модели аккаунтов контракт Rust может обращаться к разным аккаунтам данных. Какой из них считать вызывающей стороной? Во многих случаях невозможно определить единственный аккаунт в качестве вызывающего. Кроме того, среда выполнения не имеет механизма для получения аккаунтов вызывающей стороны
  • Функции ecrecover() нет, но существует функция signatureVerify() для проверки подписей ed25519.
  • Конструкции try-catch не работают. Если внешний вызов или создание контракта завершится ошибкой, среда выполнения остановит исполнение и откатит всю транзакцию.
  • Определения ошибок и откаты с сообщениями об ошибках пока не работают
  • Передача нативной стоимости при вызове функции не работает.
  • Многие встроенные функции Yul недоступны. Solang поддерживает большинство встроенных функций, однако операции с памятью и блокчейном не реализованы.
  • Формат ERC-20 пока не поддерживается. SPL-токены определяются в соответствии с Token Program. Token Program — нативный для Solana способ создавать, выпускать, передавать и сжигать токены. Файл spl_token.sol следует скопировать в дерево исходного кода и импортировать там, где требуется библиотека SplToken

Кроме того, регистры SVM имеют разрядность 64 бита, поэтому 64-битные целые числа, например uint64 и int64, предпочтительнее 256-битных. Операция с типами шире 64 бит, такими как uint256 или int256, разбивается на несколько операций. Из-за этого она выполняется медленнее и расходует больше вычислительных единиц.

Адресный литерал необходимо указывать с помощью синтаксиса address"36VtvSbE6jVGGQytYWSaDPG7uZphaxEjpJHUUpuUbq4D". Шестнадцатеричный синтаксис Ethereum, например 0xE0f5206BBD039e7b0592d8918820024e2a7437b9, не поддерживается. Все балансы и значения в Solana имеют разрядность 64 бита. Поэтому встроенные функции для адресов, то есть .balance(), .transfer() и .send(), используют 64-битные целые числа.

Solang открывает разработчикам EVM перспективный путь в экосистему Solana, но имеет ряд ограничений, которые нужно тщательно учитывать. Переход к модели аккаунтов Solana — не просто синтаксическое изменение. Он требует фундаментально изменить логику смарт-контрактов. Некоторые функции, шаблоны кода и специфические возможности EVM недоступны в Solang. Нельзя просто перенести смарт-контракт Ethereum в Solang и ожидать, что он заработает без существенных изменений. Отсутствие некоторых возможностей, например полноценных определений ошибок и откатов с сообщениями, может стать серьезной проблемой. Однако важно понимать, что Solang постоянно развивается, а каждое обновление улучшает опыт разработки на Solidity для Solana. Solang также предлагает несколько заметных преимуществ.

Преимущества

Несмотря на эти ограничения, ряд встроенных функций и архитектурных решений улучшает опыт разработчиков. Например, контракты на Solang могут взаимодействовать с программами Anchor. Для этого можно сгенерировать интерфейс Solidity из IDL программы Anchor. IDL означает «язык описания интерфейса». По сути, это JSON-файл со всеми спецификациями программы. В нем есть все необходимое для взаимодействия с программой Anchor. При разработке программы на своем фреймворке Anchor автоматически генерирует IDL. Это очень похоже на ABI в Ethereum. Чтобы сгенерировать интерфейс Solidity из IDL, используйте команду solang idl [-output directory] [IDL file]. После этого файл можно импортировать с помощью синтаксиса import “...”;.

Solang предоставляет библиотеку Solana — набор библиотек, с помощью которых контракты Solidity могут взаимодействовать со специфическими инструкциями Solana. Для выпуска, сжигания и передачи токенов Solang предоставляет библиотеку SPL Token. Ее можно считать аналогом ERC-20 и ERC-721. Solang также предоставляет библиотеку системных инструкций, чтобы разработчики могли взаимодействовать с System Program в Solana.

Solang также включает встроенные возможности, которые можно импортировать через solana. Среди них структуры AccountMeta и AccountInfo. Структура AccountMeta определяет, какие аккаунты следует передать вызываемой стороне при внешнем вызове, то есть CPI. Структура AccountMeta имеет следующий вид:

  • pubkey: адрес или публичный ключ аккаунта. Имеет тип address
  • is_writable: указывает, может ли вызываемая сторона записывать данные в этот аккаунт. Имеет тип bool
  • is_signer: указывает, может ли вызываемая сторона считать, что этот аккаунт подписал транзакцию. Имеет тип bool

Если при внешнем вызове опустить аргумент accounts, компилятор Solang автоматически сгенерирует массив AccountMeta. Это работает только для функций, объявленных как external. В противном случае массив AccountMeta нужно создать вручную с учетом порядка аккаунтов, указанного в IDL. Если вызову не нужны аккаунты, передайте пустой вектор: {accounts: []}. В документации Solang приведен наглядный пример построения массива AccountMetas:

Код
function build_this() external {
	// When calling a constructor from an external function, the data account for the contract
	// 'BeingBuilt' should be passed as the 'BeingBuilt_dataAccount' in the client code.
	BeingBuilt.new("my_seed");
}

function build_that(address data_account, address payer_account) public {
	AccountMeta[3] metas = [
		AccountMeta({
			pubkey: data_account,
      is_signer: true,
      is_writable: true
		}),
    AccountMeta({
    	pubkey: payer_account,
      is_signer: true,
      is_writable: true
    }),
    AccountMeta({
      pubkey: address"11111111111111111111111111111111",
      is_writable: false,
      is_signer: false
    })
  ];
  BeingBuilt.new{accounts: metas}("my_seed");

	// No accounts are needed in this call, so we pass an empty vector.
	BeingBuilt.say_this{accounts: []}("It's summertime!");
}

Solang также содержит встроенные функции для следующих задач:

Solang связывает Solana и Ethereum, предоставляя компилятор с богатым набором инструментов, который упрощает переход для разработчиков EVM. Несмотря на ограничения, Solang предлагает ряд возможностей для улучшения опыта разработчиков: взаимодействие с программами Anchor, доступ к специализированным библиотекам Solana и встроенные функции. Знакомые концепции, такие как IDL и стандарты токенов, дополнительно упрощают обучение. Возможность не беспокоиться о газе и не оптимизировать его расход также полезна. Solang — важный шаг к совместимости между Solana и Ethereum. Для разработчиков EVM, которые хотят выйти в высокопроизводительный мир Solana, Solang может стать подходящим инструментом.

Neon EVM

Solang — не единственный вариант для разработчиков Solidity, которые хотят создавать приложения на Solana. Neon EVM позиционирует себя как первая в мире распараллеливаемая EVM. Это полностью совместимая с Ethereum среда на Solana. Она предлагает взаимовыгодное и удобное для разработчиков решение для масштабирования dApps Ethereum на Solana. Разработчики могут развертывать свои dApps без перенастройки смарт-контрактов, используя любимые языки и инструменты.

Архитектура

Neon EVM состоит из трех основных компонентов: программы Neon EVM, Neon Proxy и Neon DAO.

Neon EVM — это программа Solana, которая принимает Ethereum-подобные транзакции и обрабатывает их в Solana по правилам EVM. Ethereum-подобные транзакции, направленные в Neon EVM, называются Neon Transactions. Они представляют собой подмножество методов JSON RPC, соответствующих Ethereum JSON-RPC API.

Neon Proxy позволяет разработчикам Ethereum переносить dApps в Neon с минимальными изменениями. Он упаковывает транзакции EVM в транзакции Solana и служит контейнерным решением для Neon Operators. Эти операторы запускают серверы Neon Proxy, принимают платежи в NEON и проводят платежи в экосистеме Solana в SOL. NEON — одновременно служебный токен и токен управления: Neon Operators получают его для оплаты комиссий за газ, необходимых для выполнения транзакций, а владельцы могут участвовать в Neon DAO.

Neon DAO — управляемая сообществом модель управления, которая позволяет держателям токенов NEON участвовать в принятии решений по Neon EVM. В нее входят пользователи, операторы, контрибьюторы, разработчики ядра и приложений. Вместе они обсуждают правила управления и развитие протокола. DAO работает через несколько децентрализованных собраний, отвечающих за экосистему, разработку и безопасность. Каждое собрание обеспечивает совместное принятие решений и оценку предложений в своей области. Собрание по экосистеме контролирует ее устойчивый рост и управляет средствами для грантов и инициатив. Собрание по разработке отвечает за технические обновления программы Neon и экстренные вмешательства. Собрание по безопасности защищает казначейство Neon и программу Neon от потенциальных угроз.

Совместимость с EVM

Neon EVM обеспечивает взаимодействие с EVM в Solana следующими способами:

  • Реализует большинство методов Ethereum JSON-RPC API
  • Использует специальный прокси-сервер для обработки вызовов Ethereum
  • Учитывает различия и ограничения архитектуры Solana

Взаимодействие с Neon EVM похоже на работу с любой другой EVM. Разработчики могут использовать знакомые методы RPC API, направляя их в Neon Proxy. Это обеспечивает удобный и целостный процесс разработки. Ключевые возможности:

  • Совместимость со смарт-контрактами на Solidity и Vyper, а также со стандартными инструментами разработки Ethereum: Metamask, Foundry и Remix
  • Поддержка большинства опкодов Ethereum без изменений
  • Прием запросов транзакций Ethereum типа 0 / legacy. Транзакции EIP-1559 пока не поддерживаются

Разумеется, для корректной работы Neon EVM в Solana необходимы определенные адаптации. Основные различия:

  • Neon EVM поддерживает все предварительно скомпилированные контракты, определенные на evm.code. Однако контракты Solidity со следующими вызовами выполняться не будут: bigModExp, bn256Add, bn256ScalarMult и bn256Pairing. Чтобы в будущем поддерживать такие контракты, в Neon EVM необходимо реализовать системные вызовы Solana
  • Хотя большинство опкодов поддерживаются без изменений, опкоды COINBASE, PREVRANDAO (FKA DIFFICULTY), GASLIMIT, BASEFEE и GAS не поддерживаются. Они называются вариантными опкодами и адаптированы для использования в Neon EVM.
  • Расход газа и расчет комиссий отличаются от Ethereum. Обычно затраты ниже, поскольку Solana выступает уровнем расчетов
  • Методы Solidity transfer() и send() в Neon EVM не защищены от повторного входа из-за другого расчета газа
  • Модель аккаунтов Solana влияет на хранилище смарт-контрактов: исполняемые и неисполняемые аккаунты имеют разные функции хранения и права доступа
  • Neon EVM использует версионированные транзакции, поэтому одна транзакция может использовать не более 64 аккаунтов
  • Neon EVM использует Berkeley Packet Filter (BPF) из Solana с лимитом heap-памяти 256 КБ. Это ограничивает размер вызовов контрактов и требует стратегий оптимизации для эффективного управления памятью
  • Функции, связанные со временем, например block.number и block.timestamp, ведут себя иначе. Разработчикам настоятельно не рекомендуется использовать их при разработке для Neon EVM

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

Подключение к Neon RPC

Разработчики могут легко подключиться к Neon RPC через Chainlist. Здесь можно подключиться к Neon EVM Mainnet или Devnet. Нажмите Connect Wallet в модальном окне Mainnet или Devnet, а затем Approve, когда откроется ваш кошелек.

Перед отправкой транзакций в Neon EVM пользователям следует выбрать оптимального оператора. Разверните сведения на карточке, чтобы увидеть доступные конечные точки RPC для каждой сети:

Если вы выберете не оператора по умолчанию, предложенного при подключении кошелька, потребуется подключиться вручную. В документации Neon EVM есть подробные руководства по подключению к Proxy через Foundry, Hardhat, Remix и Truffle. В разделе о развертывании мы рассмотрим подключение через Foundry.

После подключения разработчики могут получить NEON или другие тестовые токены ERC-20 через Neon Faucet. Также можно программно запрашивать токены через конечную точку request_neon:

Код
curl -i -X POST \
	-d '{"wallet": "Your wallet", "amount": 1}' \
	'http://localhost:3333/request_neon'

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

Жизненный цикл транзакции и комиссии за газ

Транзакция из dApp Ethereum выполняется в Solana через Neon EVM в три основных этапа:

  • Пользователь инициирует подписанную Ethereum-подобную транзакцию, направленную на конечную точку Neon RPC
  • Транзакция передается в Neon Proxy через Ethereum API. Proxy оценивает объем газа для выполнения транзакции, инициирует ее рассылку, оборачивая Ethereum-подобную транзакцию в транзакцию Solana, и отправляет обернутую транзакцию в Neon EVM. В результате формируются квитанция Solana и соответствующая квитанция транзакции Neon EVM. Смарт-контракт Neon разворачивает транзакцию, проверяет подпись пользователя и загружает состояние EVM из хранилища Solana. Транзакция выполняется внутри BPF Solana
  • Solana и Neon EVM обновляют свои состояния и завершают запрос транзакции

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

Разработчики также могут отправлять транзакции без газа. Эта возможность предназначена для пользователей, у которых недостаточно токенов NEON для оплаты комиссий за первые транзакции. Чтобы получить стартовый пакет транзакций без газа, разработчики могут написать на info@neonevm.org. Выбранный разработчиком Proxy Operator по-прежнему обработает эти транзакции, однако их стоимость оплатит Neon. Обычно каждому новому аккаунту Neon предоставляется не менее трех транзакций без газа.

Процесс отправки транзакций без газа выглядит так:

  • Конечный пользователь инициирует транзакцию через dApp
  • dApp запрашивает текущую цену газа у выбранного Proxy Operator. Если аккаунт соответствует требованиям, Proxy Operator помечает аккаунт Neon как имеющий право на определенное количество транзакций без газа
  • Для таких транзакций dApp показывает нулевую стоимость газа
  • Конечный пользователь подписывает транзакцию без комиссии за газ
  • Proxy Operator выполняет транзакцию, а комиссию за газ в SOL оплачивает Neon Foundation

В документации Neon EVM приведен следующий фрагмент, демонстрирующий запрос транзакции без газа:

Код
try {
	// Get gasless transaction if user account is eligible
  const rawGasPrice = await axios.post(rpcApiUrl, {
  	method: 'neon_gasPrice',
    params: [{ from: address }],
    jsonrpc: "2.0",
    id: new Date().getTime()
   })

   tx.gasPrice = rawGasPrice.data?.result;
	} catch (e) {
  	//Else, get standard GAS price
   	setError('Can\'t retrieve gas price for transaction')

    const rawGasPrice = await web3.eth.getGasPrice();

    tx.gasPrice = web3.utils.toHex(rawGasPrice);
} finally {
    setTx(tx)
}

NeonPass

NeonPass — инструмент для передачи токенов между Solana и Neon EVM. Он позволяет беспрепятственно перемещать активы между ассоциированными токен-аккаунтами Solana и аккаунтами токенов ERC-20 в Neon EVM. NeonPass использует интерфейсный контракт Neon EVM и специализированное хранилище аккаунтов. Токены Solana Program Library (SPL) упаковываются в интерфейс ERC-20 внутри фабричного контракта Neon EVM. Благодаря этому SPL можно хранить в аккаунтах токенов ERC-20, совместимых с dApps на Solidity. NeonPass позволяет передавать токены в обоих направлениях между аккаунтами Solana и Neon EVM. В отличие от традиционных мостов, которые блокируют активы и выпускают новые, он напрямую перемещает токены между двумя типами аккаунтов. Это обеспечивает беспрепятственное перемещение токенов Solana и Neon EVM.

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

Разработчики могут развертывать приложения в Neon EVM с помощью Hardhat, Foundry, Truffle и Remix. Поскольку проще всего использовать Solang через Anchor, все тесты написаны на TypeScript. Однако теперь поклонники Solidity наконец могут тестировать и развертывать dApps на Solidity в Solana через Foundry.

Сначала убедитесь, что ваш совместимый с EVM кошелек подключен к Neon EVM Devnet. Затем клонируйте пример проекта Foundry от Neon и перейдите в его каталог:

Код
git clone https://github.com/neonlabsorg/neon-tutorials
cd neon-tutorials/foundry

Затем установите Foundryup, установщик набора инструментов Foundry, и выполните foundryup, чтобы установить последние nightly-версии предварительно скомпилированных бинарных файлов, то есть force, cast, anvil и chisel:

Код
curl -L https://foundry.paradigm.xyz | bash
foundryup

Установите необходимые библиотеки:

Код
forge install foundry-rs/forge-std --no-commit
forge install openzeppelin/openzeppelin-contracts --no-commit

Теперь получите приватный ключ аккаунта кошелька. Например, в Metamask его можно увидеть, открыв меню-гамбургер и перейдя в Account Details > Show Private Key. Вам будет предложено ввести пароль. Нажмите Confirm, чтобы получить доступ к приватному ключу аккаунта. Никому не передавайте этот ключ и примите необходимые меры для его защиты.

Затем создайте файл .env со следующими переменными:

Код
RPC_URL_DEVNET=https://devnet.neonevm.org
CHAIN_ID_DEVNET=245022926
RPC_URL_MAINNET=https://neon-proxy-mainnet.solana.p2p.org
CHAIN_ID_MAINNET=245022934
PRIVATE_KEY=
VERIFIER_URL_BLOCKSCOUT=https://neon-devnet.blockscout.com/api

Замените <YOUR_PRIVATE_KEY> своим приватным ключом и выполните source .env.

Чтобы скомпилировать контракты проекта, перейдите в каталог src и выполните forge build. В консоли должно появиться сообщение об успешной работе компилятора. Контракты также можно протестировать командой forge test. Чтобы развернуть контракт проекта, выполните следующую команду:

Код
forge create --rpc-url $RPC_URL_DEVNET --private-key $PRIVATE_KEY src/TestERC20/TestERC20.sol:TestERC20 --constructor-args "Test ERC20 Token" "TERC20" --legacy

Вы должны увидеть примерно такой вывод:

Код
[⠰] Compiling...
No files changed, compilation skipped
Deployer: 0x4455E84Eaa56a01676365D4f86348B311969a4f4
Deployed to: 0x5537599aa2F97Dd60a66342522a465A7f2e40Ff9
Transaction hash: 0x6de9dab8a526cbac33008056d185b93dff725605efb791bf116b6bece4f0c486

Чтобы верифицировать контракт, выполните следующую команду:

Код
forge verify-contract --chain-id $CHAIN_ID_DEVNET  src/TestERC20/TestERC20.sol:TestERC20 --verifier-url $VERIFIER_URL_BLOCKSCOUT --verifier blockscout

Замените <contract_address> адресом своего смарт-контракта. Вы должны получить ответ OK с URL, ведущим на адрес контракта в BlockScout — обозревателе Devnet от Neon. В файле .env также можно настроить использование NeonScan вместо BlockScout. NeonScan также поддерживает devnet.

Преимущества и ограничения

Разработчикам, которым нужен опыт разработки, похожий на Ethereum, стоит выбрать Neon EVM. Это совместимая с EVM среда, которая отправляет Ethereum-подобные транзакции и использует знакомые инструменты. Такие возможности, как NeonPass, поддержка большинства опкодов EVM и транзакции без газа, значительно упрощают переход на Solana. Однако Neon EVM не идеальна. У нее есть ряд ограничений: необходимость менять логику смарт-контрактов для адаптации к инфраструктуре Solana, работа в рамках ограничений Berkeley Packet Filter (BFP) и моделей аккаунтов Solana, а также ограничения для некоторых опкодов и предварительно скомпилированных контрактов. Чтобы успешно развертывать приложения в Solana из совместимой с EVM среды, важно понимать и учитывать эти особенности.

Предыдущие миграции

Чтобы крупный протокол Ethereum можно было развернуть в сети без EVM, необходимо решить несколько сложных задач. В частности, найти инженеров, не специализирующихся на Solidity, чтобы переписать кодовую базу с нуля, выбрать надежных партнеров для аудита, повторно проверить новую кодовую базу и адаптировать контракты управления для исполнения решений DAO. Это может стоить миллионы долларов и потребовать нескольких месяцев напряженной работы. Для большинства проектов такой вариант невозможен. Однако подобные миграции уже происходили.

Helium — это сеть LoRaWAN, цель которой — создать децентрализованную беспроводную инфраструктуру для поддержки устройств Интернета вещей (IoT). Для этого используются хот-споты — небольшие устройства с низким энергопотреблением, похожие на миниатюрные вышки сотовой связи и способные подключаться к другим хот-спотам на больших расстояниях. Изначально Helium работал на собственном блокчейне первого уровня (L1), но команда разработчиков предложила перейти на Solana в рамках HIP 70. Переход позволил бы Helium повысить доступность, расширить возможности компонуемости и ускорить взаимодействие с пользователями, сохранив высокий уровень безопасности и низкую стоимость использования. Сообщество подавляющим большинством поддержало предложение, и в апреле 2023 года Helium перешел на Solana. Операционный директор Helium Скотт Сигел назвал миграцию скучным событием — ни с сетью, ни с инфраструктурой Helium не возникло никаких проблем. Это была мечта инженера. Команда также описала весь процесс миграции в серии руководств в своей документации. Миграция Helium прошла с огромным успехом и принесла сообществу значительную пользу.

Эта миграция — не единичный случай. The Render Network, первая в мире децентрализованная платформа GPU-рендеринга, в ноябре 2023 года успешно перенесла свою основную инфраструктуру с Ethereum на Solana. Сообщество проголосовало за RNP-002, поддержав миграцию на Solana. Основатель Render Джулс Урбах назвал миграцию переломным моментом. Он заявил: «Невероятная скорость транзакций Solana, низкие комиссии и ориентация на архитектуру веб-масштаба делают ее идеальной платформой для Render Network, пока мы продолжаем создавать масштабируемую и децентрализованную инфраструктуру метавселенной».

Миграция Render не оказала заметного негативного влияния на пользователей. Они могут переводить средства из Ethereum в Solana с помощью Render’s Upgrade Assistant. Пользователь подключает кошелек Ethereum, указывает количество RNDR для миграции и ожидает доставки токенов на указанный кошелек Solana. 

Maker — один из наиболее характерных проектов Ethereum. Его цель — раскрыть потенциал децентрализованных финансов с помощью Maker Platform, инклюзивной платформы, призванной расширить экономические возможности и обеспечить равный доступ к глобальному финансовому рынку. Платформа состоит из MakerDAO для управления проектом Maker и протокола Maker для DAI — «первой в мире непредвзятой валюты и ведущего децентрализованного стейблкоина». Основатель Maker Руне Кристенсен опубликовал пост об использовании форка кодовой базы Solana для разработки аппчейна Maker: 

Миграции по своей природе сложны. Несмотря на финансовые и временные затраты, а также репутационные риски переноса всей инфраструктуры проекта с Ethereum на Solana, проекты выбирают Solana. С такими инструментами, как Solang и Neon EVM, миграция не обязательно должна быть сложной. Как показал опыт Helium, она может пройти без лишних событий и практически не повлиять на средства пользователей, как в случае с Render Network. Solana — самый производительный блокчейн на рынке, созданный для веб-масштаба. Здесь стоит разрабатывать, и все больше проектов это понимают.

Заключение

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

Solana предлагает эффективную альтернативу этим ограничениям. Лучший способ воспользоваться реальными преимуществами Solana — разрабатывать непосредственно на Solana. Благодаря последним достижениям такие инструменты, как Solang и Neon EVM, позволяют заинтересованным разработчикам EVM выполнять миграцию с помощью знакомых инструментов и языков. В этой статье представлено подробное руководство по архитектуре Solana, ее сравнению с Ethereum и первым шагам разработчика EVM в создании решений на Solana. Solana — самый производительный блокчейн на рынке. Он набирает популярность, привлекает все больше внимания и становится основой для надежных потребительских приложений. Зачем ждать масштабирования Ethereum, если уже сегодня можно воспользоваться преимуществами быстрого и масштабируемого блокчейна?

Если вы дочитали до этого места, спасибо, анон! Укажите свой адрес электронной почты ниже, чтобы не пропускать новости Solana. Готовы узнать больше? Присоединяйтесь к нашему Discord, чтобы уже сегодня начать создавать будущее на самом производительном блокчейне.

Дополнительные ресурсы

Подпишитесь на Helius

Следите за новостями разработки на Solana и получайте уведомления о наших публикациях

Увеличенное изображение