Safe Network новини 🇧🇬 30.9.2021

Както споменахме няколко седмици назад, старият тип данни Sequence за променящи се данни беше заменен с Register. Регистрите могат да правят всичко, което можеше Sequence по отношение на съхранението на предишни версии с добавения бонус, че може да обработва и едновременното им съхранение. Тази седмица Дейвид Русу повдига завесата на мистериозния свят на Merkle Registers.

Общ напредък

Дейвид Русу почти завърши основната функционалност за клиента за записване в Разходната книга. След като е напълно завършена, тя ще намали работата на монетните възли само до четене: те ще трябва само да проверят Разходната книга за ангажименти по DBC транзакции, за да проверят дали всички входове са ангажирани с една и съща транзакция и да потвърдят салдата по транзакциите.

@Chris.connelly продължава да се бори с qp2p. Много от заданията, които то върши във връзка с входящи съобщения, вероятно са остарели, сега когато не използваме пула за връзки, за да поддържаме връзките отворени, а въвеждането на връзките и обработката на входящи съобщения в safe_network хранилището трябва да подобри стабилността. Ще отнеме малко работа обаче!

Крис също идентифицира дългогодишна грешка в qp2p тестовете, която сега е поправена.

@lionel.faber е фокусиран върху CI/CD и инструментите за стартиране, като актуализира инструментите ни за автоматизация за изграждане на облачни виртуални машини, за да се стартира пълноценна тестова мрежа. Всеки може да използва този инструмент, при условие че има необходимите идентификационни данни за AWS и Digital Ocean. Инструментът се конфигурира и може да се задейства според нуждите. Вътрешно ние използваме ръчни спусъци и специален коментар launch-testnet в PR прегледите.

Работата по CLI-то и API-то продължава за да ги направи съвместими с най-новата версия safe_network … приближава се до това, но както @Chriso споменато във вторник все още има някои гремлини, които гризат кабелите, включително някои проблеми около извличането на файлове с CLI-то.

Създадохме някои основни задания за лог файла на тестовата мрежа, които би трябвало да гарантират, че вече не препращаме едни и същи съобщения (дори вече засякохме незначително усилване на съобщенията). Това все още не е добавено, тъй като продължаваме да се борим със стабилността му.

Тази седмица променихме повторните опити на клиентите да бъдат по-разумни, което помогна; смачкахме някои фалшиви грешки, които се произвеждат от време на време, което се дължи на това, че разчитаме на грешки в tokio (когато самата задача е завършила добре). И @yogesh започна да подобрява зареждането на клиенти в мрежата, което в момента се търси с всеки достъпен компютър, но не се опитва да установи състоянието на мрежата, което по-късно води до повече AE-съобщения, отколкото е необходимо.

Меркъл регистър

Тази седмица бихме искали да се потопим дълбоко в Меркъл регистъра, един от двата примитивни типа данни в Сафе мрежаta (другият е неизменни парчета).

Регистърът на Меркъл е нов CRDT, който сме измислили, за да моделираме променящо се състояние в Safe мрежата, той поддържа едновременно записване и обхождане на историята. Те се използват широко в NRS за поддържане на съпоставяне на имена, използвани за проследяване на версиите на файл(-ове) и всяко приложение, което се нуждае от променящо се състояние.

Множеството на CRDT регистъра

Регистрите се използват за писане и четене на стойност, подобно на регистрите на процесора. Съществуващите CRDT на регистрите са Регистърът с много стойности (MVReg) и Регистърът за последно записани печалби (LWWReg). Нашият регистър на Merkle (MerkleReg) е поредният CRDT в това множество.

Всички регистри следват подобно API.

# You can read the current value(s) stored in the register
read(reg) -> val(s)

# You can write a value to a register using a causal context
write(reg, val, ctx) -> reg

# Merge two registers
merge(reg1, reg2) -> merged-reg

MerkleReg е изграден върху Mergle DAG. Merkle DAG е обобщение на Merkle дървото, което позволява възлите да имат множество родители и да поставят данни на всеки възел.

С Merkle Trees подреждаме данни в листата на двоично дърво и ги хешираме по двойки, за да получим следващото ниво на възли, повтаряме това чрез хеширане на двойки от тези хешове, докато стигнем до корена. Това е невероятно гъвкава структура от данни, използвана в много децентрализирани системи. Merkle DAG премахват ограничението за двоично дърво. Вече можем да поставяме данни на всеки възел и всеки възел може да има множество родители.

Начинът, по който изграждаме MerkleReg, е да използваме корените на Merkle DAG като текущите стойности на регистъра. Например, помислете за следната поредица от операции.

Започваме с четене на празния DAG, връщаме празния набор.

read(∅) = {}

Записваме „a“ в регистъра, използваме празния набор като контекст.

                  ∅
write(∅, a, {}) = |
                  a

Едновременно с това друг клиент пише в същия регистър.

                  ∅
write(∅, b, {}) = |
                  b

След като двамата клиенти запишат текущото състояние в мрежата, можем да обединим двата едновременни регистри.

      ∅  ∅     ∅
merge(|, |) = / \
      a  b   a   b

Четенето на обединения регистър връща и двете едновременни стойности.

       ∅  
read( / \ ) = {a, b}
     a   b

Вече можем да разрешим едновременните стойности, като използваме и “a” и “b” като контекст за запис.

                            ∅
        ∅                  / \
write( / \ , c, {a, b}) = a   b
      a   b                \ /
                            c

Четенето на крайния регистър връща само “c”.

        ∅
       / \
read( a   b ) = {c}
       \ /  
        c

Хубаво свойство на този MerkleReg в сравнение с някои от другите CRDT на регистъра е, че имаме цялата история на разклоняване на регистъра, поддържана в DAG на Merkle. Ако проследяваме документ, можем да преминем през историята му, за да видим как се е развил.

MultiSet и MultiMaps

Можем да изградим MultiSet и MultiMaps върху Merkle Registers съвсем просто, като се възползваме от това как работят контекстите за писане.

Записите, записани в регистъра с празен контекст, ще се появят, когато прочетем стойностите обратно, това симулира Set CRDT.

Започнете с празния регистър.

read(∅) = {}

След като запишете „y“ с празен контекст.

      ∅
read( | ) = {y}
      y 

След това напишете „x“ с празен контекст.

        ∅
read(  / \  ) = {x, y}
      x   y

Писане на „z“ с празен контекст.

         ∅
read(  / | \  ) = {x, y, z}
      x  y  z

Сега можем да симулираме изтриване, като присвоим специален възел “кошче”:

        ∅
read( / | \  ) = {x, y, 🗑} 
     x  y  🗑

Обединете “y” с :wastebasket:, за да го изтриете.

        ∅
read( / | \  ) = {x, 🗑}
     x  y  🗑
         \ /
          🗑

Това ни дава комплект CRDT с добавяния и премахвания. За да получим CRDT Карта, правим членовете на набора ключ с 2 кортежа :стойност:

          ∅
read(  /  |  \  ) = {x:1, y:2, 🗑} 
     x:1 y:2 🗑

Актуализирането на стойността на „x“ се извършва чрез използване на текущите записи „x“ като разклонения:
Тук актуализираме „x“, за да съхранява „2“ вместо „1“

          ∅
read(  /  |  \ ) = {x:2, y:2, 🗑} 
     x:1 y:2 🗑
      |
     x:2

Тъй като това е едновременно редактирана структура, може да завършим с множество стойности, записани към конкретен ключ (оттук и множеството в Multi-Map):

Друг клиент едновременно пише x:3

          ∅
       /  |  \
read( x:1 x:3 🗑 ) = {x:2, x:3, 🗑} 
       |
      x:2

Тези множество записи могат да бъдат разрешени чрез отписване на запис за „x“ с „x:2“ и „x:3“ като разклонения.

          ∅
        /  |  \ 
read( x:1 x:3 🗑 ) = {x:3, 🗑} 
       |   |
      x:2  |
        \  /
        x:3

Това ни дава MultiMap CRDT с история и сливане на едновременни стойности!

Последици от MerkleReg

MerkleReg заменя стария тип данни Sequence, защото открихме, че опитът да се моделират линейни последователности в частично подредена мрежа няма да има чиста семантика. Вместо това приемаме разделянията, резултатът е, че приложенията трябва да се справят с едновременни стойности. Например браузър, изграден върху Safe мрежата, трябва да се съобрази с възможността уебсайтовете да имат множество едновременни страници index.html. NRS ще трябва да се занимава с множество записи за едно и също име.

Това не е толкова голям проблем, колкото си мислите, повечето мащабни системи вече работят с този модел. Например DNS позволява множество IP адреси, свързани с домейн, и нещата (обикновено) все още работят.

Преводи:

:uk: English :ru: Russian ; :de: German ; :es: Spanish ; :fr: French

  • Подробна информация може да намерите както винаги във форума на международната общност: Safe Network Forum
  • Ако имате въпроси може да ги зададете във Facebook групата на българската Safe общност: https://www.facebook.com/groups/SafeNetworkBulgaria/
  • Ако искате да следите последните новини заповядайте във Facebook страницата на Safe Network България: https://www.facebook.com/SafeNetworkBulgaria/