Utreexo: பல UTXO Bitcoin ஐ சுருக்குகிறது

ஹே ஹப்ர்!

பிட்காயின் நெட்வொர்க்கில், அனைத்து முனைகளும், ஒருமித்த கருத்து மூலம், UTXO களின் தொகுப்பை ஒப்புக்கொள்கின்றன: செலவழிக்க எத்தனை நாணயங்கள் உள்ளன, யாருக்கு, எந்த நிபந்தனைகளின் கீழ். UTXO தொகுப்பு என்பது ஒரு வேலிடேட்டர் முனைக்குத் தேவையான குறைந்தபட்ச தரவுத் தொகுப்பாகும், இது இல்லாமல் உள்வரும் பரிவர்த்தனைகளின் செல்லுபடியை மற்றும் அவற்றைக் கொண்ட தொகுதிகளை முனையால் சரிபார்க்க முடியாது.

இது சம்பந்தமாக, இந்த தொகுப்பின் சேமிக்கப்பட்ட பிரதிநிதித்துவத்தை குறைக்க, பாதுகாப்பு உத்தரவாதங்களை இழக்காமல் சுருக்க, சாத்தியமான எல்லா வழிகளிலும் முயற்சிகள் மேற்கொள்ளப்படுகின்றன. சேமிக்கப்பட்ட தரவின் அளவு சிறியது, வேலிடேட்டர் முனையின் வட்டு இடத் தேவைகள் குறையும், இது ஒரு வேலிடேட்டர் முனையைத் தொடங்குவதை மலிவானதாக்குகிறது, இது பிணையத்தை விரிவாக்கவும் அதன் மூலம் பிணையத்தின் நிலைத்தன்மையை அதிகரிக்கவும் உங்களை அனுமதிக்கிறது.

இந்த இடுகையில் இணை ஆசிரியரின் சமீபத்திய முன்மொழிவின் ரஸ்ட் முன்மாதிரியை இடுகையிடுவோம் மின்னல் நெட்வொர்க் பேப்பர், தாடியஸ் டிரைஜா - Utreexo: Bitcoin UTXO தொகுப்பிற்கு உகந்ததாக ஒரு டைனமிக் ஹாஷ் அடிப்படையிலான குவிப்பான், இது வேலிடேட்டர் முனைகளுக்கான வட்டு இடத் தேவைகளைக் குறைக்க அனுமதிக்கிறது.

இது பிரச்சனையா?

பிட்காயினின் வற்றாத பிரச்சனைகளில் ஒன்று அதன் அளவிடுதல் ஆகும். "உங்கள் சொந்த வங்கி" என்ற யோசனைக்கு நெட்வொர்க் பங்கேற்பாளர்கள் பயன்பாட்டிற்கு கிடைக்கும் அனைத்து நிதிகளின் பதிவுகளையும் வைத்திருக்க வேண்டும். பிட்காயினில், கிடைக்கும் நிதியானது செலவழிக்கப்படாத வெளியீடுகளின் தொகுப்பாக வெளிப்படுத்தப்படுகிறது - ஒரு UTXO-தொகுப்பு. இது குறிப்பாக உள்ளுணர்வு பிரதிநிதித்துவம் இல்லை என்றாலும், ஒவ்வொரு "வாலட்" ஒரு தனி நுழைவாக "இருப்பு" கொண்டிருக்கும் பிரதிநிதித்துவத்தின் மீது செயல்படுத்தும் செயல்திறனின் அடிப்படையில் நன்மை பயக்கும், மேலும் தனியுரிமையையும் சேர்க்கிறது (எ.கா. CoinJoin).

பரிவர்த்தனைகளின் வரலாறு (பிளாக்செயின் என்று அழைக்கப்படுகிறது) மற்றும் அமைப்பின் தற்போதைய நிலை ஆகியவற்றை வேறுபடுத்துவது முக்கியம். பிட்காயின் பரிவர்த்தனை வரலாறு தற்போது சுமார் 200 ஜிபி வட்டு இடத்தை ஆக்கிரமித்துள்ளது, மேலும் தொடர்ந்து வளர்ந்து வருகிறது. இருப்பினும், கணினி நிலை 4 ஜிபி வரிசையில் மிகவும் சிறியது, மேலும் தற்போது யாரோ ஒருவர் நாணயங்களை வைத்திருக்கிறார் என்ற உண்மையை மட்டுமே கணக்கில் எடுத்துக்கொள்கிறார். இந்தத் தரவின் அளவும் காலப்போக்கில் அதிகரிக்கிறது, ஆனால் மிகவும் மெதுவான விகிதத்தில் மற்றும் சில சமயங்களில் குறைய முனைகிறது (சிடிபிவியைப் பார்க்கவும்).

லைட் கிளையண்டுகள் (SPVகள்) தனிப்பட்ட விசைகளைத் தவிர வேறு எந்த குறைந்தபட்ச நிலையையும் (UTXO-செட்) சேமிக்கும் திறனுக்கான வர்த்தக பாதுகாப்பு உத்தரவாதம்.

UTXO மற்றும் UTXO-செட்

UTXO (செலவிடப்படாத பரிவர்த்தனை வெளியீடு) என்பது செலவழிக்கப்படாத பரிவர்த்தனை வெளியீடு, பரிவர்த்தனைகளில் மாற்றப்படும் ஒவ்வொரு சடோஷியின் பயணத்தின் இறுதிப் புள்ளியாகும். செலவழிக்கப்படாத வெளியீடுகள் புதிய பரிவர்த்தனைகளின் உள்ளீடுகளாக மாறும்.

புதிய UTXOக்கள் எப்போதும் பரிவர்த்தனைகளால் உருவாக்கப்படுகின்றன:

• உள்ளீடுகள் இல்லாமல் coinbase பரிவர்த்தனைகள்: சுரங்கத் தொழிலாளர்கள் நாணயங்களை வெளியிடும்போது புதிய UTXOகளை உருவாக்கவும்
• வழக்கமான பரிவர்த்தனைகள்: தற்போதுள்ள UTXO களின் ஒரு குறிப்பிட்ட தொகுப்பை செலவழிக்கும் போது புதிய UTXO களை உருவாக்கவும்

UTXO உடன் பணிபுரியும் செயல்முறை:

இந்த பணப்பையில் செலவழிப்பதற்காக கிடைக்கும் UTXO தொகையின் அடிப்படையில், பணப்பைகள் செலவழிக்க (பேலன்ஸ்) கிடைக்கும் நாணயங்களின் எண்ணிக்கையை கணக்கிடும்.

ஒவ்வொரு வேலிடேட்டர் முனையும், இரட்டைச் செலவு முயற்சிகளைத் தடுக்க, தொகுப்பைக் கண்காணிக்க வேண்டும் всех சரிபார்க்கும் போது UTXO ஒவ்வொன்றும் பரிவர்த்தனைகள் ஒவ்வொருவரும் தொகுதி.

முனையில் தர்க்கம் இருக்க வேண்டும்:

• UTXO-செட்டில் சேர்த்தல்
• UTXO-தொகுப்பில் இருந்து நீக்குதல்
• ஒரு தொகுப்பில் ஒற்றை UTXO இருப்பதைச் சரிபார்க்கிறது

ஒரு தொகுப்பைப் பற்றிய சேமித்த தகவலுக்கான தேவைகளைக் குறைப்பதற்கான வழிகள் உள்ளன, அதே நேரத்தில் கூறுகளைச் சேர்க்கும் மற்றும் அகற்றும் திறனைப் பராமரிக்கும் போது, ​​ஒரு தொகுப்பில் ஒரு உறுப்பு இருப்பதைச் சரிபார்த்து நிரூபிக்கவும் கிரிப்டோகிராஃபிக் திரட்டிகள்.

UTXO க்கான பேட்டரிகள்

பல UTXO களை சேமிக்க பேட்டரிகளைப் பயன்படுத்துவதற்கான யோசனை விவாதிக்கப்பட்டது முந்தைய.

UTXO-தொகுப்பு, ஆரம்ப பிளாக் டவுன்லோட் (IBD) நேரத்தில், முழுமையாகவும் நிரந்தரமாகவும் சேமிக்கப்படும், அதே நேரத்தில் நெட்வொர்க்கின் ஒவ்வொரு புதிய மற்றும் சரியான தொகுதியிலிருந்தும் பரிவர்த்தனைகளைச் செயலாக்கிய பிறகு அதன் உள்ளடக்கங்கள் மாறும். இந்தச் செயல்பாட்டிற்கு சுமார் 200 ஜிபி பிளாக் டேட்டாவைப் பதிவிறக்குவது மற்றும் நூற்றுக்கணக்கான மில்லியன் டிஜிட்டல் கையொப்பங்களைச் சரிபார்க்க வேண்டும். IBD செயல்முறை முடிந்ததும், UTXO-தொகுப்பு சுமார் 4 ஜிபியை ஆக்கிரமித்துக்கொள்ளும் என்பது முக்கிய அம்சமாகும்.

இருப்பினும், திரட்டிகளுடன், நிதிக்கான ஒருமித்த விதிகள் சரிபார்ப்பு மற்றும் கிரிப்டோகிராஃபிக் சான்றுகளின் உருவாக்கத்திற்கு குறைக்கப்படுகின்றன, மேலும் கிடைக்கக்கூடிய நிதிகளைக் கண்காணிப்பதற்கான சுமை அந்த நிதிகளின் உரிமையாளருக்கு மாற்றப்படுகிறது, அவர் அவற்றின் இருப்பு மற்றும் உரிமைக்கான ஆதாரத்தை வழங்குகிறது.

ஒரு திரட்டியை ஒரு தொகுப்பின் சிறிய பிரதிநிதித்துவம் என்று அழைக்கலாம். சேமிக்கப்பட்ட பிரதிநிதித்துவத்தின் அளவு நிலையானதாக இருக்க வேண்டும் , அல்லது தொகுப்பின் கார்டினாலிட்டி மற்றும் தனிமத்தின் அளவைப் பொறுத்து கீழ்நிலையாக அதிகரிக்கவும், எடுத்துக்காட்டாக , இங்கு n என்பது சேமிக்கப்பட்ட தொகுப்பின் கார்டினாலிட்டி.

இந்த வழக்கில், திரட்டியானது தொகுப்பில் ஒரு உறுப்பைச் சேர்த்ததற்கான ஆதாரத்தை உருவாக்க அனுமதிக்க வேண்டும் (சேர்க்கும் ஆதாரம்) மற்றும் இந்த ஆதாரத்தை திறம்பட சரிபார்க்க முடியும்.

பேட்டரி அழைக்கப்படுகிறது மாறும் ஒரு தொகுப்பிலிருந்து கூறுகளைச் சேர்க்க மற்றும் உறுப்புகளை அகற்ற உங்களை அனுமதித்தால்.

அத்தகைய பேட்டரிக்கு ஒரு எடுத்துக்காட்டு டிசம்பர் 2018 இல் Boneh, Bunz, Fisch ஆகியோரால் முன்மொழியப்பட்ட RSA அக்யூமுலேட்டர். அத்தகைய ஒரு குவிப்பான் சேமிக்கப்பட்ட பிரதிநிதித்துவத்தின் நிலையான அளவைக் கொண்டுள்ளது, ஆனால் இருப்பு தேவைப்படுகிறது பகிரப்பட்ட ரகசியம் (நம்பகமான அமைப்பு). இந்தத் தேவை பிட்காயின் போன்ற நம்பகமற்ற நெட்வொர்க்குகளுக்கு இதுபோன்ற ஒரு திரட்டியின் பொருந்தக்கூடிய தன்மையை நிராகரிக்கிறது, ஏனெனில் ரகசிய உருவாக்கத்தின் போது தரவு கசிவு தாக்குதல் நடத்துபவர்கள் UTXO இருப்பதற்கான தவறான ஆதாரத்தை உருவாக்க அனுமதிக்கலாம், அத்தகைய குவிப்பானின் அடிப்படையில் UTXO-செட் கொண்ட முனைகளை ஏமாற்றலாம்.

உட்ரீக்ஸோ

தாடியஸ் ட்ரைஜாவால் முன்மொழியப்பட்ட Utreexo வடிவமைப்பு உருவாக்குவதை சாத்தியமாக்குகிறது மாறும் аккумулятор இல்லாமல் நம்பகமான அமைப்பு.

Utreexo ஒரு சரியான பைனரி காடு மெர்க்கல் மரங்கள் மற்றும் இது முன்வைக்கப்பட்ட யோசனைகளின் வளர்ச்சியாகும் விநியோகிக்கப்பட்ட pki க்கான திறமையான ஒத்திசைவற்ற திரட்டிகள், ஒரு தொகுப்பிலிருந்து உறுப்புகளை அகற்றும் திறனைச் சேர்த்தல்.

பேட்டரி தருக்க அமைப்பு

சிறந்த பைனரி மரங்களின் காட்டில் பேட்டரி செல்கள் அமைக்கப்பட்டிருக்கின்றன. மரங்கள் உயரத்தால் வரிசைப்படுத்தப்படுகின்றன. இந்த பிரதிநிதித்துவம் மிகவும் காட்சிக்குரியதாகத் தேர்ந்தெடுக்கப்பட்டது மற்றும் பேட்டரியின் செயல்பாட்டின் போது மரங்கள் ஒன்றிணைவதைக் காட்சிப்படுத்த உங்களை அனுமதிக்கிறது.

காட்டில் உள்ள அனைத்து மரங்களும் சிறந்தவை என்பதால், எந்த இயற்கை எண்ணையும் இரண்டு சக்திகளின் கூட்டுத்தொகையாகக் குறிப்பிடுவது போல, அவற்றின் உயரம் இரண்டின் சக்தியாக வெளிப்படுத்தப்படுகிறது என்று ஆசிரியர் குறிப்பிடுகிறார். அதன்படி, எந்த இலைகளின் தொகுப்பையும் பைனரி மரங்களாக தொகுக்கலாம், மேலும் எல்லா சந்தர்ப்பங்களிலும், ஒரு புதிய உறுப்பைச் சேர்ப்பதற்கு அறிவு தேவைப்படுகிறது. சேமிக்கப்பட்ட மரங்களின் வேர் முனைகள் பற்றி மட்டுமே.

இவ்வாறு, Utreexo திரட்டியின் சேமிக்கப்பட்ட பிரதிநிதித்துவமானது ரூட் முனைகளின் பட்டியல் (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(), இது இரண்டு கொடுக்கப்பட்ட உறுப்புகளுக்கான பெற்றோர் முனையை அங்கீகரிக்கிறது.

பெற்றோர்() செயல்பாடு

நாங்கள் 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[..])
}

சார்லஸ் பூலாகுட், பியர்-அலைன் ஃபூக், ஆதி ஷமிர் மற்றும் செபாஸ்டின் ஜிம்மர் ஆகியோரால் விவரிக்கப்பட்ட தாக்குதல்களைத் தடுக்க ஆசிரியர் குறிப்பிடுகிறார்.
சிதைந்த ஹாஷ் செயல்பாடுகளில் இரண்டாவது ப்ரீமேஜ் தாக்குதல்கள், இரண்டு ஹாஷ்கள் கூடுதலாக, மரத்தின் உள்ளே உள்ள உயரத்தையும் இணைக்க வேண்டும்.

நீங்கள் குவிப்பானில் கூறுகளைச் சேர்க்கும்போது, ​​எந்த ரூட் உறுப்புகள் மாற்றப்படுகின்றன என்பதை நீங்கள் கண்காணிக்க வேண்டும். நீங்கள் சேர்க்கும் ஒவ்வொரு உறுப்புக்கும் ரூட் உறுப்புகளை மாற்றுவதற்கான பாதையைப் பின்பற்றுவதன் மூலம், இந்த உறுப்புகளின் இருப்புக்கான ஆதாரத்தை நீங்கள் பின்னர் உருவாக்கலாம்.

மாற்றங்களைச் சேர்க்கும்போது அவற்றைக் கண்காணிக்கவும்

செய்யப்பட்ட மாற்றங்களைக் கண்காணிக்க, கட்டமைப்பை அறிவிப்போம் 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 க்கான ஆதாரத்தை சரிபார்க்கும் செயல்முறை

பொருட்களை அகற்றுதல்

பேட்டரியிலிருந்து ஒரு கலத்தை அகற்ற, செல் உள்ளது என்பதற்கான சரியான ஆதாரத்தை நீங்கள் வழங்க வேண்டும். ஆதாரத்திலிருந்து தரவைப் பயன்படுத்தி, திரட்டியின் புதிய மூல கூறுகளைக் கணக்கிட முடியும், அதற்கான ஆதாரம் இனி உண்மையாக இருக்காது.

வழிமுறை பின்வருமாறு:

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

உறுப்பு "A" அகற்றும் செயல்முறை:

ஏற்கனவே உள்ள நெட்வொர்க்கில் ஒருங்கிணைப்பு

முன்மொழியப்பட்ட திரட்டியைப் பயன்படுத்தி, UTXO-செட்டை மாற்றும் போது அனைத்து UTXO களையும் சேமிக்க DB ஐப் பயன்படுத்துவதை முனைகள் தவிர்க்கலாம். இருப்பினும், ஆதாரங்களுடன் வேலை செய்வதில் சிக்கல் எழுகிறது.

UTXO திரட்டியைப் பயன்படுத்தும் வேலிடேட்டர் முனையை அழைப்போம் கச்சிதமான (காம்பாக்ட்-ஸ்டேட் நோட்), மற்றும் திரட்டி இல்லாத வேலிடேட்டர் முழு (முழு முனை). இரண்டு வகை முனைகளின் இருப்பு அவற்றை ஒரே நெட்வொர்க்கில் ஒருங்கிணைப்பதில் சிக்கலை உருவாக்குகிறது, ஏனெனில் கச்சிதமான முனைகளுக்கு UTXO களின் இருப்புக்கான ஆதாரம் தேவைப்படுகிறது, அவை பரிவர்த்தனைகளில் செலவிடப்படுகின்றன, அதே நேரத்தில் முழு முனைகளும் இல்லை. அனைத்து நெட்வொர்க் முனைகளும் ஒரே நேரத்தில் மற்றும் ஒருங்கிணைந்த முறையில் Utreexo ஐப் பயன்படுத்துவதற்கு மாறவில்லை என்றால், கச்சிதமான முனைகள் பின்தங்கியிருக்கும் மற்றும் பிட்காயின் நெட்வொர்க்கில் செயல்பட முடியாது.

நெட்வொர்க்கில் கச்சிதமான முனைகளை ஒருங்கிணைப்பதில் உள்ள சிக்கலைத் தீர்க்க, கூடுதல் வகை முனைகளை அறிமுகப்படுத்த முன்மொழியப்பட்டது - பாலங்கள். பிரிட்ஜ் நோட் என்பது Utreexo பேட்டரி மற்றும் பவர்-ஆன் ஆதாரத்தையும் சேமிக்கும் ஒரு முழுமையான முனை ஆகும் всех UTXO-தொகுப்பில் இருந்து UTXO. புதிய பரிவர்த்தனைகள் வரும்போது பிரிட்ஜ்கள் புதிய ஹாஷ்களைக் கணக்கிட்டு, திரட்டி மற்றும் சான்றுகளைப் புதுப்பிக்கும். திரட்டி மற்றும் சான்றுகளை பராமரித்தல் மற்றும் புதுப்பித்தல் போன்ற கணுகளில் கூடுதல் கணக்கீட்டு சுமையை சுமத்துவதில்லை. பாலங்கள் வட்டு இடத்தை தியாகம் செய்கின்றன: விஷயங்களை ஒழுங்கமைக்க வேண்டும் ஹாஷ்கள், ஒப்பிடும்போது காம்பாக்ட் நோட்களுக்கான ஹாஷ்கள், இங்கு n என்பது UTXO தொகுப்பின் சக்தி.

நெட்வொர்க் கட்டமைப்பு

ஏற்கனவே உள்ள முனைகளின் மென்பொருளை மாற்றாமல் பிணையத்தில் கச்சிதமான முனைகளை படிப்படியாக சேர்ப்பதை பாலங்கள் சாத்தியமாக்குகின்றன. முழு முனைகள் முன்பு போலவே செயல்படுகின்றன, பரிவர்த்தனைகள் மற்றும் தொகுதிகளை தங்களுக்குள் விநியோகிக்கின்றன. பிரிட்ஜ் நோட்கள் முழு முனைகளாகும் всех இப்போதைக்கு UTXO. பிரிட்ஜ் நோட் தன்னை விளம்பரப்படுத்திக் கொள்ளாது, அனைத்து முழு முனைகளுக்கும் முழு முனையாகவும், அனைத்து கச்சிதமானவற்றுக்கு ஒரு சிறிய முனையாகவும் பாசாங்கு செய்கிறது. பாலங்கள் இரண்டு நெட்வொர்க்குகளையும் ஒன்றாக இணைத்தாலும், அவை உண்மையில் அவற்றை ஒரு திசையில் மட்டுமே இணைக்க வேண்டும்: ஏற்கனவே உள்ள முழு முனைகளிலிருந்து சிறிய முனைகளுக்கு. பரிவர்த்தனை வடிவத்தை மாற்ற வேண்டிய அவசியமில்லை, மேலும் கச்சிதமான முனைகளுக்கான UTXO சான்றுகள் நிராகரிக்கப்படலாம் என்பதால் இது சாத்தியமாகும், எனவே எந்த சிறிய முனையும் பிரிட்ஜ் நோட்களின் பங்கேற்பு இல்லாமல் அனைத்து நெட்வொர்க் பங்கேற்பாளர்களுக்கும் பரிவர்த்தனைகளை ஒளிபரப்ப முடியும்.

முடிவுக்கு

நாங்கள் Utreexo பேட்டரியைப் பார்த்து அதன் முன்மாதிரியை ரஸ்டில் செயல்படுத்தினோம். பேட்டரி அடிப்படையிலான முனைகளை ஒருங்கிணைக்க அனுமதிக்கும் நெட்வொர்க் கட்டமைப்பைப் பார்த்தோம். காம்பாக்ட் கேட்ச்களின் நன்மை, சேமிக்கப்பட்ட தரவின் அளவு ஆகும், இது UTXO களின் தொகுப்பின் சக்தியை மடக்கை சார்ந்தது, இது வட்டு இடம் மற்றும் அத்தகைய முனைகளுக்கான சேமிப்பக செயல்திறனுக்கான தேவைகளை வெகுவாகக் குறைக்கிறது. குறைபாடு என்னவென்றால், ஆதாரங்களை அனுப்புவதற்கான கூடுதல் முனை டிராஃபிக் ஆகும், ஆனால் ஆதாரங்களை திரட்டும் நுட்பங்கள் (ஒரு ஆதாரம் பல கூறுகள் இருப்பதை நிரூபிக்கும் போது) மற்றும் கேச்சிங் ஆகியவை போக்குவரத்தை ஏற்றுக்கொள்ளக்கூடிய வரம்புகளுக்குள் வைத்திருக்க உதவும்.

குறிப்புகள்:

• ரஸ்டில் உள்ள Utreexo முன்மாதிரியின் GitHub
• தாடியஸ் டிரைஜா - Utreexo: Bitcoin UTXO தொகுப்பிற்கு உகந்ததாக ஒரு டைனமிக் ஹாஷ் அடிப்படையிலான குவிப்பான்
• கட்டுரையிலிருந்து அனிமேஷன் விளக்கப்படங்கள்

ஆதாரம்: www.habr.com