Utreexo: קאַמפּרעסינג פילע UTXO ביטקאָין

היי האבר!

אין די ביטקאָין נעץ, אַלע נאָודז, דורך קאָנסענסוס, שטימען אויף אַ גאַנג פון UTXOs: ווי פילע קאָינס זענען בנימצא פֿאַר ספּענדינג, צו וועמען פּונקט, און אונטער וואָס טנאָים. די UTXO שטעלן איז די מינימום גאַנג פון דאַטן פארלאנגט פֿאַר אַ וואַלידאַטאָר נאָדע, אָן וואָס די נאָדע וועט נישט קענען צו באַשטעטיקן די גילטיקייַט פון ינקאַמינג טראַנזאַקשאַנז און די בלאַקס מיט זיי.

אין דעם אַכטונג, פרווון זענען געמאכט אין יעדער מעגלעך וועג צו רעדוצירן די סטאָרד פאַרטרעטונג פון דעם גאַנג, צו קאָמפּרעס עס אָן לוזינג זיכערהייט געראַנטיז. דער קלענערער די באַנד פון סטאָרד דאַטן, די נידעריקער די דיסק פּלאַץ רעקווירעמענץ פון די וואַלידאַטאָר נאָדע, וואָס מאכט די קאַטער פון אַ וואַלידאַטאָר נאָדע ביליק, אַלאַוז איר צו יקספּאַנד די נעץ און דערמיט פאַרגרעסערן די פעסטקייַט פון די נעץ.

אין דעם פּאָסטן, מיר וועלן פּאָסטן אַ רוסט פּראָוטאַטייפּ פון אַ פריש פאָרשלאָג פון אַ קאָ-מחבר בליץ נעטוואָרק פּאַפּיר, Thaddeus Dryja - Utreexo: אַ דינאַמיש האַש-באזירט אַקיומיאַלאַטאָר אָפּטימיזעד פֿאַר די ביטקאָין UTXO שטעלן, וואָס אַלאַוז רידוסינג דיסק פּלאַץ רעקווירעמענץ פֿאַר וואַלידאַטאָר נאָודז.

וואָס איז די פּראָבלעם?

איינער פון די דוירעסדיק פּראָבלעמס פון ביטקאָין איז זיין סקאַלאַביליטי. דער געדאַנק פון "דיין אייגענע באַנק" ריקווייערז נעץ פּאַרטיסאַפּאַנץ צו האַלטן רעקאָרדס פון אַלע געלט בנימצא פֿאַר נוצן. אין ביטקאָין, בנימצא געלט זענען אויסגעדריקט ווי אַ סכום פון אַנספּענט אַוטפּוץ - אַ UTXO-סעט. כאָטש דאָס איז נישט אַ ספּעציעל ינטואַטיוו פאַרטרעטונג, עס איז וווילטויק אין טערמינען פון ימפּלאַמענטיישאַן פאָרשטעלונג איבער אַ פאַרטרעטונג אין וואָס יעדער "בייַטל" האט אַ "וואָג" ווי אַ באַזונדער פּאָזיציע, און אויך מוסיף פּריוואַטקייט (למשל. קאָינדזשאָין).

עס איז וויכטיק צו ויסטיילן צווישן די געשיכטע פון ​​טראַנזאַקשאַנז (וואָס איז גערופן די בלאָקטשיין) און די קראַנט שטאַט פון די סיסטעם. ביטקאָין טראַנסאַקטיאָן געשיכטע דערווייַל אַקיאַפּייז וועגן 200 גיגאבייט פון דיסק פּלאַץ, און האלט צו וואַקסן. אָבער, די סיסטעם שטאַט איז פיל קלענערער, ​​אויף די סדר פון 4 גיגאבייט, און נאָר נעמט אין חשבון די פאַקט אַז עמעצער איצט אָונז קאָינס. דער באַנד פון די דאַטן ינקריסיז אויך מיט צייט, אָבער אין אַ פיל סלאָוער קורס און טענדז אפילו צו פאַרמינערן (זען CDPV).

ליכט קלייאַנץ (ספּווס) האַנדל זיכערהייט געראַנטיז פֿאַר די פיייקייט צו קראָם קיין מינימום שטאַט (UTXO-set) אנדערע ווי פּריוואַט שליסלען.

UTXO און UTXO-שטעלן

UTXO (Unspent Transaction Output) איז די אַנספּענט טראַנסאַקטיאָן רעזולטאַט, דער סוף פונט פון די נסיעה פון יעדער סאַטאָשי טראַנספערד אין טראַנזאַקשאַנז. ונספּענט אַוטפּוץ ווערן ינפּוץ פון נייַע טראַנזאַקשאַנז און זענען אַזוי פארבראכט (פאַרברענגען) און אַוועקגענומען פון די UTXO-סעט.

ניו UTXOs זענען שטענדיק באשאפן דורך טראַנזאַקשאַנז:

• קאָינסבאַסע טראַנזאַקשאַנז אָן ינפּוץ: שאַפֿן נייַע UTXOs ווען מיינערז אַרויסגעבן קאָינס
• רעגולער טראַנזאַקשאַנז: שאַפֿן נייַע UTXOs בשעת ספּענדינג אַ זיכער גאַנג פון יגזיסטינג UTXOs

פּראָצעס פון ארבעטן מיט UTXO:

וואַללעץ ציילן די נומער פון קאָינס בנימצא פֿאַר ספּענדינג (וואָג) באזירט אויף די סומע פון ​​UTXO בנימצא צו דעם בייַטל פֿאַר ספּענדינג.

יעדער וואַלידאַטאָר נאָדע, צו פאַרמייַדן טאָפּל פאַרברענגען פרווון, מוזן מאָניטאָר די גאַנג אַלע UTXO ווען טשעק יעדער טראַנזאַקשאַנז יעדער בלאָק.

דער נאָדע מוזן האָבן לאָגיק:

• אַדישאַנז צו UTXO-סעט
• דילישאַנז פון UTXO-סעט
• קאָנטראָלירן דעם בייַזייַן פון אַ איין UTXO אין אַ גאַנג

עס זענען וועגן צו רעדוצירן די רעקווירעמענץ פֿאַר סטאָרד אינפֿאָרמאַציע וועגן אַ גאַנג, בשעת איר האַלטן די פיייקייט צו לייגן און אַראָפּנעמען עלעמענטן, קאָנטראָלירן און באַווייַזן די עקזיסטענץ פון אַן עלעמענט אין אַ גאַנג. קריפּטאָגראַפיק אַקיומיאַלייטערז.

באַטעריז פֿאַר UTXO

דער געדאַנק פון ניצן באַטעריז צו קראָם קייפל UTXOs איז דיסקאַסט פריער.

די UTXO-סעט איז געבויט אויף די פליען, בעשאַס די ערשט בלאָק אראפקאפיע (יבד), סטאָרד אין פול און פּערמאַנאַנטלי, בשעת זייַן אינהאַלט טוישן נאָך פּראַסעסינג טראַנזאַקשאַנז פון יעדער נייַ און ריכטיק בלאָק פון די נעץ. דער פּראָצעס ריקווייערז דאַונלאָודינג בעערעך 200 גיגאבייט פון בלאָק דאַטן און וועראַפייינג הונדערטער פון מיליאַנז פון דיגיטאַל סיגנאַטשערז. נאָך די יבד פּראָצעס איז געענדיקט, די דנאָ שורה איז אַז די UTXO-סעט וועט פאַרנעמען וועגן 4 גיגאבייט.

אָבער, מיט אַקיומיאַלייטערז, די כּללים פון קאָנסענסוס פֿאַר געלט זענען רידוסט צו די וועראַפאַקיישאַן און דור פון קריפּטאָגראַפיק פּראָוועס, און די מאַסע פון ​​טראַקינג בנימצא געלט איז שיפטיד צו די באַזיצער פון די געלט, וואָס גיט דערווייַז פון זייער עקזיסטענץ און אָונערשיפּ.

אַן אַקיומיאַלאַטאָר קענען זיין גערופֿן אַ סאָליד פאַרטרעטונג פון אַ סכום. די גרייס פון די סטאָרד פאַרטרעטונג מוזן זיין קעסיידערדיק , אָדער פאַרגרעסערן סובלינעאַרלי מיט רעספּעקט צו די קאַרדינאַליטי פון די גאַנג און די גרייס פון דעם עלעמענט זיך, פֿאַר בייַשפּיל , ווו n איז די קאַרדינאַליטי פון די סטאָרד שטעלן.

אין דעם פאַל, דער אַקיומיאַלאַטאָר זאָל לאָזן דזשענערייטינג אַ דערווייַז פון די ינקלוזשאַן פון אַן עלעמענט אין דעם גאַנג (ינקלוזשאַן דערווייַז) און מאַכן עס מעגלעך צו יפעקטיוולי באַשטעטיקן דעם דערווייַז.

די באַטאַרייע איז גערופן דינאַמיש אויב אַלאַוז איר צו לייגן עלעמענטן און באַזייַטיקן עלעמענטן פון אַ גאַנג.

אַ בייַשפּיל פון אַזאַ אַ באַטאַרייע וואָלט זיין RSA אַקיומיאַלאַטאָר פארגעלייגט דורך Boneh, Bunz, Fisch אין דעצעמבער 2018. אַזאַ אַ אַקיומיאַלאַטאָר האט אַ קעסיידערדיק גרייס פון סטאָרד פאַרטרעטונג, אָבער ריקווייערז דעם בייַזייַן שערד סוד (טראַסטיד סעטאַפּ). די פאָדערונג ניגייץ די אָנווענדלעך פון אַזאַ אַ אַקיומיאַלאַטאָר פֿאַר טראַסטלאַס נעטוואָרקס ווי ביטקאָין, זינט דאַטן ליקאַדזש בעשאַס סוד דור קענען לאָזן אַטאַקערז צו שאַפֿן פאַלש דערווייַז פון די עקזיסטענץ פון אַ UTXO, נארן נאָודז מיט אַ UTXO-שטעלן באזירט אויף אַזאַ אַ אַקיומיאַלאַטאָר.

Utreexo

די Utreexo פּלאַן פארגעלייגט דורך Thaddeus Dryja מאכט עס מעגלעך צו שאַפֿן דינאַמיש באַטאַרייע אָן טראַסטיד-סעטאַפּ.

Utreexo איז אַ וואַלד פון גאנץ ביינערי מערקלע טריז און איז אַ אַנטוויקלונג פון די געדאנקען דערלאנגט אין עפעקטיוו ייסינגקראַנאַס אַקיומיאַלייטערז פֿאַר פונאנדערגעטיילט פּקי, אַדינג די פיייקייט צו באַזייַטיקן עלעמענטן פון אַ גאַנג.

באַטערי לאַדזשיקאַל סטרוקטור

די באַטאַרייע סעלז זענען עריינדזשד אין אַ וואַלד פון ידעאַל ביינערי ביימער. ביימער זענען אָרדערד לויט הייך. דעם פאַרטרעטונג איז אויסדערוויילט ווי די מערסט וויזשאַוואַל און אַלאַוז איר צו וויזשוואַלייז די מערדזשינג פון ביימער בעשאַס אַפּעריישאַנז אויף די באַטאַרייע.

דער מחבר באַמערקט אַז זינט אַלע ביימער אין די וואַלד זענען ידעאַל, זייער הייך איז אויסגעדריקט ווי אַ מאַכט פון צוויי, פּונקט ווי יעדער נאַטירלעך נומער קענען זיין רעפּריזענטיד ווי אַ סאַכאַקל פון כוחות פון צוויי. אַקקאָרדינגלי, קיין סכום פון בלעטער קענען זיין גרופּט אין ביינערי ביימער, און אין אַלע קאַסעס, אַדינג אַ נייַ עלעמענט ריקווייערז וויסן בלויז וועגן די וואָרצל נאָודז פון סטאָרד ביימער.

אזוי, די סטאָרד פאַרטרעטונג פון די Utreexo אַקיומיאַלאַטאָר איז אַ רשימה פון וואָרצל נאָודז (מערקלע וואָרצל), און ניט דער גאַנצער וואַלד פֿון ביימער.

זאל ס פאָרשטעלן די רשימה פון וואָרצל עלעמענטן ווי Vec<Option<Hash>>. אָפּטיאָנאַל טיפּ Option<Hash> ינדיקייץ אַז דער וואָרצל עלעמענט קען זיין פעלנדיק, וואָס מיטל אַז עס איז קיין בוים מיט די צונעמען הייך אין די אַקיומיאַלאַטאָר.

/// SHA-256 хеш
#[derive(Copy, Clone, Hash, Eq, PartialEq)]
pub struct Hash(pub [u8; 32]);

#[derive(Debug, Clone)]
pub struct Utreexo {
    pub roots: Vec<Option<Hash>>,
}

impl Utreexo {
    pub fn new(capacity: usize) -> Self {
        Utreexo {
            roots: vec![None; capacity],
        }
    }
}

אַדינג עלעמענטן

ערשטער, לאָזן ס באַשרייַבן די פֿונקציע parent(), וואָס אנערקענט די פאָטער נאָדע פֿאַר צוויי געגעבן עלעמענטן.

פאָטער () פֿונקציע

זינט מיר נוצן Merkle ביימער, דער פאָטער פון יעדער פון די צוויי נאָודז איז איין נאָדע וואָס סטאָרז די האַש פון די קאַנקאַטאַניישאַן פון די האַשעס פון די קינד נאָודז:

fn hash(bytes: &[u8]) -> Hash {
    let mut sha = Sha256::new();
    sha.input(bytes);
    let res = sha.result();
    let mut res_bytes = [0u8; 32];
    res_bytes.copy_from_slice(res.as_slice());

    Hash(res_bytes)
}

fn parent(left: &Hash, right: &Hash) -> Hash {
    let concat = left
        .0
        .into_iter()
        .chain(right.0.into_iter())
        .map(|b| *b)
        .collect::<Vec<_>>();

    hash(&concat[..])
}

דער מחבר באמערקט אַז צו פאַרמייַדן די אַטאַקס דיסקרייבד דורך Charles Bouillaguet, Pierre-Alain Fouque, Adi Shamir און Sebastien Zimmer אין
צווייטע פּרעימאַגע אַטאַקס אויף דיטערד האַש פאַנגקשאַנז, א חו ץ ד י צװ ײ האשע , זא ל אוי ך צוגעלײג ט װער ן ד י הוי ך אי ן דע ם בוים .

ווען איר לייגן עלעמענטן צו די אַקיומיאַלאַטאָר, איר דאַרפֿן צו האַלטן שפּור פון וואָס וואָרצל עלעמענטן זענען פארענדערט. דורך נאָכגיין דעם דרך פון טשאַנגינג די וואָרצל עלעמענטן פֿאַר יעדער עלעמענט איר לייגן, איר קענען שפּעטער בויען אַ דערווייַז פון די בייַזייַן פון די עלעמענטן.

שפּור ענדערונגען ווי איר לייגן זיי

צו שפּור די ענדערונגען געמאכט, לאָזן אונדז דערקלערן די סטרוקטור Update, וואָס וועט קראָם דאַטן וועגן נאָדע ענדערונגען.

#[derive(Debug)]
pub struct Update<'a> {
    pub utreexo: &'a mut Utreexo,
    // ProofStep хранит "соседа" элемента и его положение
    pub updated: HashMap<Hash, ProofStep>,
}

צו לייגן אַן עלעמענט צו די באַטאַרייע, איר דאַרפֿן:

• שאַפֿן אַ מענגע פון ​​קערב פון וואָרצל עלעמענטן new_roots און שטעלן די יגזיסטינג וואָרצל עלעמענטן דאָרט, איינער פֿאַר יעדער עמער:

קאָדעקס

let mut new_roots = Vec::new();

for root in self.roots.iter() {
    let mut vec = Vec::<Hash>::new();
    if let Some(hash) = root {
        vec.push(*hash);
    }

    new_roots.push(vec);
}

• צוגעבן די עלעמענטן צו זיין מוסיף (מענגע insertions) צום ערשטן װאגן new_roots[0]:

קאָדעקס

new_roots[0].extend_from_slice(insertions);

• צונויפגיסן די זאכן צוגעלייגט צו דער ערשטער קאָרב מיט די מנוחה:
  • פֿאַר אַלע קאַרץ מיט מער ווי איין נומער:
    1. נעמען צוויי עלעמענטן פון די סוף פון די קאָרב, רעכענען זייער פאָטער, אַראָפּנעמען ביידע עלעמענטן
    2. לייג די קאַלקיאַלייטיד פאָטער צו דער ווייַטער וואָגן

קאָדעקס

for i in 0..new_roots.len() {
    while new_roots[i].len() > 1 {
        // Объединяем два элемента в один и удаляем их
        let a = new_roots[i][new_roots[i].len() - 2];
        let b = new_roots[i][new_roots[i].len() - 1];
        new_roots[i].pop();
        new_roots[i].pop();
        let hash = self.parent(&a, &b);

        // Наращиваем количество корзин если требуется
        if new_roots.len() <= i + 1 {
            new_roots.push(vec![]);
        }

        // Помещаем элемент в следующую корзину
        new_roots[i + 1].push(hash);

        // Не забываем отслеживать изменения;
        // это пригодится для генерации доказательства добавления элементов
        updated.insert(a, ProofStep { hash: b, is_left: false });
        updated.insert(b, ProofStep {hash: a, is_left: true });
    }
}

• מאַך וואָרצל עלעמענטן פון בינס צו ריזאַלטינג אַקיומיאַלאַטאָר מענגע

קאָדעקס

for (i, bucket) in new_roots.into_iter().enumerate() {
    // Наращиваем аккумулятор если требуется
    if self.roots.len() <= i {
        self.roots.push(None);
    }

    if bucket.is_empty() {
        self.roots[i] = None;
    } else {
        self.roots[i] = Some(bucket[0]);
    }
}

קריייטינג אַ דערווייַז פֿאַר צוגעלייגט עלעמענטן

דערווייַז פון ינקלוזשאַן פון די צעל אין די באַטאַרייע (Proof) וועט דינען אלס דער מערקל וועג, באשטייט פון א קייט ProofStep. אויב דער דרך פירט ינ ערגעצ ניט, דעמאָלט דער דערווייַז איז פאַלש.

/// Единичный шаг на пути к элементу в дереве Меркла.
#[derive(Debug, Copy, Clone)]
pub struct ProofStep {
    pub hash: Hash,
    pub is_left: bool,
}

/// Доказательство включения элемента. Содержит сам элемент и путь к нему.
#[derive(Debug, Clone)]
pub struct Proof {
    pub steps: Vec<ProofStep>,
    pub leaf: Hash,
}

ניצן די אינפֿאָרמאַציע באקומען פריער ווען אַדינג אַן עלעמענט (סטרוקטור Update), איר קענען מאַכן דערווייַז אַז אַן עלעמענט איז צוגעגעבן צו די באַטאַרייע. צו טאָן דאָס, מיר גיין דורך די טיש פון ענדערונגען געמאכט און לייגן יעדער שריט צו Merkle ס דרך, וואָס וועט דערנאָך דינען ווי דערווייַז:

קאָדעקס

impl<'a> Update<'a> {
    pub fn prove(&self, leaf: &Hash) -> Proof {
        let mut proof = Proof {
            steps: vec![],
            leaf: *leaf,
        };

        let mut item = *leaf;
        while let Some(s) = self.updated.get(&item) {
            proof.steps.push(*s);
            item = parent(&item, &s);
        }

        proof
    }
}

פּראָצעס פון קריייטינג אַ דערווייַז

טשעק די דערווייַז פֿאַר אַן עלעמענט

קאָנטראָלירונג די ינקלוזשאַן דערווייַז פון אַן עלעמענט בוילז אַראָפּ צו נאָכפאָלגן די Merkle דרך ביז עס פירט צו אַ יגזיסטינג וואָרצל עלעמענט:

pub fn verify(&self, proof: &Proof) -> bool {
    let n = proof.steps.len();
    if n >= self.roots.len() {
        return false;
    }

    let expected = self.roots[n];
    if let Some(expected) = expected {
        let mut current_parent = proof.leaf;
        for s in proof.steps.iter() {
            current_parent = if s.is_left {
                parent(&s.hash, &current_parent)
            } else {
                parent(&current_parent, &s.hash)
            };
        }

        current_parent == expected
    } else {
        false
    }
}

וויסואַללי:

פּראָצעס פון קאָנטראָלירן די דערווייַז פֿאַר א

רימוווינג זאכן

צו באַזייַטיקן אַ צעל פון אַ באַטאַרייע, איר מוזן צושטעלן גילטיק זאָגן אַז דער צעל איז דאָרט. ניצן די דאַטן פון דער דערווייַז, עס איז מעגלעך צו רעכענען נייַע וואָרצל עלעמענטן פון די אַקיומיאַלאַטאָר פֿאַר וואָס די געגעבן דערווייַז וועט ניט זיין אמת.

די אַלגערידאַם איז ווי גייט:

1. ווי אין דערצו, מיר אָרגאַניזירן אַ סכום פון ליידיק קערב קאָראַספּאַנדינג צו מערקלע ביימער מיט אַ הייך גלייַך צו די מאַכט פון צוויי פון די קאָרב אינדעקס
2. מיר אַרײַן אין די קערב עלעמענטן פֿון די טרעפּ פֿונעם מערקלע־שטעג; די קאָרב אינדעקס איז גלייַך צו די נומער פון די קראַנט שריט
3. מיר באַזייַטיקן די וואָרצל עלעמענט צו וואָס דער דרך פון דער דערווייַז פירט
4. ווי מיט אַדינג, מיר רעכענען נייַע וואָרצל עלעמענטן דורך קאַמביינינג עלעמענטן פון קערב אין פּערז און אַריבערפירן די רעזולטאַט פון די פאַרבאַנד צו די ווייַטער קאָרב

קאָדעקס

fn delete(&self, proof: &Proof, new_roots: &mut Vec<Vec<Hash>>) -> Result<(), ()> {
    if self.roots.len() < proof.steps.len() || self.roots.get(proof.steps.len()).is_none() {
        return Err(());
    }

    let mut height = 0;
    let mut hash = proof.leaf;
    let mut s;

    loop {
        if height < new_roots.len() {
            let (index, ok) = self.find_root(&hash, &new_roots[height]);
            if ok {
                // Remove hash from new_roots
                new_roots[height].remove(index);

                loop {
                    if height >= proof.steps.len() {
                        if !self.roots[height]
                            .and_then(|h| Some(h == hash))
                            .unwrap_or(false)
                        {
                            return Err(());
                        }

                        return Ok(());
                    }

                    s = proof.steps[height];
                    hash = self.parent(&hash, &s);
                    height += 1;
                }
            }
        }

        if height >= proof.steps.len() {
            return Err(());
        }

        while height > new_roots.len() {
            new_roots.push(vec![]);
        }

        s = proof.steps[height];
        new_roots[height].push(s.hash);
        hash = self.parent(&hash, &s);
        height += 1;
    }
}

דער פּראָצעס פון רימוווינג עלעמענט "א":

ינטעגראַטיאָן אין אַ יגזיסטינג נעץ

ניצן די פארגעלייגט אַקיומיאַלאַטאָר, נאָודז קענען ויסמיידן ניצן אַ DB צו קראָם אַלע UTXOs בשעת איר קענען טוישן די UTXO-שטעלן. אָבער, די פּראָבלעם פון ארבעטן מיט זאָגן ערייזאַז.

לאָמיר רופן די וואַלידאַטאָר נאָדע וואָס ניצט די UTXO אַקיומיאַלאַטאָר סאָליד (סאָליד-שטאַט נאָדע), און די וואַלידאַטאָר אָן אַ אַקיומיאַלאַטאָר איז פאַרענדיקן (פול נאָדע). די עקזיסטענץ פון צוויי קלאסן פון נאָודז קריייץ אַ פּראָבלעם פֿאַר ינטאַגרייטינג זיי אין אַ איין נעץ, ווייַל סאָליד נאָודז דאַרפן דערווייַז פון די עקזיסטענץ פון UTXOs, וואָס זענען פארבראכט אין טראַנזאַקשאַנז, בשעת פול נאָודז טאָן ניט. אויב אַלע נעץ נאָודז טאָן ניט סיימאַלטייניאַסלי און אין אַ קאָואָרדאַנייטיד שטייגער באַשטימען צו ניצן Utreexo, דעמאָלט סאָליד נאָודז וועט זיין לינקס הינטער און וועט נישט קענען צו אַרבעטן אויף די ביטקאָין נעץ.

צו סאָלווע די פּראָבלעם פון ינטאַגרייטינג סאָליד נאָודז אין די נעץ, עס איז פארגעלייגט צו באַקענען אַן נאָך קלאַס פון נאָודז - בריקן. א בריק נאָדע איז אַ גאַנץ נאָדע וואָס אויך סטאָרז די Utreexo באַטאַרייע און מאַכט-אויף דערווייַז פֿאַר אַלע UTXO פֿון UTXO-סעט. בריקן רעכענען נייַע האַשעס און דערהייַנטיקן די אַקיומיאַלאַטאָר און פּראָוועס ווען נייַ בלאַקס פון טראַנזאַקשאַנז אָנקומען. אָנהאַלטן און אַפּדייטינג די אַקיומיאַלאַטאָר און פּרופס טוט נישט אָנטאָן נאָך קאַמפּיוטיישאַנאַל מאַסע אויף אַזאַ נאָודז. בריקן קרבן דיסק פּלאַץ: דאַרפֿן צו האַלטן די טינגז אָרגאַניזירט האַשעס, קאַמפּערד צו האַשעס פֿאַר סאָליד נאָודז, ווו n איז די מאַכט פון די UTXO שטעלן.

נעץ אַרקאַטעקטשער

בריקן מאַכן עס מעגלעך צו ביסלעכווייַז לייגן סאָליד נאָודז צו די נעץ אָן טשאַנגינג די ווייכווארג פון יגזיסטינג נאָודז. גאַנץ נאָודז אַרבעטן ווי פריער, דיסטריביוטינג טראַנזאַקשאַנז און בלאַקס צווישן זיך. בריק נאָודז זענען פול נאָודז אַז אַדישנאַלי קראָם Utrexo באַטאַרייע דאַטן און אַ סכום פון ינקלוזשאַן פּראָוועס פֿאַר אַלע UTXO פֿאַר איצט. די בריק נאָדע מעלדן זיך נישט ווי אַזאַ, פּריטענדינג צו זיין אַ פול נאָדע פֿאַר אַלע פול נאָודז און אַ סאָליד נאָדע פֿאַר אַלע סאָליד אָנעס. כאָטש בריקן פאַרבינדן ביידע נעטוואָרקס צוזאַמען, זיי פאקטיש נאָר דאַרפֿן צו פאַרבינדן זיי אין איין ריכטונג: פון יגזיסטינג פול נאָודז צו סאָליד נאָודז. דאָס איז מעגלעך ווייַל די טראַנסאַקטיאָן פֿאָרמאַט דאַרף ניט זיין טשיינדזשד, און UTXO פּרופס פֿאַר סאָליד נאָודז קענען זיין דיסקאַרדיד, אַזוי קיין סאָליד נאָדע קענען סימאַלערלי בראָדקאַסט טראַנזאַקשאַנז צו אַלע נעץ פּאַרטיסאַפּאַנץ אָן די אָנטייל פון בריק נאָודז.

סאָף

מיר געקוקט אויף די Utreexo באַטאַרייע און ימפּלאַמענאַד זייַן פּראָוטאַטייפּ אין Rust. מיר געקוקט אויף די נעץ אַרקאַטעקטשער וואָס וועט לאָזן די ינאַגריישאַן פון באַטאַרייע-באזירט נאָודז. די מייַלע פון ​​סאָליד קאַטשאַז איז די גרייס פון די סטאָרד דאַטן, וואָס דעפּענדס לאָגאַריטהמיקלי אויף די מאַכט פון די UTXOs שטעלן, וואָס שטארק ראַדוסאַז די באדערפענישן פֿאַר דיסק פּלאַץ און סטאָרידזש פאָרשטעלונג פֿאַר אַזאַ נאָודז. די כיסאָרן איז די נאָך נאָדע פאַרקער פֿאַר טראַנסמיטינג פּראָוועס, אָבער זאָגן אַגגרעגאַטיאָן טעקניקס (ווען איין דערווייַז פּראָוועס די עקזיסטענץ פון עטלעכע עלעמענטן) און קאַטשינג קענען העלפֿן האַלטן פאַרקער אין פּאַסיק לימאַץ.

רעפֿערענצן:

• GitHub פון Utreexo פּראָוטאַטייפּ אין זשאַווער
• Thaddeus Dryja - Utreexo: אַ דינאַמיש האַש-באזירט אַקיומיאַלאַטאָר אָפּטימיזעד פֿאַר די ביטקאָין UTXO שטעלן
• אַנימאַטעד אילוסטראציעס פון דעם אַרטיקל

מקור: www.habr.com