King_Junaid1

Я всегда слышал, что криптография защищает системы, но никогда не останавливался, чтобы подумать о том, что она на самом деле защищает, просматривая @SignOfficial docs, которые начали казаться немного более понятными.

С поверхности кажется, что всё прикрыто.

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

Так что это выглядит безопасно.

Но эта безопасность сосредоточена на чем-то очень конкретном.

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

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

Потому что криптография не решает, что входит в #SignDigitalSovereignInfra систему.

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

И вот где происходит сдвиг.

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

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

Так что доверие на самом деле не исчезает.

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

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

И вот что делает безопасность в $SIGN менее абсолютной, чем кажется на первый взгляд.

Не неполной.

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

Теперь я пытаюсь понять,

Криптография действительно защищает истину внутри этих систем?

Или просто обеспечивает, что всё, что записывается, остается последовательным 🤔

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

Как, правда ли это? соответствует ли это? допустимо ли это?

Но чем больше я об этом думаю, тем меньше это похоже на то, что происходит в первую очередь.

Прежде чем какие-либо данные будут рассмотрены, система $SIGN проверяет что-то еще, понимает ли она то, что видит.

Следует ли это известному формату?
Соответствует ли это ожидаемой структуре?
Является ли это чем-то, что система вообще предназначена обрабатывать?

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

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

Не потому что они неверны.

Просто потому что они не подходят.

Это та часть, которую легко пропустить.

Мы думаем, что проверка - это просто показать истину, но это также касается совместимости.

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

Так что система на самом деле не начинает с вопроса, правда ли это?

Она начинает с вопроса, могу ли я с этим работать?

И это меняет то, как я смотрю на доверие в #SignDigitalSovereignInfra .
Потому что дело не только в том, что говорят данные.

Дело в том, распознает ли система, как это сказано.

И если эта часть не совпадает, остальное даже не получает шанса.

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

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

Потому что, как только распределение структурируется в последовательном порядке,

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

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

И это меняет то, как люди взаимодействуют с @SignOfficial

Вместо того чтобы реагировать на возможности,

они начинают предвосхищать их.

Что создает другой вид динамики.

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

Так что это больше не просто вопрос, кто что получает

это становится

как люди позиционируют себя до того, как это произойдет

Вот где вещи начинают казаться менее очевидными в #SignDigitalSovereignInfra

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

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

изначальный замысел распределения $SIGN может измениться без изменения самой системы.

Так что мой вопрос таков:

Сделает ли предсказуемость эти системы сильнее?

или просто делает их легче для стратегической навигации 🤔

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

На поверхности это имеет смысл.
Существует удостоверение.
Оно проверяемо.
Это подтверждается.

Так что это должно просто работать.

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

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

Они зависят от контекста.

Кто его выдал?
По каким правилам?
Какую схему оно следует?
Что на самом деле должно представлять доказательство?

И все это должно быть интерпретировано прежде, чем будет принято решение внутри #SignDigitalSovereignInfra .

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

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

И вот здесь вещи начинают казаться менее прямолинейными.

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

Оно условно.

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

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

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

Не уверен, делает ли возможность что-то доказать это универсально надежным,
или просто упрощает каждому из систем решение о том, принимать это или нет 🤔

Я думаю о том, что на самом деле происходит, когда идентичность повторно используется в системах @SignOfficial и, честно говоря, часть, которая кажется слишком чистой, — это предположение, что значение просто переносится автоматически

внутри одной системы это работает хорошо
один учетные данные → один контекст → одно толкование

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

потому что теперь несколько уровней начинают иметь значение

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

и все это должно быть разрешено, прежде чем система сможет решить, что на самом деле означает эта идентичность

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

потому что идентичность — это не просто данные, это контекст
и контекст не всегда передается ясно

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

и вот где вещи начинают меняться внутри #SignDigitalSovereignInfra , потому что две системы могут смотреть на одни и те же учетные данные и все равно рассматривать их по-разному

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

и когда вы смотрите на это через системы, такие как $SIGN , вопрос становится труднее игнорировать

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

Я думал об автоматизации в распределении

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

в системах, таких как @SignOfficial , распределение на самом деле не является случайным или нейтральным

это определяется условиями, которые уже определены где-то еще

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

к моменту, когда токены распределены,
результат уже решен

автоматизация просто его выполняет

так что внутри #SignDigitalSovereignInfra
процесс кажется чистым, потому что

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

но это не обязательно означает, что это беспристрастно

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

и как только все закодировано
становится сложнее оспаривать

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

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

что заставляет меня задуматься 🤔

Делает ли автоматизация распределение действительно справедливым?
Или просто делает слой принятия решений менее очевидным в системах, таких как $SIGN Network.

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

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

но внутри систем, таких как @SignOfficial , это работает только в том случае, если проверяющий может надежно получить доступ к последнему статусу

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

и это создает зависимость, о которой не говорят слишком часто

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

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

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

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

не говорю, что отзыв неверен
просто не вполне уверен, делает ли это удостоверения более безопасными

или просто более зависимыми от того, как системы, такие как $SIGN , будут поддерживать все в синхронизации 🤔

Я думаю о том, как на самом деле работают airdrop'ы на практике, и часть, которая меня беспокоит, не смарт-контракт, а все, что происходит до него.

Списки соответствия, снимки, фильтрация — все это обычно собирается вне цепи, и именно там происходит большинство ошибок, а не в самом контракте.

TokenTable из @SignOfficial пытается подключиться к этому уровню, связывая распределение непосредственно с аттестациями вместо статических списков.

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

Но я не думаю, что это так просто.

Потому что теперь вопрос смещается с
является ли список правильным?
на является ли аттестация правильной?

И это все еще зависит от того, как были собраны данные, кто их выдал и какие критерии были использованы изначально.

Таким образом, вместо устранения ошибок система может просто перемещать их на один уровень глубже.
Сложнее увидеть, сложнее оспорить, но они все еще существуют в #SignDigitalSovereignInfra .

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

Что заставляет меня задуматься.

Снижает ли TokenTable на самом деле ошибки airdrop'ов или просто скрывает их?

И поэтому я продолжаю следить за $SIGN и буду продолжать задавать вопросы.

Я думаю о том, как @SignOfficial верификация на самом деле ведет себя, когда использование начинает увеличиваться, и честно говоря, часть, которая кажется слишком чистой, — это предположение, что она просто остается мгновенной, независимо от всего. #SignDigitalSovereignInfra

На небольшом масштабе все работает нормально
одна учетная запись → одна проверка → результат

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

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

и все это должно быть завершено до того, как будет возвращен ответ

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

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

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

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

вот где координация становится настоящим ограничением, и координация не масштабируется так же чисто, как логика

поэтому то, что на теории выглядит как верификация в реальном времени, начинает зависеть от того, насколько хорошо разные части $SIGN остаются синхронизированными под давлением

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

Системы не ломаются громко, они сначала тихо дрейфуют.

По крайней мере, это то, что я начал замечать.

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

Но большую часть времени это не так.

Всё продолжает работать. Всё по-прежнему проверяется. Ничто не выглядит сломанным. И именно поэтому никто это не ставит под сомнение.

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

На чем-то вроде Midnight это кажется еще более интересным.

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

Так что снаружи все выглядит стабильно.

Но стабильность не всегда означает правильность.

Иногда это просто означает, что ничего еще не было оспорено.

И это та часть, о которой я все время думаю.

Что если системы не терпят неудач, когда они ломаются,
а когда мы наконец замечаем, что они уже сломались?

@MidnightNetwork $NIGHT #night