🥇Utreexo: බිට්කොයින් UTXO ගොඩක් සම්පීඩනය කිරීම

හෙලෝ, හබ්ර්!

Bitcoin ජාලය තුළ, සියලු නෝඩ්, සම්මුතිය හරහා, UTXOs කට්ටලයකට එකඟ වේ: වියදම් සඳහා කොපමණ කාසි තිබේද, හරියටම කාටද සහ කුමන කොන්දේසි යටතේද. UTXO කට්ටලය යනු වලංගුකාරක නෝඩයක් සඳහා අවශ්‍ය අවම දත්ත කට්ටලය වන අතර, එසේ නොමැතිව නෝඩයට පැමිණෙන ගනුදෙනුවල වලංගුභාවය සහ ඒවා අඩංගු බ්ලොක් සත්‍යාපනය කිරීමට නොහැකි වනු ඇත.

මේ සම්බන්ධයෙන්, මෙම කට්ටලයේ ගබඩා කර ඇති නියෝජනය අඩු කිරීමට, ආරක්ෂක සහතික අහිමි නොවී සම්පීඩනය කිරීමට හැකි සෑම ආකාරයකින්ම උත්සාහ කරනු ලැබේ. ගබඩා කර ඇති දත්ත පරිමාව කුඩා වන තරමට, වලංගුකාරක නෝඩයේ තැටි අවකාශ අවශ්‍යතා අඩු වන අතර එමඟින් වලංගුකාරක නෝඩයක් දියත් කිරීම ලාභදායී වේ, ඔබට ජාලය පුළුල් කිරීමට සහ එමඟින් ජාලයේ ස්ථායිතාව වැඩි කිරීමට ඉඩ සලසයි.

මෙම ලිපියෙන් අපි සම-කර්තෘවරයෙකුගේ මෑත යෝජනාවක රස්ට් මූලාකෘතියක් පළ කරන්නෙමු අකුණු ජාල කඩදාසි, තඩ්ඩියස් ඩ්‍රයිජා - Utreexo: Bitcoin UTXO කට්ටලය සඳහා ප්‍රශස්ත කළ ගතික හැෂ් පදනම් වූ සමුච්චකය, වලංගුකාරක නෝඩ් සඳහා තැටි ඉඩ අවශ්‍යතා අඩු කිරීමට ඉඩ සලසයි.

ප්‍රොබ්ලමාද?

Bitcoin හි බහු වාර්ෂික ගැටළුවක් වන්නේ එහි විශාලනයයි. "ඔබගේම බැංකුව" යන අදහස සඳහා ජාල සහභාගිවන්නන් භාවිතා කිරීමට ඇති සියලුම අරමුදල්වල වාර්තා තබා ගැනීම අවශ්‍ය වේ. Bitcoin හි, පවතින අරමුදල් වියදම් නොකළ නිමැවුම් කට්ටලයක් ලෙස ප්‍රකාශ වේ - UTXO-කට්ටලයක්. මෙය විශේෂයෙන් අවබෝධාත්මක නිරූපණයක් නොවන නමුත්, එක් එක් "පසුම්බි" සඳහා වෙනම ප්‍රවේශයක් ලෙස "ශේෂයක්" ඇති, සහ පුද්ගලිකත්වය එක් කරන නිරූපණයක් හරහා ක්‍රියාත්මක කිරීමේ කාර්ය සාධනය අනුව එය ප්‍රයෝජනවත් වේ (උදා. CoinJoin).

ගනුදෙනු ඉතිහාසය (බ්ලොක්චේන් ලෙස හඳුන්වනු ලබන) සහ පද්ධතියේ වත්මන් තත්ත්වය අතර වෙනස හඳුනා ගැනීම වැදගත් වේ. Bitcoin ගණුදෙණු ඉතිහාසය දැනට 200 GB පමණ තැටි ඉඩක් ලබාගෙන ඇති අතර එය දිගටම වර්ධනය වේ. කෙසේ වෙතත්, පද්ධති තත්ත්වය 4 GB අනුපිළිවෙලට වඩා කුඩා වන අතර, දැනට යමෙකුට කාසි හිමි බව පමණක් සැලකිල්ලට ගනී. මෙම දත්තවල පරිමාව ද කාලයත් සමඟ වැඩි වේ, නමුත් ඉතා මන්දගාමී වේගයකින් සහ සමහර විට අඩු වීමට පවා නැඹුරු වේ (සීඩීපීවී බලන්න).

පුද්ගලික යතුරු හැර වෙනත් අවම තත්වයක් (UTXO-set) ගබඩා කිරීමේ හැකියාව සඳහා සැහැල්ලු සේවාලාභීන් (SPVs) වෙළඳ ආරක්ෂාව සහතික කරයි.

UTXO සහ UTXO-set

UTXO (නොදැමුණු ගනුදෙනු ප්‍රතිදානය) යනු වියදම් නොකළ ගනුදෙනු ප්‍රතිදානය, ගනුදෙනු වලදී මාරු කරන ලද එක් එක් Satoshi ගමනේ අවසාන ලක්ෂ්‍යය වේ. වියදම් නොකළ ප්‍රතිදානයන් නව ගනුදෙනුවල යෙදවුම් බවට පත් වන අතර එමඟින් වියදම් (වියදම්) කර UTXO-කට්ටලයෙන් ඉවත් කරනු ලැබේ.

නව UTXOs සෑම විටම ගනුදෙනු මගින් නිර්මාණය වේ:

ආදාන නොමැතිව coinbase ගනුදෙනු: පතල්කරුවන් කාසි නිකුත් කරන විට නව UTXOs සාදන්න
නිත්‍ය ගනුදෙනු: පවතින UTXO හි නිශ්චිත කට්ටලයක් වැය කරන අතරතුර නව UTXOs සාදන්න

UTXO සමඟ වැඩ කිරීමේ ක්රියාවලිය:

මුදල් පසුම්බි මෙම මුදල් පසුම්බියට වියදම් කිරීම සඳහා ලබා ගත හැකි UTXO ප්‍රමාණය මත පදනම්ව වියදම් කිරීමට ඇති කාසි ගණන (ශේෂය) ගණන් කරයි.

සෑම වලංගුකාරක නෝඩයක්ම, ද්විත්ව වියදම් උත්සාහයන් වැළැක්වීම සඳහා, කට්ටලය නිරීක්ෂණය කළ යුතුය всех පරීක්ෂා කිරීමේදී UTXO සෑම ගනුදෙනු එකිනෙකා අවහිර කරන්න.

නෝඩයට තර්කනය තිබිය යුතුය:

UTXO-set වෙත එකතු කිරීම්
UTXO-set වෙතින් මකාදැමීම්
කට්ටලයක් තුළ තනි UTXO එකක් තිබේදැයි පරීක්ෂා කිරීම

මූලද්‍රව්‍ය එකතු කිරීමේ සහ ඉවත් කිරීමේ හැකියාව පවත්වා ගනිමින් කට්ටලයක් පිළිබඳ ගබඩා කර ඇති තොරතුරු සඳහා අවශ්‍යතා අඩු කිරීමට ක්‍රම තිබේ, භාවිතා කරමින් කට්ටලයක මූලද්‍රව්‍යයක පැවැත්ම පරීක්ෂා කර ඔප්පු කරන්න ගුප්ත ලේඛන සමුච්චකය.

UTXO සඳහා බැටරි

බහු UTXO ගබඩා කිරීම සඳහා බැටරි භාවිතා කිරීමේ අදහස සාකච්ඡා කරන ලදී කලින්.

UTXO-කට්ටලය පියාසර මත ගොඩනගා ඇත, ආරම්භක වාරණ බාගැනීම් (IBD) අතරතුර, සම්පූර්ණ සහ ස්ථිර ලෙස ගබඩා කර ඇති අතර, ජාලයේ එක් එක් නව සහ නිවැරදි කොටස් වලින් ගනුදෙනු සැකසීමෙන් පසු එහි අන්තර්ගතය වෙනස් වේ. මෙම ක්‍රියාවලිය සඳහා ආසන්න වශයෙන් 200 GB වාරණ දත්ත බාගත කිරීම සහ ඩිජිටල් අත්සන් මිලියන සිය ගණනක් සත්‍යාපනය කිරීම අවශ්‍ය වේ. IBD ක්‍රියාවලිය අවසන් වූ පසු, අවසාන කරුණ නම් UTXO-කට්ටලය 4 GB පමණ ප්‍රමාණයක් ගනී.

කෙසේ වෙතත්, සමුච්චය කරන්නන් සමඟ, අරමුදල් සඳහා වන සම්මුතියේ නීති ගුප්ත ලේඛන සාධන සත්‍යාපනය සහ උත්පාදනය දක්වා අඩු කරනු ලබන අතර, පවතින අරමුදල් ලුහුබැඳීමේ භාරය එම අරමුදල්වල හිමිකරු වෙත මාරු කරනු ලැබේ, ඔහු ඒවායේ පැවැත්ම සහ හිමිකාරිත්වය පිළිබඳ සාක්ෂි සපයයි.

සමුච්චකය කට්ටලයක සංයුක්ත නිරූපණයක් ලෙස හැඳින්විය හැක. ගබඩා කළ නිරූපණයේ ප්‍රමාණය නියත විය යුතුය , හෝ කට්ටලයේ කාර්ඩිනලිටි සහ මූලද්‍රව්‍යයේ ප්‍රමාණය සම්බන්ධයෙන් යටි රේඛීයව වැඩි කරන්න, උදාහරණයක් ලෙස , මෙහි n යනු ගබඩා කර ඇති කට්ටලයේ කාඩිනල්ටියාවයි.

මෙම අවස්ථාවෙහිදී, සමුච්චකය මඟින් මූලද්‍රව්‍ය කට්ටලයට ඇතුළත් කිරීම පිළිබඳ සාක්ෂියක් ජනනය කිරීමට ඉඩ දිය යුතුය (ඇතුළත් කිරීමේ සාක්ෂිය) සහ මෙම සාධනය ඵලදායී ලෙස සත්‍යාපනය කිරීමට හැකි වේ.

බැටරිය ලෙස හැඳින්වේ ගතික ඔබට මූලද්‍රව්‍ය එකතු කිරීමට සහ කට්ටලයකින් මූලද්‍රව්‍ය ඉවත් කිරීමට ඉඩ දෙන්නේ නම්.

එවැනි බැටරියක උදාහරණයක් වනු ඇත 2018 දෙසැම්බර් මාසයේදී Boneh, Bunz, Fisch විසින් යෝජනා කරන ලද RSA සමුච්චකය. එවැනි ඇකියුලේටරයක ගබඩා කර ඇති නිරූපනයේ නියත ප්රමාණය ඇත, නමුත් පැමිණීම අවශ්ය වේ බෙදාගත් රහස (විශ්වාසදායී සැකසුම). මෙම අවශ්‍යතාවය Bitcoin වැනි විශ්වාස රහිත ජාල සඳහා එවැනි සමුච්චයක යෙදීම ප්‍රතික්ෂේප කරයි, මන්ද රහසිගත උත්පාදනය අතරතුර දත්ත කාන්දු වීම ප්‍රහාරකයන්ට UTXO පැවැත්ම පිළිබඳ ව්‍යාජ සාක්ෂි නිර්මාණය කිරීමට ඉඩ දිය හැකි බැවින්, එවැනි සමුච්චයක් මත පදනම් වූ UTXO කට්ටලයක් සහිත නෝඩ් රැවටීම.

Utreexo

Thaddeus Dryja විසින් යෝජනා කරන ලද Utreexo නිර්මාණය නිර්මාණය කිරීමට හැකි වේ ගතික බැටරිය තොරව විශ්වාසනීය-සැකසුම.

Utreexo යනු පරිපූර්ණ ද්විමය වනාන්තරයකි මර්කල් ගස් සහ ඉදිරිපත් කරන ලද අදහස්වල වර්ධනයකි බෙදා හරින ලද pki සඳහා කාර්යක්ෂම අසමමිතික සමුච්චකය, කට්ටලයකින් මූලද්රව්ය ඉවත් කිරීමේ හැකියාව එකතු කිරීම.

බැටරි තාර්කික ව්යුහය

බැටරි සෛල පරිපූර්ණ ද්විමය ගස් වනාන්තරයක සකස් කර ඇත. ගස් උස අනුව නියම කර ඇත. මෙම නිරූපණය වඩාත් දෘශ්‍ය ලෙස තෝරාගෙන ඇති අතර බැටරියේ මෙහෙයුම් වලදී ගස් ඒකාබද්ධ කිරීම දෘශ්‍යමාන කිරීමට ඔබට ඉඩ සලසයි.

ඕනෑම ස්වාභාවික සංඛ්‍යාවක් දෙකක බල එකතුවක් ලෙස නිරූපණය කළ හැකි සේම, වනාන්තරයේ ඇති සියලුම ගස් පරමාදර්ශී බැවින්, ඒවායේ උස දෙකේ බලයක් ලෙස ප්‍රකාශ වන බව කතුවරයා සඳහන් කරයි. ඒ අනුව, ඕනෑම කොළ කට්ටලයක් ද්විමය ගස් ලෙස කාණ්ඩ කළ හැකි අතර, සෑම අවස්ථාවකදීම, නව මූලද්රව්යයක් එකතු කිරීම සඳහා දැනුම අවශ්ය වේ. ගබඩා කර ඇති ගස්වල මුල් නෝඩ් ගැන පමණි.

මේ අනුව, Utreexo accumulator හි ගබඩා කර ඇති නිරූපණය මූල නෝඩ් ලැයිස්තුවකි (Merkle root), මුළු ගස් වනාන්තරයම නොවේ.

මූල මූලද්‍රව්‍ය ලැයිස්තුව ලෙස නිරූපණය කරමු 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(), ලබා දී ඇති මූලද්‍රව්‍ය දෙකක් සඳහා මාපිය නෝඩය හඳුනා ගනී.

මාපිය () කාර්යය

අපි මර්කල් ගස් භාවිතා කරන බැවින්, එක් එක් නෝඩ් දෙකෙහි මාපිය ළමා නෝඩ් වල හෑෂ්වල හෑෂ් ගබඩා කරන එක් නෝඩයක් වේ:

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), ඔබට බැටරියට මූලද්‍රව්‍යයක් එකතු කර ඇති බවට සාක්ෂි නිර්මාණය කළ හැකිය. මෙය සිදු කිරීම සඳහා, අපි සිදු කරන ලද වෙනස්කම් වගුව හරහා ගොස් එක් එක් පියවර මර්කල්ගේ මාර්ගයට එක් කරන්න, එය පසුව සාක්ෂියක් ලෙස සේවය කරනු ඇත:

කේතය

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
    }
}

සාක්ෂියක් නිර්මාණය කිරීමේ ක්රියාවලිය

මූලද්රව්යයක් සඳහා සාක්ෂි පරීක්ෂා කිරීම

මූලද්‍රව්‍යයක් ඇතුළත් කිරීමේ සාධනය පරීක්ෂා කිරීම, එය පවතින මූල මූලද්‍රව්‍යයකට ගෙන යන තෙක් මර්කල් මාර්ගය අනුගමනය කිරීම දක්වා පහත වැටේ:

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
    }
}

දෘශ්යමය වශයෙන්:

A සඳහා සාක්ෂි පරීක්ෂා කිරීමේ ක්රියාවලිය

අයිතම ඉවත් කිරීම

බැටරියකින් සෛලයක් ඉවත් කිරීම සඳහා, ඔබ සෛලය එහි ඇති බවට වලංගු සාක්ෂි සැපයිය යුතුය. සාධනයේ දත්ත භාවිතා කරමින්, දී ඇති සාක්ෂිය තවදුරටත් සත්‍ය නොවන සමුච්චකයේ නව මූල මූලද්‍රව්‍ය ගණනය කළ හැකිය.

ඇල්ගොරිතම පහත පරිදි වේ:

මීට අමතරව, අපි කූඩ දර්ශකයෙන් දෙකක බලයට සමාන උසකින් යුත් මර්කල් ගස්වලට අනුරූප හිස් බාස්කට් කට්ටලයක් සංවිධානය කරමු.
අපි මර්කල් මාර්ගයේ පියවරෙන් මූලද්රව්ය කූඩවලට ඇතුල් කරන්නෙමු; බාස්කට් දර්ශකය වත්මන් පියවර ගණනට සමාන වේ
සාධනයෙන් මාර්ගය යොමු කරන මූල මූලද්‍රව්‍යය අපි ඉවත් කරමු
එකතු කිරීමේදී මෙන්, අපි නව මූල මූලද්‍රව්‍ය ගණනය කරන්නේ කූඩවල මූලද්‍රව්‍ය යුගල වශයෙන් ඒකාබද්ධ කර ඊළඟ කූඩයට එකමුතුවේ ප්‍රතිඵලය ගෙන යාමෙනි.

කේතය

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;
    }
}

"A" මූලද්රව්යය ඉවත් කිරීමේ ක්රියාවලිය:

පවතින ජාලයකට ඒකාබද්ධ වීම

යෝජිත සමුච්චකය භාවිතා කරමින්, UTXO-කට්ටලය වෙනස් කිරීමට හැකි වන අතරම සියලුම UTXOs ගබඩා කිරීමට DB භාවිතා කිරීම නෝඩ් වලට මග හැරිය හැක. කෙසේ වෙතත්, සාක්ෂි සමඟ වැඩ කිරීමේ ගැටළුව පැන නගී.

UTXO accumulator භාවිතා කරන Validator node එක කියමු සංගත (සංයුක්ත-රාජ්ය නෝඩය), සහ සමුච්චයක් නොමැති වලංගුකාරකය වේ සම්පූර්ණයි (සම්පූර්ණ නෝඩය). සංයුක්ත නෝඩ් සඳහා ගණුදෙණු සඳහා වැය වන UTXOs පවතින බවට සාක්ෂි අවශ්‍ය වන අතර සම්පූර්ණ නෝඩ් එසේ නොවන බැවින්, නෝඩ් කාණ්ඩ දෙකක පැවැත්ම ඒවා තනි ජාලයකට ඒකාබද්ධ කිරීමේ ගැටලුවක් නිර්මාණය කරයි. සියලුම ජාල නෝඩ් එකවර සහ සම්බන්ධීකරණ ආකාරයකින් Utreexo භාවිතා කිරීමට මාරු නොවන්නේ නම්, සංයුක්ත නෝඩ් ඉතිරි වන අතර Bitcoin ජාලය මත ක්‍රියා කිරීමට නොහැකි වනු ඇත.

ජාලයට සංයුක්ත නෝඩ් ඒකාබද්ධ කිරීමේ ගැටළුව විසඳීම සඳහා, අතිරේක නෝඩ් පන්තියක් හඳුන්වා දීමට යෝජනා කෙරේ - පාලම්. පාලම් නෝඩයක් යනු Utreexo බැටරිය සහ බලය ක්‍රියාත්මක වන සාක්ෂි ගබඩා කරන සම්පූර්ණ නෝඩයකි всех UTXO-කට්ටලයෙන් UTXO. පාලම් නව හෑෂ් ගණනය කර නව ගණුදෙනු කොටස් පැමිණෙන විට සමුච්චකය සහ සාක්ෂි යාවත්කාලීන කරයි. ඇකියුලේටරය සහ සාධනය නඩත්තු කිරීම සහ යාවත්කාලීන කිරීම එවැනි නෝඩ් මත අමතර ගණනය කිරීමේ බරක් පැටවෙන්නේ නැත. පාලම් තැටි අවකාශය කැප කරයි: දේවල් පිළිවෙලට තබා ගත යුතුය හෑෂ්, හා සසඳන විට සංයුක්ත නෝඩ් සඳහා හෑෂ්, n යනු UTXO කට්ටලයේ බලයයි.

ජාල ගෘහ නිර්මාණ ශිල්පය

පවතින නෝඩ් වල මෘදුකාංග වෙනස් නොකර ක්‍රමයෙන් ජාලයට සංයුක්ත නෝඩ් එක් කිරීමට පාලම් මඟින් හැකියාව ලැබේ. සම්පූර්ණ නෝඩ් පෙර මෙන් ක්‍රියාත්මක වන අතර, ඔවුන් අතර ගනුදෙනු සහ බ්ලොක් බෙදා හරිනු ලැබේ. පාලම් නෝඩ් යනු Utreexo බැටරි දත්ත අතිරේකව ගබඩා කරන සම්පූර්ණ නෝඩ් සහ ඇතුළත් කිරීමේ සාක්ෂි සමූහයකි. всех දැනට UTXO. බ්‍රිජ් නෝඩය සියලුම සම්පූර්ණ නෝඩ් සඳහා සම්පූර්ණ නෝඩයක් ලෙසත් සියලු සංයුක්ත ඒවා සඳහා සංයුක්ත නෝඩයක් ලෙසත් මවාපාමින් තමන්ව ප්‍රචාරය නොකරයි. පාලම් ජාල දෙකම එකට සම්බන්ධ කළද, ඇත්ත වශයෙන්ම ඒවා සම්බන්ධ කිරීමට අවශ්‍ය වන්නේ එක් දිශාවකට පමණි: පවතින සම්පූර්ණ නෝඩ් සිට සංයුක්ත නෝඩ් දක්වා. ගනුදෙනු ආකෘතිය වෙනස් කිරීමට අවශ්‍ය නොවන නිසාත්, සංයුක්ත නෝඩ් සඳහා UTXO සාධනය ඉවත දැමිය හැකි නිසාත් මෙය කළ හැකිය, එබැවින් ඕනෑම සංයුක්ත නෝඩයකට බ්‍රිජ් නෝඩ් වල සහභාගීත්වයෙන් තොරව සියලුම ජාල සහභාගිවන්නන් වෙත ගනුදෙනු විකාශනය කළ හැකිය.

නිගමනය

අපි Utreexo බැටරිය දෙස බලා එහි මූලාකෘතිය Rust හි ක්රියාත්මක කළෙමු. අපි බැටරි මත පදනම් වූ නෝඩ් ඒකාබද්ධ කිරීමට ඉඩ සලසන ජාල ගෘහ නිර්මාණ ශිල්පය දෙස බැලුවෙමු. සංයුක්ත අල්ලා ගැනීමේ වාසිය වන්නේ ගබඩා කරන ලද දත්තවල ප්‍රමාණය වන අතර එය UTXOs කට්ටලයේ බලය මත ලඝුගණක ලෙස රඳා පවතී, එමඟින් එවැනි නෝඩ් සඳහා තැටි ඉඩ සහ ගබඩා ක්‍රියාකාරිත්වය සඳහා වන අවශ්‍යතා බෙහෙවින් අඩු කරයි. අවාසිය නම් සාක්ෂි සම්ප්‍රේෂණය කිරීම සඳහා අමතර නෝඩ් ගමනාගමනය වන නමුත් සාක්ෂි එකතු කිරීමේ ක්‍රම (එක් සාක්ෂියක් මූලද්‍රව්‍ය කිහිපයක පැවැත්ම සනාථ කරන විට) සහ හැඹිලිය මඟින් ගමනාගමනය පිළිගත හැකි සීමාවන් තුළ තබා ගැනීමට උපකාරී වේ.

යොමු: