nevvt

BLS-подписанный корень Меркла — это как раз тот случай, когда результат Ньютона может выглядеть более «доделанным», чем он есть на самом деле.

Одна компактная фиксация. Одна подпись. Один аккуратный объект в вершине пути.

Очень легко уважать.

Может, слишком легко.

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

Он сжимает беспорядок.

Все листья снизу исчезают в одно значение.

Проверки политики. Вывод оператора. Подробности оценки. Объекты результата.

Экран перестаёт показывать гору.

Он показывает корень.

И как только этот корень подписан BLS, всё начинает ощущаться «устроенным».

Вот на что стоит притормозить.

BLS-подписанный корень Меркла может доказать что-то важное.

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

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

Он может дать Ньютону компактный способ закрепить множество оценённых объектов в одной точке подписанного доказательства.

Это имеет значение.

Но корень всё ещё является границей.

Не пледом.

Он доказывает приверженность множеству.

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

Вот где сидит опасность.

Ревьюер видит BLS-подпись. Корень Меркла совпадает. Набор операторов
выглядит согласованным. Результат транзакции кажется сложнее оспорить.

Так нижний слой получает меньше внимания.

Какой лист? Какой policy CID? Какая оценка оператора? Какой атрибут идентичности? Какой риск-вход? Какой именно результат на самом деле принадлежит этому намерению?

Он всё ещё там.

Просто спрятан под элегантностью корня.

Именно поэтому этот компонент интересен в Ньютоне.

Корень ценен, потому что сжимает доказательство.

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

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

Он не должен делать результат проще верить, не открывая путь.

Потому что самая опасная версия верификации — это не «отсутствующее доказательство».

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

@NewtonProtocol #Nevvt $NEWT $TLM $LAB
#SouthKoreanStocksRise5%
#KOSPIOpensUp1.41%

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

Но это было не так.

То, что осталось со мной, — это мир вокруг правила.

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

Это должно сделать систему ощущающейся более безопасной.

Но это также создает ловушку.

Потому что читаемое правило всё равно может оценить неверный мир.

Вот к этой мысли я возвращался снова и снова. #Nevvt

Не в том, говорит ли политика «разрешить».
Не в том, говорит ли она «запретить».
А в том, что именно было показано политике до того, как она приняла решение.

Кто-то может прочитать правило Rego внутри Newton и решить, что граница очевидна.

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

Читаемо. Поддается аудиту. Почти спокойно.

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

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

Это и есть неприятная часть.

Правило не было сломано.

Оно оценило ровно то, что ему дали.

Newton Protocol становится особенно интересным здесь, потому что Rego / OPA делают политику исполняемой, но при этом делают и границу оценки видимой — если знать, куда смотреть.

Политика — это не всё решение.

Это лишь линза.

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

Вот на какой риск я смотрю.

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

Правило может быть корректным.

Мир может быть неверным.

Именно в этом зазоре политика Newton становится особенно важной для наблюдения.

@NewtonProtocol $NEWT $LAB $VANRY #Newt

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

Но нет.

То, что действительно изменило экран для меня, — это агрегированная подпись BLS.

Один объект.
Одна чистая проверка.
Одна проверка валидации.

Это должно было сделать систему проще.

Но не сделало.

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

Вот на что я продолжал смотреть.

Не на политику.
Не на транзакцию.
На подпись.

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

И технически — да: одна часть стала простой.

Проверка сжата.
Смарт-контракт может проверять её эффективно.
Результат имеет чистую криптографическую «поверхность».

Но это не то же самое, что простой процесс доверия.

Именно в этом для меня становится интересным Newton Protocol.

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

Но он не стирает то, что должно было произойти до этого.

Операторы всё равно оценивали намерение. Кворум с учетом долей по-прежнему имел значение. Согласие по политике всё равно должно было сформироваться.
За результатом всё равно должен был стоять достаточный вес — правильного распределения.

Эта разграниченность важна.

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

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

Вот тот риск, за которым я слежу.

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

Подпись существует, чтобы сделать верификацию эффективной.

Вопрос в том, помнят ли пользователи, что именно она сжала.

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

Именно это условие я отслеживаю в Newton Protocol.

@NewtonProtocol #Nevvt $NEWT
$EPIC
$HMSTR