NewbieToNode

@SignOfficial

Я ожидал, что этот отзыв пройдет.

Но этого не произошло.

Нет ошибки.

Просто... никаких изменений.

Те же учетные данные.

Все еще действительны.

Точно так же, как будто ничего не было вызвано.

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

Запустил это снова.

Ничего не изменилось.

Поэтому я проверил аттестатора.

Совпадает.

Затем я проверил схему.

Другой адрес.

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

Я снова попытался со стороны аттестатора.

Все еще ничего.

Даже не выглядело, как будто это пыталось.

Я переключил это.

Вызвано со стороны схемы.

На этот раз это прошло.

Вот где это изменилось.

Аттестатор мог это выдать.

Но не мог отменить это.

Регистрант мог.

Я запустил еще одно.

Другие учетные данные.

То же поведение.

Выдано в одном месте.

Контролировалось в другом.

Я остался на этом дольше, чем планировал.

Потому что ничего не проваливалось.

Все просто... игнорировало неправильного вызывающего.

Я продолжаю возвращаться к этому как к разделенной власти.

Сущность, создающая учетные данные...

не является той, которая может его отключить.

Снаружи это выглядит как контроль эмитента.

Внутри контроль находится совершенно в другом месте.

Две власти.

Только одна видима, когда создаются учетные данные.

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

не просто той, которая определила схему, под которой они существуют.

Потому что, как только они разделены...

отзыв перестает быть действием.

И становится зависимостью.

Так что настоящий вопрос заключается в этом.

Когда что-то нужно быстро отключить...

на кого вы на самом деле ждете?

#SignDigitalSovereignInfra #Sign

@SignOfficial

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

Аттестатор выставил значение дальше.

Креденциал не сделал этого.

Думал, что выбрал не тот.

Запустил снова.

Та же аттестация.

Тот же schemaId.

Все еще короче.

Это не сидело хорошо.

Поэтому я продолжал это.

Что было введено...

и что появилось...

не были одинаковыми.

Ничего не провалилось.

Нет отказа.

Нет предупреждения.

Это разрешилось чисто.

Вот тогда я снова посмотрел на схему.

"maxValidFor" был ниже, чем то, что было представлено.

Он не отвергал ввод.

Он его обрезал.

Я попробовал снова.

Другой аттестатор.

Та же схема.

Тот же результат.

Вот тогда это щелкнуло.

Аттестатор не определяет креденциал.

Они ведут переговоры со схемой.

А схема решает, что на самом деле выживает.

Снаружи это выглядит так, будто аттестатор установил значение.

Внутри часть этого никогда не проходит.

Нет сигнала.

Нет следа.

Просто чистое итоговое состояние.

Две разные подачи.

Тот же креденциал.

Я продолжаю возвращаться к этому как к иллюзии переопределения аттестатора.

Сдается, что контроль находится у эмитента.

Но окончательная форма уже ограничена где-то еще.

$SIGN имеет значение только если ограничения схемы, такие как "maxValidFor", не тихо изменяют то, что было представлено...

но четко показывают эту границу.

Потому что как только входные данные изменяются без видимости...

источник истины смещается.

И вы не видите, как это происходит.

Поэтому настоящий вопрос становится таким.

Если часть ввода никогда не выживает в схеме...

что именно вы проверяете?

#SignDigitalSovereignInfra #Sign

@SignOfficial

Я раньше следил за "linkedAttestationId".

Ожидал, что это разрешится.

Но этого не произошло.

Думал, что выбрал неправильный.

Запустил это снова.

Тот же ID.

По-прежнему пусто.

Это не имело смысла.

Кажется, я упустил что-то очевидное.

Поэтому я проверил реестр напрямую.

Там тоже ничего.

Подождал.

Попробовал снова.

Никаких изменений.

Но учетные данные...

были в порядке.

Они проверялись без проблем.

Никаких ошибок.

Никаких предупреждений.

Вот где все изменилось.

Ссылка отсутствовала.

Учетные данные не были.

Поэтому я попробовал другой.

Разная аттестация.

Та же схема.

"linkedAttestationId" установлен.

Ничего за ним.

Нет возврата.

Нет сбоя.

Нет сигналов о том, что что-то не так.

Вот тогда я перестал искать запись.

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

Ссылка никогда не включается в это.

Проверка не следует за ней.

Не ждет ее.

Не заботится о том, разрешится ли это.

Учетные данные стоят сами по себе.

На что они указывают...

никогда не привлекается.

Вот тогда это стало понятно.

Это не ломалось.

Это игнорировалось.

Перспектива призрака.

Ссылка, которая существует...

без необходимости разрешать.

Снаружи...

все выглядит завершенным.

Учетные данные проверяются.

Структура держится.

Но связь...

не принуждается.

Вот где это становится рискованным.

Система видит ссылку...

и предполагает непрерывность.

Но ничто не гарантирует этого.

Ничто не доказывает это.

Ничто не связывает это.

Два учетных данных могут выглядеть связанными.

Ничто на самом деле не связывает их вместе.

И поскольку проверка никогда не проверяет...

нет сигнала о том, что что-то отсутствует.

$SIGN имеет значение только если ссылки, такие как "linkedAttestationId", необходимо разрешить...

а не просто существовать.

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

структура перестает означать связь.

Так что реальный вопрос становится таким.

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

без чего-либо там...

что именно система считает связанным?

#SignDigitalSovereignInfra #Sign

@SignOfficial

Я проверял учетные данные ранее.

Я предположил, что удостоверяющий является источником истины.

Затем я посмотрел на схему.

Другой адрес.

`registrant` в схеме.
`attester` в учетных данных.

Не одно и то же.

Это не имело смысла.

Так что я взял еще одну.

Затем еще одну.

Разные схемы.
Разные удостоверяющие.

Такой же разрыв.

В тот момент я подумал, что что-то упустил.

Некоторую связь между ними.

Что-то, связывающее эмитента с правилами.

Не смог найти это.

Учетные данные пришли от удостоверяющего.

Но правила не пришли.

Я проследил это еще дальше.

Схема стоит там первой.

Зарегистрирована один раз.

Затем повторно используется.

Снова и снова.

Любой, кто эмитирует под ней...

не определяет ее.

Вот где это перевернулось.

Удостоверяющий контролирует выпуск.

Регистрант контролирует, что вообще означает выпуск.

Две разные власти.

Нет видимой границы между ними.

Вы читаете учетные данные и доверяете удостоверяющему...

но они не определяли правила за этим.

И ничего в потоке не говорит вам об этом.

Это просто выглядит действительным.

Вот где это начинает становиться неудобным.

Если схема изменится...
удостоверяющий не может остановить это.

Если регистрант исчезнет...
правила не уйдут с ними.

Так что то, чему вы доверяете...

и то, что на самом деле определяет учетные данные...

не одно и то же.

Я продолжаю возвращаться к этому как к разделению власти.

Не совместно.

Не слоисто.

Разделено.

$SIGN важно только если система, в которой `registrant` и `attester` разделены, может поддерживать стабильные правила учетных данных...

even when the issuer doesn’t control them.

Потому что как только этот разрыв имеет значение...

больше нет единого источника истины.

Так что настоящий вопрос становится таким.

Когда эмитент и создатель правил не одно и то же...

что именно вы доверяете, когда проверяете?

#SignDigitalSovereignInfra #Sign

@SignOfficial

Я перезагрузил ту же аттестацию, и данные изменились.

Та же `dataLocation`.

Разное содержание.

Я проверил это снова.

Тот же указатель.

Все еще другое.

Так что я извлек временную метку.

`attestTimestamp`

Старше, чем то, что я сейчас видел.

Я подумал, что что-то перепутал.

Так что я попробовал другой.

Разная аттестация.

Та же схема.

То же место.

Новые данные.

Вот тогда это перестало казаться ошибкой.

Аттестация подтверждена.

Чисто.

Ничего не провалилось.

Ничего не помечено.

Но то, к чему это свелось, не совпадало с тем, что было, когда это было выдано.

Я продолжал.

Больше аттестаций с использованием оффчейн `dataLocation`.

То же поведение.

Ссылка остается фиксированной.

Содержание за ней смещается.

И система рассматривает это как одно и то же.

Я продолжаю возвращаться к этому.

Смещение указателя.

Система закрепляет местоположение…

а не состояние данных на `attestTimestamp`.

Так что это все еще подтверждается.

Просто не против того, что на самом деле видел эмитент.

Вот в чем дело.

Удостоверение проходит…

но оно больше не доказывает то, против чего было выдано.

$SIGN имеет значение здесь только в том случае, если система, которая подтверждает против `dataLocation`, вместо состояния на `attestTimestamp`, все еще достаточна, когда эти два начинают расходиться в масштабе.

Потому что как только они расходятся…

ничего не ломается.

Ничего не проваливается.

Ничего не обновляется.

Это все еще подтверждается.

Так что настоящий вопрос становится таким.

Когда указатель остается стабильным, но данные изменяются…

что именно все еще подтверждает аттестация?

#SignDigitalSovereignInfra #Sign

@SignOfficial

Я пытался отозвать аттестацию ранее, и это не сработало.

Без ошибок.

Просто нет пути.

Я проверил это снова.

Все еще действительно.

Поэтому я поднялся на один уровень выше.

Схема.

`revocable = false`

Я запустил другую под той же схемой.

Разная аттестация.

Тот же результат.

Два удостоверения.

Ни одно из них не могло быть отозвано.

Вот тогда все изменилось.

Это не было неудачным отзывом.

Не было ничего для выполнения.

Удостоверение не было заблокировано после выдачи.

Оно было выдано таким образом.

Я продолжал.

Больше аттестаций.

Та же схема.

То же поведение.

Каждое из них могло быть выдано.

Ни одно из них не могло быть возвращено.

И ничего в аттестации не говорит вам об этом.

Вы видите это только тогда, когда пытаетесь отозвать...

и ничего не происходит.

Я продолжаю возвращаться к этому.

Блокировка отзыва.

Не задержка.

Не ограничение.

Просто отсутствие.

Возможность выдачи существует.

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

И это решение не принимается, когда создается удостоверение.

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

$SIGN имеет значение здесь только в том случае, если система, где `revocable = false` полностью исключает отзыв на уровне схемы, все еще достаточна, когда условия вокруг этих удостоверений начинают меняться.

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

ничто не ломается.

Ничто не дает сбой.

Ничто не обновляется.

Оно просто остается.

Таким образом, настоящий вопрос становится таким.

Если отзыв никогда не существовал в первую очередь...

что именно система ожидает адаптировать позже?

#SignDigitalSovereignInfra #Sign

@MidnightNetwork

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

Это вернуло чистый валидный результат.

Нет флагов.

Но в нем не было ничего, что говорило бы мне о том, что на самом деле было проверено.

Я снова прокрутил это, ожидая, что контекст появится где-то.

Ссылка. Что угодно.

Больше ничего не нашлось.

Подтверждение осталось.

Смысл - нет.

Мне пришлось проверить это дважды.

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

Она не сказала.

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

И начало казаться структурным.

Валидатор не подтверждает, что произошло.

Он подтверждает, что что-то валидное произошло.

Не понимая этого никогда.

Я продолжаю возвращаться к этому как к пробелу в понимании.

Где проверка остается целой.

Но понимание никогда не приходит.

Два совершенно разных базовых состояния могут пройти одно и то же подтверждение.

И ничего в выводе не отделяет их.
Это справедливо, пока объем невысок.

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

$NIGHT имеет значение только здесь, если этот слой проверки все еще может отделить то, что остается валидным, от того, что остается значимым, когда подтверждения начинают накапливаться.

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

Она сжимает различия в тот же результат.
Так что настоящим испытанием становится это.

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

#night #Night

@MidnightNetwork

Этим утром я просматривал компактный контракт, и что-то не сошлось.

Условие оценивалось как истинное.

Цепь велась так, будто её не существовало.

Нет ошибки.

Нет сбоя.

Просто... исчезло.

Я проверил входные данные.

Правильно.

Проверил условия.

Все еще истинно.

Но когда я проследил это через компиляцию, эта ветвь никогда не стала ограничениями.

Условный путь, зависящий от внешнего ввода, оценивался как истинный, но никогда не входил в цепь.

Не отклонено.

Не сломано.

Просто стерто.

Вот где это сломалось для меня.

Цепь не выполняет вашу логику.

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

Если что-то не может быть сведено к ограничениям, Compact не отклоняет это.

Он стирает это.

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

Не неправильная логика.

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

Что означает, что что-то может быть истинным...

и все еще быть непроверяемым.

И проверяющий никогда не узнает разницы.

Потому что с его точки зрения доказательство завершено.

Но завершено над чем?

Не над реальностью.

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

Вот где это начинает иметь значение.

Потому что теперь система может доказать корректность...

над неполной версией реальности.

$NIGHT имеет значение только если то, что Compact исключает, никогда не станет частью того, что проверяющий предполагает, что завершено.

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

Доказательство все равно пройдет.

Только истина исчезнет.

Так что реальный вопрос становится таким.

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

#night #Night

@SignOfficial

`attestTimestamp` соответствует `revokeTimestamp`.

Нет разрыва.

Это не должно было случиться.

Я поймал это, проверяя временные метки.

Я проверил еще одну.

Та же схема.

Другой эмитент.

Тот же результат.

Сначала казалось, что это связано с временем.

Как будто отзыв произошел сразу после выдачи.

Но этого не произошло.

Не было "после".

SIGN регистрирует оба события независимо.

Они просто совпали в один и тот же момент.

Что означает, что эта учетная запись никогда не имела действительного состояния.

Ни на мгновение.

Даже не на блок.

Что означает, что никогда не было состояния, которое могла бы прочитать какая-либо система.

Вот где это изменилось.

Это не была отозванная учетная запись.

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

Мгновенная недействительность.

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

Я следил за тем, как система с этим обращается.

Она разрешается.

Схема загружается.

Эмитент проверяется.

Все проходит на поверхности.

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

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

Вот где $SIGN начинает иметь значение.

$SIGN имеет значение только если протокол может различать аттестацию, где `attestTimestamp == revokeTimestamp`, и ту, которая стала недействительной позже.

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

Так что вопрос становится таким.

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

#SignDigitalSovereignInfra #Sign

@MidnightNetwork

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

Результат должен был следовать.

Но этого не произошло.

Нет сбоя.
Нет вывода.

Просто… ничего.

Я запустил это снова.

Те же входные данные.
Те же условия.

По-прежнему заблокировано.

В тот момент я подумал, что подключил что-то неправильно.

Поэтому я вернулся назад.

Строка за строкой.

Что-то казалось странным.

Путь не терпел неудачу.

Он просто никогда не прошел.

Вот тогда это и осенило.

Он не сломался.

Он исчез.

Только часть логики на самом деле выжила.

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

Не отклонено.

Просто… не поддающееся выражению.

Это другой тип границы.

Не время выполнения.
Не валидация.

Раньше обоих.

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

Потому что то, что компилируется, не является вашей полной логикой.

Это только та часть, которая может существовать как ограничения внутри цепи.

Все остальное просто никогда не появляется.

Что делает отладку странной.

Вы не преследуете ошибки.

Вы пытаетесь заметить, чего не хватает.

И вы видите это только если уже подозреваете это.

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

Потому что это не проявится, когда все чисто.

Это проявляется, когда что-то должно работать… и просто этого нет.

Так что настоящий вопрос становится таким.

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

#night #Night