Parity (OpenEthereum)

Что такое Parity (OpenEthereum)?

Parity (OpenEthereum) — бывший клиент исполнения Ethereum, который изначально назывался Parity Ethereum, а позже получил название OpenEthereum.

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

Изначально Parity Ethereum разрабатывала компания Parity Technologies. Клиент был написан на Rust и отличался высокой скоростью, низким потреблением ресурсов, модульной архитектурой и пригодностью для промышленной инфраструктуры Ethereum.

В конце 2019 года Parity Technologies объявила, что кодовая база Parity Ethereum и ее сопровождение перейдут к открытому совместному проекту OpenEthereum.

В официальном сообщении Parity Transitioning Parity Ethereum to OpenEthereum DAO пояснялось, что клиент перейдет к модели сопровождения с участием нескольких организаций.

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

В организации OpenEthereum на GitHub проект публично обозначен как устаревший.

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

Его не следует путать с текущей деятельностью Parity Technologies в более широкой блокчейн-экосистеме.

Также не следует путать его с общеупотребительным словом parity, которое может означать равенство или четность/нечетность в математике и вычислительной технике.

Основные сведения о Parity (OpenEthereum)

• • Parity Ethereum — клиент исполнения Ethereum, изначально разработанный Parity Technologies.
  • OpenEthereum — более поздняя версия Parity Ethereum, которую поддерживало сообщество.
  • Клиент был написан на Rust и получил известность благодаря скорости, модульности и применению в инфраструктуре Ethereum.
  • Сейчас OpenEthereum признан устаревшим. Это историческое ПО, а не актуальный клиент по умолчанию для основной сети Ethereum.
  • Parity (OpenEthereum) помог показать, почему Ethereum нужна поддержка нескольких независимых реализаций клиентов.
  • Инциденты с кошельком Parity в 2017 году не связаны напрямую с самим клиентом Ethereum, но остаются важными уроками по безопасности смарт-контрактов.
  • Современные операторы узлов Ethereum обычно используют актуальные клиенты исполнения в связке с актуальными клиентами консенсуса.
  • Знакомство с Parity (OpenEthereum) помогает понять историю клиентов Ethereum, риски инфраструктуры и управление жизненным циклом ПО.

Почему Parity (OpenEthereum) важен для криптоиндустрии

Parity (OpenEthereum) важен, потому что Ethereum — это не одна отдельная программа.

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

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

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

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

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

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

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

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

Поэтому Parity (OpenEthereum) остается важным, хотя больше не является актуальным клиентом основной сети.

Его история объясняет, почему Ethereum ценит разнообразие клиентов, разные языки программирования, независимые команды и активное сопровождение ПО.

Parity Ethereum и OpenEthereum: в чем разница

Parity Ethereum — первоначальное название клиента Ethereum, разработанного Parity Technologies.

OpenEthereum — название, которое проект получил после выхода из-под непосредственного контроля Parity Technologies.

О переходе объявили в декабре 2019 года.

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

В феврале 2020 года Parity также опубликовала материал Contributors Join OpenEthereum. В нем объяснялось, что команда отказалась от подхода с лицензией под управлением DAO и пока сохранила кодовую базу под лицензией GPLv3.

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

В других материалах может использоваться название OpenEthereum.

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

Практическое различие состоит в том, что Parity Ethereum обозначает более ранний период под руководством Parity, а OpenEthereum — последующий период сопровождения сообществом.

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

Что делает клиент исполнения Ethereum

Клиент исполнения Ethereum — это часть ПО узла, которая обрабатывает транзакции Ethereum, исполняет смарт-контракты, отслеживает балансы аккаунтов, учитывает газ, формирует квитанции и журналы, а также обрабатывает изменения состояния.

До перехода Ethereum на Proof of Stake клиенты исполнения часто называли клиентами Eth1.

После The Merge узлам Ethereum обычно нужны и клиент исполнения, и клиент консенсуса.

Клиент исполнения обрабатывает транзакции и поддерживает состояние исполнения.

Клиент консенсуса отвечает за консенсус Proof of Stake, координацию предложения блоков, аттестации и выбор форка.

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

Parity (OpenEthereum) относился к категории клиентов исполнения.

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

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

Когда пользователи говорят об OpenEthereum как о клиенте, речь в первую очередь идет об инфраструктуре узлов, а не о потребительском приложении-кошельке.

Как работал Parity (OpenEthereum)

Parity (OpenEthereum) подключался к одноранговой сети Ethereum и следовал правилам протокола Ethereum.

Узел с этим клиентом мог находить другие узлы, загружать блоки, проверять заголовки блоков, выполнять транзакции, поддерживать локальную базу данных Ethereum и предоставлять API локальным или удаленным приложениям.

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

В документации OpenEthereum упоминались такие функции, как расширенные возможности командной строки, настраиваемые API и быстрая синхронизация.

Как и другие клиенты Ethereum, OpenEthereum поддерживал интерфейсы JSON-RPC, позволявшие приложениям запрашивать данные блокчейна и отправлять подписанные транзакции.

В документации Ethereum по API JSON-RPC объясняется, как приложения Ethereum взаимодействуют с клиентами исполнения через стандартизированные методы API.

Благодаря этому такие клиенты, как Parity (OpenEthereum), стали важной инфраструктурой для кошельков, обозревателей блокчейна, dApp, индексаторов и сервисов, которым нужны данные Ethereum.

Чтобы пользоваться преимуществами клиента, пользователю не требовалось знать все его внутренние особенности.

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

Почему Rust был важен

Parity Ethereum был известен тем, что его написали на Rust.

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

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

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

Медленный клиент может создавать операционные проблемы для операторов узлов.

Модульный клиент может быть проще адаптировать и интегрировать в сервисы.

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

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

Важны также разные языки программирования, архитектуры, зависимости и инженерные подходы.

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

Разные реализации могут снизить этот риск, если они активно сопровождаются и тестируются на соответствие одним и тем же правилам протокола.

Прекращение поддержки OpenEthereum

Сейчас OpenEthereum признан устаревшим.

В организации OpenEthereum на GitHub проект обозначен как устаревший, а несколько связанных репозиториев архивированы.

На странице релизов OpenEthereum представлены исторические выпуски, включая версию v3.3.5 за 2022 год.

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

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

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

Кроме того, он может не получать исправления безопасности и обновления совместимости.

Поэтому старые руководства по OpenEthereum не следует считать актуальными инструкциями по эксплуатации основной сети Ethereum.

Историческое ПО может оставаться полезным для исследований, старых частных сетей, архивных материалов или изучения истории развития Ethereum.

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

Parity (OpenEthereum) и разнообразие клиентов Ethereum

Разнообразие клиентов означает, что у блокчейн-сети есть несколько независимых реализаций клиентов.

Ethereum выигрывает от того, что ни один клиент не доминирует во всей сети.

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

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

Parity Ethereum поддерживал разнообразие клиентов Ethereum в важный период роста сети.

Некоторое время эту роль продолжал выполнять и OpenEthereum.

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

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

Главный урок истории Parity (OpenEthereum) не сводится к тому, что несколько клиентов лучше, чем один.

Важно, чтобы несколько клиентов активно сопровождались.

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

Parity (OpenEthereum) и The Merge

После The Merge Ethereum перешел с Proof of Work на Proof of Stake.

Теперь современный узел Ethereum обычно объединяет клиент исполнения с клиентом консенсуса.

В период перехода Ethereum OpenEthereum уже приближался к завершению своего жизненного цикла сопровождения.

Поэтому OpenEthereum не входит в стандартный современный стек клиентов Ethereum после The Merge для работы с актуальным узлом основной сети.

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

The Merge также сделал различие между клиентами исполнения и консенсуса более заметным.

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

Современная инфраструктура Ethereum разделена на более четкие уровни.

Этот контекст помогает понять, почему исторические клиенты, такие как Parity (OpenEthereum), следует рассматривать с учетом периода, в котором они использовались.

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

Parity Wallet и клиент Parity Ethereum

Parity Wallet и Parity Ethereum Client исторически связаны, но их не следует считать одним и тем же продуктом.

Parity Ethereum был клиентом исполнения для подключения к Ethereum и работы с сетью.

Parity Wallet — название функциональности кошелька и инструментов для кошельков на смарт-контрактах, связанных с ПО Parity.

Это различие важно, поскольку известные инциденты с Parity в 2017 году затрагивали смарт-контракты кошельков с мультиподписью, а не сам протокол Ethereum целиком.

Новички могут услышать о «взломе Parity» и решить, что взломали сам клиент Ethereum.

Это неверный вывод.

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

Клиентское ПО, интерфейсы кошельков, смарт-контракты и пользовательские ключи — это разные уровни.

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

Понимание этого различия важно для точной оценки рисков в криптоиндустрии.

Инциденты с мультисиг-кошельками Parity в 2017 году

Инциденты с мультисиг-кошельками Parity — одни из самых известных событий в истории безопасности смарт-контрактов Ethereum.

В июле 2017 года уязвимость в контрактах мультисиг-кошельков Parity позволила злоумышленнику похитить более 150,000 ETH из затронутых кошельков.

В анализе взлома мультисиг-кошелька Parity от OpenZeppelin объясняется, что уязвимость затрагивала Parity Multisig Wallet версии 1.5 и более поздние версии.

В ноябре 2017 года возникла еще одна критическая проблема, затронувшая мультисиг-кошельки Parity, созданные после 20 июля 2017 года.

В предупреждении о безопасности Parity сообщила, что уязвимость обнаружили в контракте библиотеки Parity Wallet, используемом стандартным мультисиг-контрактом.

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

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

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

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

Уроки Parity в области безопасности смарт-контрактов

Инциденты с кошельками Parity преподали несколько важных уроков в области безопасности смарт-контрактов.

Первый урок: права доступа должны быть заданы явно и тщательно проверены.

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

Второй урок: библиотеки смарт-контрактов могут стать единой точкой отказа.

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

Третий урок: безопасность мультисиг-кошельков зависит от качества их реализации.

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

Четвертый урок: важны аудиты, формальная проверка, программы вознаграждения за обнаружение ошибок и поэтапное развертывание.

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

Шестой урок: пользователям следует различать безопасность протокола и безопасность приложений.

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

Parity (OpenEthereum) и операторы узлов

Для операторов узлов Parity (OpenEthereum) — прежде всего исторический клиент, который важно изучать, а не использовать как современный инструмент по умолчанию.

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

Устаревший клиент может создавать операционные риски, поскольку Ethereum продолжает развиваться.

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

При настройке узлов для промышленной эксплуатации операторам инфраструктуры следует использовать актуальную документацию по клиентам Ethereum.

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

Parity (OpenEthereum) по-прежнему полезен для изучения того, как строилась историческая инфраструктура Ethereum.

Он также помогает понять, почему важно управлять жизненным циклом клиентов.

Установка блокчейн-узла — не разовое действие.

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

Parity (OpenEthereum) и разработчики

Разработчики использовали Parity (OpenEthereum) для взаимодействия с Ethereum через RPC API, локальные узлы, тестовые среды и инфраструктурные сервисы.

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

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

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

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

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

Это снижает риск зависимости от особенностей одного клиента.

Это также поддерживает общую цель Ethereum — разнообразие реализаций.

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

Старые примеры Parity могут объяснить принципы работы, но для современных промышленных систем нужна поддержка актуальных клиентов.

Parity (OpenEthereum) и JSON-RPC

JSON-RPC — распространенный интерфейс, через который многие приложения Ethereum взаимодействуют с клиентами исполнения.

Parity (OpenEthereum) предоставлял методы JSON-RPC, позволявшие приложениям запрашивать данные аккаунтов, блоков и транзакций, журналы и другую информацию Ethereum.

Ранее некоторые поставщики инфраструктуры отдавали предпочтение Parity из-за его производительности и набора функций.

Однако неосторожное предоставление доступа к конечным точкам RPC создает риски безопасности.

Незащищенная публичная конечная точка RPC может раскрыть данные, дать возможность злоупотребления, подвергнуть систему атакам типа «отказ в обслуживании» или, при неправильной настройке, разрешить опасные административные действия.

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

Этот урок применим ко всем клиентам Ethereum, а не только к Parity (OpenEthereum).

Даже теоретически безопасное клиентское ПО может стать опасным при развертывании с небезопасными настройками.

Операционная безопасность — часть безопасности узла.

Parity (OpenEthereum) и современные клиенты Ethereum

Parity (OpenEthereum) отличается от современных активно сопровождаемых клиентов Ethereum тем, что его разработка и поддержка прекращены.

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

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

Современный узел Ethereum — это не просто установка старого клиента, о котором можно забыть.

Он требует внимательного выбора и постоянного сопровождения ПО.

Историческое значение OpenEthereum не следует путать с готовностью к промышленной эксплуатации сегодня.

Клиент может иметь большое влияние и при этом устареть.

Для инфраструктуры с открытым исходным кодом это обычная ситуация.

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

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

Почему OpenEthereum признали устаревшим

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

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

Прекращение поддержки OpenEthereum показало, что инфраструктуре с открытым исходным кодом нужны активные сопровождающие, а не только историческая значимость.

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

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

Для пользователей общий вывод прост.

Криптоклиент не следует оценивать только по его прежней репутации.

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

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

Чему Parity (OpenEthereum) учит о ПО с открытым исходным кодом в криптоиндустрии

Parity (OpenEthereum) показывает, что инфраструктура криптоиндустрии с открытым исходным кодом дает большие возможности, но требует значительных усилий.

Такое ПО можно изучать, разветвлять, улучшать и повторно использовать.

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

Репозиторий может перестать обновляться.

Команда сопровождающих может переключиться на другие задачи.

Клиент может пропустить обновления.

В библиотеке смарт-контрактов могут быть критические ошибки.

Популярный инструмент может устареть, пока старые руководства продолжают распространяться в интернете.

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

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

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

Распространенные заблуждения о Parity (OpenEthereum)

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

На самом деле OpenEthereum стал продолжением клиента Parity Ethereum после того, как проект вышел из-под контроля Parity Technologies.

Другое заблуждение — считать OpenEthereum рекомендованным клиентом основной сети Ethereum на сегодняшний день.

Это не так, поскольку проект признан устаревшим.

Третье заблуждение — считать, что инциденты с мультисиг-кошельками Parity были сбоями протокола Ethereum.

Это были сбои смарт-контрактов кошельков, а не самого консенсуса Ethereum.

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

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

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

Для здорового разнообразия нужны активно сопровождаемые, безопасные и актуальные реализации.

Шестое заблуждение — считать, что кодовая база на Rust автоматически безопасна.

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

Риски безопасности устаревших клиентов

Использование устаревшего клиентского ПО блокчейна может создавать серьезные риски безопасности и эксплуатации.

Первый риск — несовместимость с протоколом.

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

Второй риск — отсутствие важных исправлений безопасности.

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

Третий риск — проблемы с подключением к узлам сети.

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

Четвертый риск — несовместимость API.

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

Пятый риск — сложности с эксплуатацией.

Старая документация может противоречить современной архитектуре Ethereum.

Шестой риск — ложное чувство уверенности.

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

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

Как безопасно изучать Parity (OpenEthereum)

Начните с официальных публикаций Parity о переходе, чтобы понять причины изменения названия.

Затем проверьте организацию OpenEthereum на GitHub и убедитесь в текущем статусе сопровождения проекта.

После этого изучите старую документацию OpenEthereum, чтобы понять, как клиент работал исторически.

Затем сравните эти сведения с актуальной документацией Ethereum по узлам.

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

Если вы изучаете инциденты с кошельками, отделяйте клиентское ПО от кода смарт-контрактов кошелька.

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

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

Не полагайтесь на устаревшие публикации в блогах как на актуальные инструкции по эксплуатации.

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

Parity (OpenEthereum) в одном предложении

Parity (OpenEthereum) — написанный на Rust клиент исполнения Ethereum, изначально известный как Parity Ethereum, позднее переименованный в OpenEthereum и теперь признанный устаревшим; при этом он остается важным для понимания истории клиентов Ethereum, их разнообразия и рисков криптоинфраструктуры.

FAQ

Что такое Parity (OpenEthereum)?

Parity (OpenEthereum) — историческое семейство клиентов исполнения Ethereum, которое началось с Parity Ethereum и позднее получило название OpenEthereum.

Parity Ethereum и OpenEthereum — это одно и то же?

OpenEthereum стал более поздним продолжением клиента Parity Ethereum, который поддерживало сообщество.

Кто создал Parity Ethereum?

Изначально Parity Ethereum разрабатывала компания Parity Technologies.

На каком языке программирования был написан Parity Ethereum?

Parity Ethereum и OpenEthereum были написаны на Rust.

OpenEthereum все еще сопровождается?

Нет. OpenEthereum признан устаревшим, а связанные с ним репозитории архивированы.

Можно ли использовать OpenEthereum как узел основной сети Ethereum сегодня?

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

Что делал Parity (OpenEthereum)?

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

Почему Parity был важен для Ethereum?

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

Что случилось с OpenEthereum?

В итоге жизненный цикл OpenEthereum завершился: проект признали устаревшим, и его перестали активно сопровождать как клиент Ethereum.

Инциденты с кошельком Parity были тем же, что ошибка клиента Ethereum?

Нет. Инциденты с кошельками Parity затрагивали код смарт-контрактов мультисиг-кошельков, а не основной протокол Ethereum.

Каков главный урок инцидентов с кошельками Parity?

Код смарт-контрактов кошельков необходимо тщательно проектировать, проверять, тестировать и контролировать, поскольку ошибки могут навсегда затронуть активы большой стоимости.

Каков главный урок прекращения поддержки OpenEthereum?

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

Заключение

Parity (OpenEthereum) — важная часть истории Ethereum.

Сначала он назывался Parity Ethereum — это был клиент исполнения на Rust, разработанный Parity Technologies.

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

На протяжении нескольких лет он вносил вклад в развитие инфраструктуры Ethereum, ее производительности и разнообразия клиентов.

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

Его история ценна, поскольку дает несколько важных уроков о криптоиндустрии.

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

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

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

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

Инциденты с кошельками Parity показали, как уязвимость библиотеки смарт-контрактов может привести к масштабной краже или блокировке средств.

Прекращение поддержки OpenEthereum показало, что даже влиятельная инфраструктура может достичь конца жизненного цикла.

Современным пользователям безопаснее признавать Parity (OpenEthereum) важным историческим клиентом, но для работы в действующей сети использовать актуальное сопровождаемое ПО Ethereum.

Знакомство с Parity (OpenEthereum) помогает понять, как Ethereum прошел путь от ранней конкуренции клиентов к более зрелой экосистеме клиентов исполнения и консенсуса.