Начну с простого и наболевшего. Я безработный кодер) Рынок сейчас — дно тотальное. Три месяца я рассылаю отклики, и вот срез моей истории:
Вакансия |
Итог |
|---|---|
AppSec-инженер в крупном банке |
отказ |
AppSec-инженер в бигтехе |
отказ |
AppSec-инженер, ещё один |
висит «отклик отправлен», как мемориал |
Offensive AppSec Engineer |
отказ. Похоже, я недостаточно offensive |
Rust Developer |
отказ |
Senior Backend (Rust/C++) |
тишина, как в неких датацентрах |
Backend Middle |
отказ. Для мидла я, видимо, слишком недомидленный |
Вайб-кодер / AI-разработчик |
отказ. Меня не взяли вайб-кодером. Вайб не тот |
Пентестер |
и тут тишина |
Тестировщик ПО |
тишина. Хотя тестировщиком в VK я уже поработал |
Техподдержка хостинга, 2-я линия, тикеты |
«позиция уже закрыта». Даже тикеты разобрали без меня |
Quant PM, трейдер проп-деска, арбитраж трафика |
тишина. |
Вишенка на торте: между отказами на вакансии специалиста по информационной безопасности красная площадка заботливо подсунула мне курсы «Специалист по информационной безопасности». Это не баг, это их бизнес-модель. Рынок труда давно превратился в воронку продаж: тебя не берут на работу, чтобы продать тебе обучение для работы, на которую тебя не возьмут.
Схема простая и циничная до слёз. Живого человека, который находит дыры в продакшне и пишет об этом публично, вежливо отшивают шаблонным «к сожалению». Зато ему же за 150 тысяч в рассрочку предлагают стать «Топовым АппСек Инженером с нуля за 6 месяцев»… С гарантией трудоустройства, напечатанной таким мелким шрифтом, что для её прочтения нужен отдельный курс, и с наставником, чей боевой опыт — три вебинара и CTF для школьников.
Так что, видимо, реальному специалисту надо купить ещё 100500 курсов. «Хакер PRO». «Пентест с нуля до оффера». «AppSec Senior за 3 месяца». «Этичный хакинг для чайников». «DevSecOps Мастер-Класс». И сверху «Нейросети для безопасника», потому что без слова «нейросети» резюме сейчас видимо не открывают. Все сертификаты — в шапку резюме, жирным. HR-фильтр ищет ключевые слова, а не человека, который отличает SQL-инъекцию от SQL-запроса. Его этому не учили, у него тоже был курс.
Саму вакансию AppSec в итоге получит выпускник интенсива, который на собеседовании без запинки отбарабанит OWASP Top 10 и ни разу в жизни не открывал чужой код. Через полгода он пропустит в прод ровно тот баг, про который был слайд номер пять. Его компания потеряет данные клиентов. А чудо-курсы сделают из этого кейс и продадут новый поток.
Ну и как же без процветания ИИ-слопа. Резюме теперь читает не человек, а ИИ-HR. Он сверяет твой текст с вакансией, которую тоже написал ИИ, и отказ тебе пишет тоже ИИ: «Мы внимательно изучили ваш опыт». Никто ничего не изучал. Три нейросети поговорили между собой, организовали консенсус и решили, что ты не подходишь. Сопроводительные письма генерирует ChatGPT, тестовые задания решает Claude, собеседование ведёт бот, а на выходе нанимают того, у кого промпт лучше.
А когда поздно, выходит новость: «Ой. У нас утекла пара ТБ данных». Причём утекла она не из-за гениальной APT-группировки с бюджетом маленькой страны. Её вынес школьник с агентами Клода, который за вечер, между домашкой по алгебре и катками, прогнал по вашему API всё, что не закрыли выпускники курсов. Атакующим ИИ дал скорость. Защищающимся он дал красивый PDF-отчёт с зелёными галочками, который никто не открывал, ведь если отчет есть — он точно хороший.
Мой любимый жанр данного цирка — компании, которые годами рассказывают на конференциях, какая у них крутая инфраструктура. Есть, например, одна сеть пиццерий, думаю вы слышали о ней. Пицца у них правда вкусная, без шуток, я её часто ем. И ещё они очень любят рассказывать, что они не пиццерия, а крутая IT-компания, которая печёт пиццу: своя платформа, микросервисы, доклады, митапы, мерч. А потом — бам, и база клиентов гуляет по дарку: имена, телефоны, адреса доставки. IT-компания, которая случайно печёт пиццу, оказалась пиццерией, которая случайно хранит ваши данные. Пицца, к слову, осталась качественной. Качество — единственное, что у них в тот день не утекло.
Нанимать людей, которые умеют находить такое руками, наверно было дорого и долго. Утечка, как обычно бывает, вышла дороже.
Чтобы без двойных стандартов: я тоже иногда пишу с ИИ, и в fe-zk это честно раскрыто в docs/AI_LOG.md. Разница в одном: каждую строку я вручную проверяю тестом на векторах независимых эталонов и могу объяснить. ИИ — это инструмент (множитель), а не замена человеку, который понимает, что делает. Именно такого человека вы и отсеиваете своим ИИ-HR.
Вывод простой: никуда ты не нахантишься, друг мой, если ты, конечно, не доктор наук по информатике с пятью сертификатами и рекомендацией от ИИ-HR ;)
Почему с безопасностью всё так грустно: верификаторы без проверок, мосты без валидации, функции без проверки длины ответа. Ответ рядом: людей, которые умеют это проверять, отсеивают на этапе «у вас нет 5 лет опыта в нашем внутреннем NDA фреймворке». Ладно) Раз меня не берут чинить чужой код, я написал свой, и такой, чтобы целый класс этих багов ловил компилятор. Получилось вот что.
Меня зовут 0xItsss, я пишу на Rust и состою в исследовательском коллективе ZKRP. Мы занимаемся zero-knowledge криптографией, приватной инфраструктурой и децентрализованными системами. Почти год мы с командой делали OrangeHail — платёжную инфраструктуру на ZK. Про сам проект здесь говорить не буду, да и он пока не опен-сорснут. Скажу одно: за этот год я насмотрелся на то, как ломаются ончейн верификаторы и оффчейн SDK. Почти всегда виноваты не формулы, а проверки, которые забыли правильно реализовать.
Когда объявили Fe Builders Challenge 2026, я решил закрыть дыру, которая давно бросалась в глаза. В языке Fe нет ни одного верификатора доказательств. Любой ZK-проект на Fe вынужден уходить обратно в Solidity, потому что snarkjs, gnark и snark-verifier экспортируют только Solidity.
За пару недель размышлений и 5 дней кодинга получилась fe-zk. Это библиотека и генератор:
верификаторы Groth16, PLONK (snarkjs и gnark), halo2-KZG (SHPLONK и GWC), KZG-открытия и FRI/STARK для пруфов Plonky3;
слой полей, кривых и хешей за трейтами Fe;
fe-zk-genна Rust, который из verifying key делает Fe-контракт с тестами;демо: Semaphore v4, верификатор Tornado Cash на реальных mainnet-пруфах, zk Game of Life.
Ниже — как это устроено, где было больно и почему Fe мне понравился больше, чем я ожидал.
Введение в ZK для тех, кто не в теме
Zero-knowledge доказательство — это способ убедить другого, что утверждение верно, не раскрывая, почему оно верно. Классический пример: «я знаю секрет, хеш которого лежит в этом дереве», и при этом не показывать ни секрет, ни позицию в дереве.
В блокчейне ZK нужен для двух вещей:
Приватность. Доказать, что ты член группы, имеешь право на выплату или не тратишь монету дважды, не раскрывая, кто ты. Так работают Semaphore, Tornado Cash и Zcash.
Масштабирование. Посчитать что-то тяжёлое вне чейна и проверить на чейне короткий пруф, а не повторять вычисление. Так работают zk-роллапы.
Три роли

Три роли: setup, prover, verifier
Схема (circuit) описывает утверждение как систему уравнений над конечным полем. Например, «
Poseidon(secret)— лист дерева с корнемroot».Prover знает секрет (witness) и делает пруф. Это тяжело: секунды или минуты на GPU/CPU.
Verifier получает пруф, публичные входы и verifying key, и отвечает «да» или «нет». Это дёшево: миллисекунды и сотни тысяч газа.
fe-zk — это именно verifier. Пруфы делают внешние тулзы, а мы проверяем их на чейне. Поэтому верификатор и есть граница доверия: если он ошибся, контракт поверит поддельному пруфу.
Свойства, которые нельзя сломать
Completeness: честный пруф всегда принимается.
Soundness: без знания witness нельзя сделать пруф, который примут.
Zero-knowledge: пруф ничего не говорит о witness.
Верификатор отвечает за первые два. Почти все реальные взломы ZK-систем — это soundness-баги именно в верификаторе, а не в математике.
SNARKи и STARKи
SNARK (Groth16, PLONK, halo2-KZG) |
STARK (FRI, Plonky3) |
|
|---|---|---|
Криптография |
эллиптические кривые, спаривания |
только хеши |
Setup |
доверенная церемония (powers of tau) |
прозрачный, без церемонии |
Размер пруфа |
128 байт – пара KB |
десятки KB |
Газ проверки |
200k–400k |
миллионы |
Постквантовость |
нет |
да (хеши) |
Поле |
BN254, 254 бита |
KoalaBear/BabyBear, 31 бит |
SNARK дешёвый на EVM, потому что у Ethereum есть precompile для кривой BN254: сложение (0x06), умножение (0x07) и спаривание (0x08). STARK дорогой, потому что precompile для его полей и хешей нет, всё считается опкодами ВМ.
Спаривание за одну минуту
Спаривание (pairing) — это функция e(P, Q), которая берёт точку из группы G1 и точку из G2 и выдаёт элемент третьей группы. Главное свойство — билинейность:
e(a·P, b·Q) = e(P, Q)^(a·b)
Это позволяет проверить равенство «произведений скрытых чисел», не зная самих чисел. Groth16 сводит всю проверку к одному уравнению из четырёх спариваний, и precompile 0x08 проверяет его одним вызовом.
KZG-коммитменты
PLONK и halo2 строятся на KZG. Prover коммитит многочлен f(X) одной точкой кривой [f(τ)], где τ — секрет церемонии, который никто не знает. Потом он открывает многочлен в любой точке z: показывает y = f(z) и короткое доказательство. Верификатор проверяет открытие одним спариванием. Вся PLONK-проверка — это «многочлены схемы удовлетворяют уравнениям в случайной точке», и эта точка берётся из транскрипта.
Fiat–Shamir
Интерактивный протокол — это когда верификатор шлёт случайные челленджи. На чейне диалога нет. Поэтому челленджи считаются как хеш от всего, что prover уже прислал. Если в хеш не попало что-то важное, prover может подобрать это «что-то» под уже известный челлендж и подделать пруф. Это и есть уязвимость Frozen Heart, о ней ниже.
Какие системы и библиотеки поддерживает fe-zk
Каждая система доказательств — это своя экосистема тулзов. Верификатор на чейне должен совпадать с тулзой бит в бит: формат ключа, порядок координат, транскрипт.
circom + snarkjs
circom — DSL для описания схем, де-факто стандарт в Ethereum-ZK. snarkjs — JS-библиотека от iden3, которая из схемы circom делает ключи и пруфы Groth16 и PLONK, а также экспортирует Solidity-верификатор.
В fe-zk: fe-zk-gen groth16 --snarkjs vk.json и fe-zk-gen plonk. Подвох snarkjs: в JSON-пруфе координаты G2 идут в одном порядке, а в Solidity calldata — в переставленном. Сгенерированный контракт переставляет их обратно, и это покрыто тестом.
arkworks
arkworks — набор Rust-крейтов для ZK: поля, кривые, Groth16. Используется в куче проектов как эталон. Его формат ключа отличается от snarkjs сериализацией.
В fe-zk: fe-zk-gen groth16 --arkworks. Сам генератор проверяет ключи через ark-bn254, то есть arkworks у нас ещё и независимый валидатор.
gnark
gnark — Go-библиотека от Consensys, одна из самых быстрых. Её PLONK отличается от snarkjs: транскрипт на SHA-256 с текстовыми метками ("gamma", "beta", "alpha", "zeta"), другой порядок абсорбции и опциональные BSB22-коммитменты. Это расширение, которое позволяет схеме коммитить промежуточные значения.
В fe-zk: fe-zk-gen gnark, ABI Verify(bytes,uint256[]), совместимый с Solidity-верификатором самого gnark. Адаптер verify_calldata отклоняет пруф и входы любой длины, кроме той, что задана ключом.
halo2 (PSE)
halo2 изначально сделан Zcash на кривых Pasta с IPA. Форк PSE (Privacy & Scaling Explorations) перевёл его на BN254 и KZG, чтобы проверять на EVM. Схемы halo2 — это PLONKish-таблицы с кастомными гейтами и lookup-аргументами. snark-verifier генерирует для них Solidity.
Открытия многочленов в halo2-KZG бывают двух видов:
GWC (Gabizon–Williamson–Ciobotaru): по одному открытию на точку, проще;
SHPLONK: все точки батчатся в одно открытие, дешевле по газу.
В fe-zk поддержаны оба: fe-zk-gen halo2. Метаданные схемы извлекаются так же, как это делает snark-verifier.
KZG и EIP-4844
Отдельный модуль kzg проверяет одиночные и батч-открытия (GWC и SHPLONK, 162,122 газа для SHPLONK). Там же лежит обёртка над precompile 0x0a из EIP-4844, через который проверяют блобы Ethereum. Его формат входа строгий: 192 байта, версионный хеш в начале. Обёртка проверяет и длину, и магическую константу ответа.
Plonky3
Plonky3 — Rust-тулкит от Polygon для STARK на маленьких полях (KoalaBear, BabyBear, Mersenne31). Схемы там описываются как AIR (Algebraic Intermediate Representation): таблица трейса и полиномиальные ограничения между соседними строками. Коммитменты — Merkle-деревья, проверка низкой степени — FRI.
В fe-zk: verify<A: Air> для uni-stark на KoalaBear, Ext4 и Keccak-Merkle. Подробности ниже.
Semaphore
Semaphore — протокол анонимного членства от PSE поверх circom и Groth16. Пользователь доказывает «я в группе» и публикует nullifier, чтобы не проголосовать дважды. Группа хранится в LeanIMT — инкрементальном Merkle-дереве на Poseidon.
В fe-zk: ингот fe_zk_semaphore с ключами публичной церемонии глубин 1…10 и кит fe_zk::anon: LeanImt, корни которого совпадают с @semaphore-protocol/group 4.x, и Nullifiers.
BLS12-381
Вторая популярная кривая, на ней Ethereum consensus и Zcash. EIP-2537 добавил для неё precompile 0x0b–0x11 в Prague. В fe-zk лежат проверенные обёртки над ними.
Где на самом деле ломаются верификаторы
Математика Groth16 занимает одну строку:
e(-A, B) · e(α, β) · e(vk_x, γ) · e(C, δ) == 1, vk_x = IC₀ + Σ xᵢ·ICᵢ
Реализацию проверяют аудиторы, тесты проходят, а через полгода выясняется, что:
Публичный вход не проверен на
< r.xиx + rдают одну и ту же точкуxᵢ·ICᵢ. Еслиx— nullifier, получаем двойную трату.Точка не проверена на кривой. Precompile
ecAddотклонит мусор, но не все пути до него доходят. А для G2 нужна ещё и отдельная проверка подгруппы.Транскрипт Fiat–Shamir не включает какой-то вход. Это как раз класс Frozen Heart: челлендж не зависит от входа, и пруф подделывается.
Результат precompile не проверен по длине. Вызов адреса без кода возвращает success и пустой ответ. Читаем нули и считаем, что спаривание прошло.
Нехватка газа выглядит как невалидный пруф. Атакующий подрезает газ, precompile падает, верификатор отвечает
falseна честный пруф.
В Solidity каждое из этих правил — соглашение. uint256 остаётся uint256, и ничто не мешает передать непроверенное значение туда, где нужен элемент поля. Защищают только ревью и дисциплина.
Моя главная идея: превратить правила в свойства типов, чтобы нарушение было ошибкой компиляции, а не находкой аудитора.
Коротко про язык Fe
Fe — язык смарт-контрактов под EVM. Синтаксис похож на Rust, но язык свой. Для нас важно, что в нём есть:
трейты с ассоциированными константами;
дженерики и const generics, в том числе по
u256;const fnиstatic_assert, которые исполняются в компиляторе;приватные поля структур;
эффекты
uses (...): функция объявляет, к чему у неё есть доступ (storage, вызовы, контекст);бэкенды Sonatina и Yul.
Компилятор написан на Rust. Я собирал Fe 26.5.0 из исходников для теста покрытия разных CPU через Proxmox. Пребилд не встал на ВМ с отключенной AVX-инструкцией.
Архитектура

Архитектура fe-zk
Пойдём снизу вверх.
Слой 1: одно поле на всех
Трейт Field из src/field.fe:
pub trait Field { const MODULUS: u256 fn zero() -> Self fn one() -> Self fn is_canonical(_ v: u256) -> bool /// The element `v`, or `None` if `v` is not canonical. Use this for untrusted input. fn from_canonical(_ v: u256) -> Option<Self> /// `v mod MODULUS`. Silent reduction: never use it on untrusted input. fn reduce(_ v: u256) -> Self fn add(self, _ other: Self) -> Self fn mul(self, _ other: Self) -> Self fn inv(self) -> Option<Self> // ... }
Реализация одна: impl<const P: u256> Field for Fp<P>. Модуль — параметр типа, поэтому Fp<BN254_R>, Fp<KOALABEAR_P> и Fp<GOLDILOCKS_P> — разные типы. Перепутать элементы двух полей нельзя, это ошибка типов.
Montgomery-форма не нужна. addmod и mulmod в EVM работают с 512-битными промежуточными значениями и стоят по 8 газа. Один и тот же код корректен и для 254-битных полей BN254, и для 31-битного KoalaBear.
Поверх Field написаны хеши. Poseidon2 существует в одном экземпляре:
fn permute_generic<F: Field + Copy, const T: usize, const NE: usize, const NI: usize>(...)
Это и BN254 с t = 3, и KoalaBear с t = 16 под константы Plonky3. Merkle-путь дженерик и по хешу, и по типу узла: merkle_root<H: Compression<D>, D: Copy, const N: usize>. Fe мономорфизирует дженерики, поэтому абстракция ничего не стоит в самом рантайме.
Векторы для хешей взяты из circomlibjs, Plonky3 и HorizenLabs.
Слой 2: непроверенную точку нельзя создать
У Fp, G1 и G2 приватные поля. Снаружи модуля есть только два входа: from_canonical / from_coords, которые возвращают Option, и явный reduce для констант и выходов хешей. Отдельная проба подтверждает, что компилятор отклоняет Fr { v: 100 }.
С G2 всё тоньше. Проверка подгруппы G2 на EVM стоит около 750k газа. Precompile спаривания из EIP-197 и так её выполняет. Тратить газ дважды глупо, но и оставлять «полупроверенную» точку в общем типе опасно. Поэтому точка G2 из пруфа получает отдельный тип G2Proof:

Путь данных из calldata до спаривания
У G2Proof нет конверсии в G2 и нет групповых операций. Потребить его можно только в pairing_check_proof / pairing_try_proof, то есть там, где precompile досмотрит подгруппу. Тест с точкой на твисте вне подгруппы (вектор из py_ecc) подтверждает, что пруф отклоняется.
Слой 3: precompile и правило отказа
Каждый вызов precompile проверяет три вещи: флаг успеха, длину ответа и точное значение. Для спаривания ответ должен быть ровно 1, а не «не ноль».
// src/ec/precompile.fe if r.success() { assert(r.returndata_len() == out_len) } r.success()
Перед каждым вызовом верификатор проверяет остаток газа:
pub fn require_gas(_ cap: u256) uses (ctx: Ctx) { assert(ctx.gas() >= cap + GAS_MARGIN) }

Каждый вызов precompile: газ, флаг, длина, значение
Отсюда правило отказа: невалидный пруф — это false, нехватка газа — revert. Подрезанный газ больше не превращает честный пруф в невалидный.
Сигнатура uses (call: Call, ctx: Ctx) здесь не для красоты. Верификатор может делать static call и читать газ, но не может писать в storage и слать value. Проверяет компилятор: без эффекта storage функция физически не тронет хранилище.
Groth16 целиком
Ядро верификатора короче, чем объяснение к нему:
pub fn verify<const N: usize>(_ vk: Vk<N>, _ proof: Proof, _ inputs: [Bn254Fr; N]) -> bool uses (call: Call, ctx: Ctx) { if !vk.usable { return false } var vk_x = vk.ic0 var i: usize = 0 while i < N { vk_x = g1_add(vk_x, g1_mul(vk.ic[i], inputs[i])) i += 1 } pairing_try_proof( [proof.a.neg(), vk.alpha, vk_x, proof.c], [ proof.b, G2Proof::from_g2(vk.beta), G2Proof::from_g2(vk.gamma), G2Proof::from_g2(vk.delta), ], ) }
Обратите внимание на типы:
inputs: [Bn254Fr; N]— неканонический вход сюда не попадёт, он отсеян вverify_calldataчерезfrom_canonical;N— const generic: длина входов зашита в тип ключа, дописать или выкинуть публичный вход нельзя;proof.bужеG2Proof, ключевые точки поднимаются вG2Proofявно.
Semaphore поддерживает глубины дерева от 1 до 10, у ключей разное число входов. Обслуживает их одна функция verify_with<const N: usize>.
Отдельный момент: Groth16 malleable. Из валидного пруфа можно сделать другой валидный. Поэтому в примерах пруф и его хеш никогда не используются как nullifier, это прописано в SAFETY.md.
Генератор и ключ, который проверяет компилятор
fe-zk-gen читает ключ snarkjs, arkworks, gnark или halo2, проверяет его через ark-bn254 и эмитит Fe-ингот. Флага «пропустить проверки» нет — генератор просто откажется.

Конвейер fe-zk-gen: ключ проверяется дважды, генератором и компилятором
Самое интересное начинается дальше. Функция валидности точки в Fe — const fn, поэтому сгенерированный контракт перепроверяет свой ключ на этапе компиляции:
// Verifying key, validated by fe-zk-gen and re-validated at compile time. static_assert(g1_is_valid(ALPHA_X, ALPHA_Y)) static_assert(!VK_ALPHA.is_infinity()) static_assert(g2_is_valid(BETA_X0, BETA_X1, BETA_Y0, BETA_Y1)) static_assert(!VK_BETA.is_infinity()) const VK_ALPHA: G1 = G1::from_coords_or_infinity(ALPHA_X, ALPHA_Y) const VK_BETA: G2 = G2::from_coords_or_infinity(BETA_X0, BETA_X1, BETA_Y0, BETA_Y1)
Внутри g2_is_valid — проверка подгруппы G2, цикл из 254 итераций mulmod. Он исполняется в компиляторе. Если кто-то руками поправит одну константу ключа, сборка упадёт:
error[8-0081]: static assertion failed
Это закреплено тестом генератора corrupted_key_constant_fails_to_compile.
Вторая защита — from_coords_or_infinity. Для невалидной точки она даёт бесконечность, а ключ с бесконечностью в α, β, γ или δ помечен как непригодный, и verify возвращает false. Даже если удалить static_assert, непроверенная точка в ключе не появится.
Эффект на газ оказался приятным бонусом. Ключ теперь — набор констант, которые в рантайме стоят по 2 газа. Построение ключа PLONK подешевело с 1.05M газа до 673, vk() у halo2 — с 1.51M до 1.3k. Цена — около 20 секунд компиляции на три проверки подгруппы G2.
И главное: это та же самая функция, что проверяет точки из calldata в рантайме. Определение валидности существует в одном месте.
Вместе с контрактом генератор эмитит тесты: один валидный пруф и батарею невалидных — подменённый элемент, вход ≥ r, координата ≥ q, точка вне кривой, точка G2 вне подгруппы, переставленные входы. Каждое правило безопасности имеет тест, который падает без этого правила.
PLONK и транскрипт
В PLONK самое опасное — транскрипт Fiat–Shamir. Порядок абсорбции должен совпадать с эталонным верификатором байт в байт, и в него должно входить всё: digest ключа, все публичные входы, все коммитменты.
Для snarkjs и gnark транскрипты разные. gnark использует SHA-256 с доменными метками и опциональные BSB22-коммитменты, snarkjs — Keccak. Я переносил их построчно и для каждого написал тест: изменение любого входа транскрипта меняет челлендж. Это прямая защита от Frozen Heart.
Самый дорогой элемент PLONK — инверсии в поле. Возведение в степень r - 2 циклом стоит около 25k газа. Через precompile modexp (0x05) — около 1.4k:
/// `1 / a` in the BN254 scalar field through the modexp precompile (0x05). /// Success flag, returned length (32) and canonical result are checked (rule 6). pub fn inv_modexp(_ a: Bn254Fr) -> Option<Bn254Fr> uses (call: Call, ctx: Ctx)
Эта функция общая для PLONK, gnark и KZG. После этой и ещё пары оптимизаций газ относительно Solidity-верификаторов тех же тулов на одном пруфе:
Верификатор |
Fe / Solidity |
|---|---|
Groth16 (snarkjs) |
1.02–1.03x |
PLONK (snarkjs) |
1.05x |
PLONK (gnark) |
1.10–1.11x |
halo2-KZG |
1.17x |
Почти паритет. При этом в Fe-версии больше проверок, чем в эталонном Solidity.
FRI/STARK: самое тяжёлое
Верификатор для пруфов Plonky3 uni-stark: поле KoalaBear, расширение степени 4, Merkle-коммитменты на Keccak, arity 2. Готового EVM-верификатора пруфов Plonky3 я не нашёл ни на одном языке.

Проверка STARK-пруфа: ограничения AIR в точке ζ и FRI
Сначала верификатор умел только Fibonacci. Потом я вынес AIR в трейт, и верификатор стал verify<A: Air>. AIR на Fe переписывается с Rust-версии Plonky3 построчно:
impl Air for FibonacciAir { const WIDTH: u256 = 2 const NUM_PUBLIC: u256 = 3 const MAX_DEGREE: u256 = 2 fn eval(_ ctx: AirCtx) -> E { let l0 = ctx.local[0] let l1 = ctx.local[1] let n0 = ctx.next[0] let n1 = ctx.next[1] var acc = E::zero() acc = ctx.assert_first(acc, l0.sub(ctx.public_value(0))) acc = ctx.assert_first(acc, l1.sub(ctx.public_value(1))) acc = ctx.assert_transition(acc, l1.sub(n0)) acc = ctx.assert_transition(acc, l0.add(l1).sub(n1)) ctx.assert_last(acc, l1.sub(ctx.public_value(2))) } }
assert_transition и прочие делают ровно то, что VerifierConstraintFolder в Plonky3: acc = acc · α + selector · constraint. Второй AIR, MulAir на 6 колонок, проходит тот же набор тестов. Пруфы для обоих сделаны настоящим Plonky3 0.4.2.
Ограничения я сделал явными. Поддерживается одна quotient-чанка, то есть ограничения степени не выше 2. AIR с MAX_DEGREE > 2 верификатор отклоняет, а не проверяет неправильно.
Как я снял 70 % газа
Первая рабочая версия стоила 4.67M газа исполнения. Профилирование показало, что дорогая не криптография, а скрытые расходы компилятора:
Struct с inline-массивами копируется на каждом вызове. Передача по значению — это копия всех полей. Решение: поля
MemArray.Индексация
MemArrayстоит около 100 газа. Там bounds check и checked-умножение. Решение: одна проверка диапазона, потомoffset_bytes(ptr, i * 32)под#[arithmetic(unchecked)].Циклы не разворачиваются. 100–400 газа на итерацию при
-O1. Горячие места я развернул вручную.
Итог — 1.41M газа исполнения на пруфе Fibonacci (2^10 строк, 100 бит conjectured security), полная транзакция — 2.86M. Контракт весит 12.9 KB. Для STARK на EVM это нормально, хотя Groth16 всё равно дешевле в разы. Цифры честно лежат в docs/GAS.md вместе с командой, которая их считает.
Как я проверял
Правило одно: векторы только из независимых эталонов, никогда из собственного кода.
Компонент |
Эталон |
|---|---|
Poseidon |
circomlibjs |
Poseidon2 |
Plonky3, HorizenLabs |
Groth16 |
snarkjs, arkworks |
PLONK |
snarkjs, gnark |
halo2-KZG |
PSE halo2 |
FRI/STARK |
Plonky3 0.4.2 |
G2 вне подгруппы |
py_ecc |
Скрипты, которые генерируют векторы, лежат в репозитории вместе с версиями тулов. Церемониальный материал — настоящий PSE Perpetual Powers of Tau, скачивается по закреплённому хешу.
Поверх этого есть дифференциальный тест: один и тот же набор пруфов, валидных и испорченных, гоняется через наш верификатор и через эталонный. Ответы должны совпасть все.
На реальных данных:
Semaphore v4: ключи публичной церемонии для глубин 1…10, пруфы из официального SDK. Результаты сверены с
SemaphoreVerifier.solсамого Semaphore.Tornado Cash: верификатор
withdrawпринимает настоящие пруфы с mainnet. Это только верификатор, миксера в репозитории нет.zk Game of Life: поле 16×16 упаковано в биты
u256, шаг на чейне делается побитовыми сумматорами без цикла по клеткам. Отдельно Groth16-пруф 512 поколений. Один шаг на чейне стоит 657 газа. Проверка пруфа 512 поколений — 208,210 газа против 271,686 газа за прогон тех же 512 шагов на чейне.
Итого 493 теста на Fe, CI в четыре джобы. Все правила безопасности сведены в docs/SAFETY.md: правило, файл и строка, где оно применяется, и тест, который без него падает.
Что я нашёл в самом Fe
Криптография быстро упирается в края компилятора. Я записал около десятка проблем и отправил в апстрим 3 PR и 2 issue:
#2061 — обёртки precompile с фиксированным выводом в
std::evm::cryptoвозвращалиOkс нулями, если precompile отсутствует. Для криптографии это ровно пункт 4 из начала статьи.#2062 — парсер принимал
var s: u256 = aи блок на следующей строке за struct literala { ... }.#2063 —
fe fmtпереносил хвостовой комментарий внутрь списка аргументов.#2064 — нет raw staticcall со статическим буфером, теряем около 200 газа на каждый вызов precompile.
#2065 — в const-контексте нельзя
assertи методыOption.
Каждый PR идёт с регрессионным тестом и проходит тесты Fe.
Мелочи, о которые спотыкаешься: allow_unsafe = true нужно ставить у зависимого ингота; абсолютные пути зависимостей не работают; оптимизатор выкидывает неиспользуемые результаты, поэтому замеры газа надо отдавать в event.
Почему Fe крутой
Не из-за синтаксиса. Fe позволяет перенести правила безопасности из ревью в компилятор:
Правило |
Solidity |
Fe |
|---|---|---|
вход |
|
|
точка на кривой |
конвенция |
приватные поля, только проверяющий конструктор |
G2 только в спаривание |
комментарий |
тип |
ключ валиден |
надежда и аудит |
|
число входов |
проверка длины |
|
верификатор чистый |
|
|
один хеш на все поля |
копипаста |
|
В Solidity каждая строка левой колонки — дисциплина. В Fe это ошибка компиляции. И всё это почти без потерь в газе: Groth16 медленнее эталона на 2–3 %.
Что приятно удивило: ассоциированные константы в трейтах, const generics по u256, const fn, которая честно гоняет 254 итерации mulmod в компиляторе, и проверка эффектов. Что пока сыро: оптимизатор (не разворачивает циклы, дорогая индексация) и мелкие баги парсера и форматтера. Половину из них я уже отправил апстрим.
Ограничения
Не успел следующее:
Аудита нет. Это исследовательский код, без аудита в проде не используйте, как и сам Fe.
FRI привязан к одному конфигу Plonky3: KoalaBear, Keccak-Merkle, арность 2, ограничения степени до 2.
Рекурсии нет.
halo2 дороже эталона на 17 %, есть куда оптимизировать.
Что дальше
Код открыт под Apache-2.0: github.com/0xitsss/fe-zk. Начать можно с scripts/demo.sh и таблицы «For judges: one screen» в README.
В планах Poseidon2-Merkle для FRI, больше конфигов Plonky3, quotient из нескольких чанков и поддержка библиотеки, если сообществу Fe она окажется нужна. Если хотите в будущем писать на Fe и вам нужна проверка ZK-пруфов — приходите ко мне в issues, разберёмся и поработаем вместе.
0xInnominatus
Статья крутая, но практически невозможно читать из‑за оборотов LLM (прочитать через боль и слёзы можно только в том случае, если прямо очень интересна тема). ИМХО стоит добавить сноску с объяснением того, что за язык такой Fe, так как многие не идут дальше Solidity и не знают про языки Huff, Yul, Fe et cetera, и что они вообще тоже для разработки под EVM. И ещё в список хабов можно добавить хаб Solidity (я думаю там больше ЦА, чем во всех указанных хабах).
0xItsss Автор
Спасибо за фидбек! Да, статью немного упрощу, а вот насчет хаба не знал;)