హే హబ్ర్!
బిట్‌కాయిన్ నెట్‌వర్క్‌లో, అన్ని నోడ్‌లు, ఏకాభిప్రాయం ద్వారా, UTXOల సమితిని అంగీకరిస్తాయి: ఖర్చు చేయడానికి ఎన్ని నాణేలు అందుబాటులో ఉన్నాయి, ఎవరికి ఖచ్చితంగా మరియు ఏ పరిస్థితుల్లో ఉన్నాయి. UTXO సెట్ అనేది వాలిడేటర్ నోడ్‌కు అవసరమైన కనీస డేటా సెట్, ఇది లేకుండా నోడ్ ఇన్‌కమింగ్ లావాదేవీల చెల్లుబాటును మరియు వాటిని కలిగి ఉన్న బ్లాక్‌లను ధృవీకరించదు.
ఈ విషయంలో, ఈ సెట్ యొక్క నిల్వ చేయబడిన ప్రాతినిధ్యాన్ని తగ్గించడానికి, భద్రతా హామీలను కోల్పోకుండా దానిని కుదించడానికి ప్రతి సాధ్యమైన మార్గంలో ప్రయత్నాలు జరుగుతున్నాయి. నిల్వ చేయబడిన డేటా పరిమాణం ఎంత తక్కువగా ఉంటే, వాలిడేటర్ నోడ్ యొక్క డిస్క్ స్పేస్ అవసరాలు తక్కువగా ఉంటాయి, ఇది వాలిడేటర్ నోడ్‌ను చౌకగా లాంచ్ చేస్తుంది, ఇది నెట్‌వర్క్‌ను విస్తరించడానికి మరియు తద్వారా నెట్వర్క్ యొక్క స్థిరత్వాన్ని పెంచడానికి మిమ్మల్ని అనుమతిస్తుంది.
ఈ పోస్ట్‌లో మేము సహ రచయిత నుండి ఇటీవలి ప్రతిపాదన యొక్క రస్ట్ ప్రోటోటైప్‌ను పోస్ట్ చేస్తాము , - , ఇది వాలిడేటర్ నోడ్‌ల కోసం డిస్క్ స్పేస్ అవసరాలను తగ్గించడానికి అనుమతిస్తుంది.
మీరు సమస్య ఏమిటి?
Bitcoin యొక్క శాశ్వత సమస్యలలో ఒకటి దాని స్కేలబిలిటీ. "మీ స్వంత బ్యాంక్" ఆలోచన కోసం నెట్వర్క్ పాల్గొనేవారు ఉపయోగం కోసం అందుబాటులో ఉన్న అన్ని నిధుల రికార్డులను ఉంచాలి. Bitcoinలో, అందుబాటులో ఉన్న నిధులు ఖర్చు చేయని అవుట్‌పుట్‌ల సమితిగా వ్యక్తీకరించబడతాయి - UTXO-సెట్. ఇది ప్రత్యేకించి సహజమైన ప్రాతినిధ్యం కానప్పటికీ, ప్రతి "వాలెట్" ప్రత్యేక ప్రవేశంగా "బ్యాలెన్స్"ని కలిగి ఉండే ప్రాతినిధ్యంపై అమలు పనితీరు పరంగా ప్రయోజనకరంగా ఉంటుంది మరియు గోప్యతను కూడా జోడిస్తుంది (ఉదా. ).
లావాదేవీల చరిత్ర (బ్లాక్‌చెయిన్ అని పిలవబడేది) మరియు సిస్టమ్ యొక్క ప్రస్తుత స్థితి మధ్య తేడాను గుర్తించడం చాలా ముఖ్యం. Bitcoin లావాదేవీ చరిత్ర ప్రస్తుతం 200 GB డిస్క్ స్థలాన్ని తీసుకుంటుంది మరియు పెరుగుతూనే ఉంది. అయినప్పటికీ, సిస్టమ్ స్థితి 4 GB క్రమంలో చాలా చిన్నది మరియు ప్రస్తుతం ఎవరైనా నాణేలను కలిగి ఉన్నారనే వాస్తవాన్ని మాత్రమే పరిగణనలోకి తీసుకుంటుంది. ఈ డేటా పరిమాణం కూడా కాలక్రమేణా పెరుగుతుంది, కానీ చాలా నెమ్మదిగా ఉంటుంది మరియు కొన్నిసార్లు తగ్గుతుంది (CDPV చూడండి).
ప్రైవేట్ కీలు కాకుండా కనీస స్థితిని (UTXO-సెట్) నిల్వ చేయలేని సామర్థ్యానికి లైట్ క్లయింట్లు (SPVలు) వాణిజ్య భద్రత హామీలు.
UTXO మరియు UTXO-సెట్
UTXO (అన్ స్పెంట్ ట్రాన్సాక్షన్ అవుట్‌పుట్) అనేది ఖర్చు చేయని లావాదేవీ అవుట్‌పుట్, లావాదేవీలలో బదిలీ చేయబడిన ప్రతి సతోషి ప్రయాణం యొక్క ముగింపు స్థానం. ఖర్చు చేయని అవుట్‌పుట్‌లు కొత్త లావాదేవీల ఇన్‌పుట్‌లుగా మారతాయి మరియు తద్వారా ఖర్చు చేయబడతాయి (ఖర్చు చేస్తాయి) మరియు UTXO-సెట్ నుండి తీసివేయబడతాయి.
కొత్త UTXOలు ఎల్లప్పుడూ లావాదేవీల ద్వారా సృష్టించబడతాయి:
- ఇన్‌పుట్‌లు లేకుండా కాయిన్‌బేస్ లావాదేవీలు: మైనర్లు నాణేలను జారీ చేసినప్పుడు కొత్త UTXOలను సృష్టించండి
- సాధారణ లావాదేవీలు: ఇప్పటికే ఉన్న UTXOల యొక్క నిర్దిష్ట సెట్‌ను ఖర్చు చేస్తున్నప్పుడు కొత్త UTXOలను సృష్టించండి
UTXOతో పని చేసే ప్రక్రియ:
వాలెట్‌లు ఈ వాలెట్‌కు ఖర్చు చేయడానికి అందుబాటులో ఉన్న UTXO మొత్తం ఆధారంగా ఖర్చు చేయడానికి అందుబాటులో ఉన్న నాణేల సంఖ్యను (బ్యాలెన్స్) లెక్కిస్తాయి.
ప్రతి వ్యాలిడేటర్ నోడ్, డబుల్ ఖర్చు ప్రయత్నాలను నిరోధించడానికి, తప్పనిసరిగా సెట్‌ను పర్యవేక్షించాలి всех తనిఖీ చేస్తున్నప్పుడు UTXO ప్రతి లావాదేవీలు ప్రతి నిరోధించు.
నోడ్ తప్పనిసరిగా లాజిక్ కలిగి ఉండాలి:
- UTXO-సెట్‌కి చేర్పులు
- UTXO-సెట్ నుండి తొలగింపులు
- ఒక సెట్‌లో ఒకే UTXO ఉనికిని తనిఖీ చేస్తోంది
ఎలిమెంట్‌లను జోడించడం మరియు తీసివేయడం, ఉపయోగించి సెట్‌లో ఒక మూలకం ఉనికిని తనిఖీ చేయడం మరియు నిరూపించడం వంటి సామర్థ్యాన్ని కొనసాగిస్తూ, సెట్ గురించి నిల్వ చేయబడిన సమాచారం కోసం అవసరాలను తగ్గించడానికి మార్గాలు ఉన్నాయి. .
UTXO కోసం బ్యాటరీలు
బహుళ UTXOలను నిల్వ చేయడానికి బ్యాటరీలను ఉపయోగించాలనే ఆలోచన .
UTXO-సెట్ నెట్‌వర్క్‌లోని ప్రతి కొత్త మరియు సరైన బ్లాక్ నుండి లావాదేవీలను ప్రాసెస్ చేసిన తర్వాత దాని కంటెంట్‌లు మారుతున్నప్పుడు, ప్రారంభ బ్లాక్ డౌన్‌లోడ్ (IBD) సమయంలో పూర్తిగా మరియు శాశ్వతంగా నిల్వ చేయబడినప్పుడు, ఫ్లైలో నిర్మించబడింది. ఈ ప్రక్రియకు దాదాపు 200 GB బ్లాక్ డేటాను డౌన్‌లోడ్ చేయడం మరియు వందల మిలియన్ల డిజిటల్ సంతకాలను ధృవీకరించడం అవసరం. IBD ప్రక్రియ పూర్తయిన తర్వాత, బాటమ్ లైన్ ఏమిటంటే UTXO-సెట్ దాదాపు 4 GBని ఆక్రమిస్తుంది.
అయితే, సంచితాలతో, నిధుల కోసం ఏకాభిప్రాయ నియమాలు క్రిప్టోగ్రాఫిక్ రుజువుల ధృవీకరణ మరియు ఉత్పత్తికి తగ్గించబడ్డాయి మరియు అందుబాటులో ఉన్న నిధులను ట్రాక్ చేసే భారం ఆ నిధుల యజమానికి బదిలీ చేయబడుతుంది, వారు వారి ఉనికి మరియు యాజమాన్యానికి రుజువును అందిస్తారు.
ఒక సంచితాన్ని సమితి యొక్క కాంపాక్ట్ ప్రాతినిధ్యం అని పిలుస్తారు. నిల్వ చేయబడిన ప్రాతినిధ్యం యొక్క పరిమాణం తప్పనిసరిగా స్థిరంగా ఉండాలి , లేదా సెట్ యొక్క కార్డినాలిటీ మరియు మూలకం యొక్క పరిమాణానికి సంబంధించి సబ్‌లీనియర్‌గా పెంచండి, ఉదాహరణకు , ఇక్కడ n అనేది నిల్వ చేయబడిన సెట్ యొక్క కార్డినాలిటీ.
ఈ సందర్భంలో, అక్యుమ్యులేటర్ సెట్‌లో ఒక మూలకాన్ని చేర్చినట్లు రుజువును రూపొందించడానికి అనుమతించాలి (చేర్పు రుజువు) మరియు ఈ రుజువును సమర్థవంతంగా ధృవీకరించడం సాధ్యమవుతుంది.
బ్యాటరీ అంటారు డైనమిక్ ఒక సెట్ నుండి ఎలిమెంట్‌లను జోడించడానికి మరియు ఎలిమెంట్‌లను తీసివేయడానికి మిమ్మల్ని అనుమతిస్తే.
అటువంటి బ్యాటరీకి ఉదాహరణగా ఉంటుంది . అటువంటి సంచితం నిల్వ చేయబడిన ప్రాతినిధ్యం యొక్క స్థిరమైన పరిమాణాన్ని కలిగి ఉంటుంది, కానీ ఉనికి అవసరం రహస్యాన్ని పంచుకున్నారు (విశ్వసనీయ సెటప్). ఈ అవసరం బిట్‌కాయిన్ వంటి నమ్మదగని నెట్‌వర్క్‌ల కోసం అటువంటి అక్యుమ్యులేటర్ యొక్క వర్తింపును తిరస్కరిస్తుంది, ఎందుకంటే రహస్య ఉత్పత్తి సమయంలో డేటా లీకేజీ దాడి చేసేవారు UTXO ఉనికికి తప్పుడు రుజువుని సృష్టించడానికి అనుమతిస్తుంది, అటువంటి సంచితం ఆధారంగా UTXO-సెట్‌తో నోడ్‌లను మోసం చేస్తుంది.
Utreexo
థాడియస్ డ్రైజా ప్రతిపాదించిన Utreexo డిజైన్ సృష్టించడం సాధ్యం చేస్తుంది డైనమిక్ аккумулятор లేకుండా విశ్వసనీయ-సెటప్.
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(), ఇది ఇచ్చిన రెండు మూలకాల కోసం పేరెంట్ నోడ్‌ను గుర్తిస్తుంది.
పేరెంట్() ఫంక్షన్
మేము మెర్కిల్ ట్రీలను ఉపయోగిస్తున్నందున, రెండు నోడ్‌లలో ప్రతిదానికి పేరెంట్ ఒక నోడ్, ఇది చైల్డ్ నోడ్‌ల హాష్‌ల సంయోగం యొక్క హాష్‌ను నిల్వ చేస్తుంది:
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);- మొదటి బుట్టకు జోడించిన వస్తువులను మిగిలిన వాటితో కలపండి:
- ఒకటి కంటే ఎక్కువ వస్తువులు ఉన్న అన్ని కార్ట్‌ల కోసం:
- బుట్ట చివర నుండి రెండు మూలకాలను తీసుకోండి, వారి పేరెంట్‌ను లెక్కించండి, రెండు అంశాలను తీసివేయండి
- తదుపరి కార్ట్‌కు లెక్కించబడిన పేరెంట్‌ని జోడించండి
- ఒకటి కంటే ఎక్కువ వస్తువులు ఉన్న అన్ని కార్ట్‌ల కోసం:
కోడ్
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, ¤t_parent)
} else {
parent(¤t_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-సెట్‌ను మార్చగలిగినప్పటికీ అన్ని UTXOలను నిల్వ చేయడానికి DBని ఉపయోగించకుండా నివారించవచ్చు. అయితే, ఆధారాలతో పని చేయడంలో సమస్య తలెత్తుతుంది.
UTXO అక్యుమ్యులేటర్‌ని ఉపయోగించే వాలిడేటర్ నోడ్‌ని పిలుద్దాం కాంపాక్ట్ (కాంపాక్ట్-స్టేట్ నోడ్), మరియు అక్యుమ్యులేటర్ లేని వ్యాలిడేటర్ పూర్తి (పూర్తి నోడ్). రెండు తరగతుల నోడ్‌ల ఉనికి వాటిని ఒకే నెట్‌వర్క్‌లో ఏకీకృతం చేయడానికి సమస్యను సృష్టిస్తుంది, ఎందుకంటే కాంపాక్ట్ నోడ్‌లకు లావాదేవీలలో ఖర్చు చేయబడిన UTXOల ఉనికికి రుజువు అవసరం, అయితే పూర్తి నోడ్‌లు చేయవు. అన్ని నెట్వర్క్ నోడ్‌లు ఏకకాలంలో మరియు సమన్వయ పద్ధతిలో Utreexoని ఉపయోగించకపోతే, కాంపాక్ట్ నోడ్‌లు మిగిలిపోతాయి మరియు బిట్‌కాయిన్ నెట్‌వర్క్‌లో ఆపరేట్ చేయలేరు.
నెట్‌వర్క్‌లో కాంపాక్ట్ నోడ్‌లను ఏకీకృతం చేసే సమస్యను పరిష్కరించడానికి, అదనపు తరగతి నోడ్‌లను పరిచయం చేయాలని ప్రతిపాదించబడింది - వంతెనలు. బ్రిడ్జ్ నోడ్ అనేది Utreexo బ్యాటరీ మరియు పవర్-ఆన్ ప్రూఫ్‌ను కూడా నిల్వ చేసే పూర్తి నోడ్ всех UTXO-సెట్ నుండి UTXO. బ్రిడ్జ్‌లు కొత్త హ్యాష్‌లను లెక్కిస్తాయి మరియు లావాదేవీల యొక్క కొత్త బ్లాక్‌లు వచ్చినప్పుడు అక్యుమ్యులేటర్ మరియు ప్రూఫ్‌లను అప్‌డేట్ చేస్తాయి. అక్యుమ్యులేటర్ మరియు ప్రూఫ్‌లను నిర్వహించడం మరియు నవీకరించడం అటువంటి నోడ్‌లపై అదనపు గణన భారాన్ని విధించదు. వంతెనలు డిస్క్ స్థలాన్ని త్యాగం చేస్తాయి: విషయాలను క్రమబద్ధంగా ఉంచడం అవసరం హాష్‌లతో పోలిస్తే కాంపాక్ట్ నోడ్‌ల కోసం హ్యాష్‌లు, ఇక్కడ n అనేది UTXO సెట్ యొక్క పవర్.
నెట్వర్క్ ఆర్కిటెక్చర్
వంతెనలు ఇప్పటికే ఉన్న నోడ్‌ల సాఫ్ట్‌వేర్‌ను మార్చకుండా నెట్‌వర్క్‌కు కాంపాక్ట్ నోడ్‌లను క్రమంగా జోడించడాన్ని సాధ్యం చేస్తాయి. పూర్తి నోడ్‌లు మునుపటిలా పనిచేస్తాయి, తమలో తాము లావాదేవీలు మరియు బ్లాక్‌లను పంపిణీ చేస్తాయి. బ్రిడ్జ్ నోడ్‌లు పూర్తి నోడ్‌లు, ఇవి అదనంగా Utreexo బ్యాటరీ డేటా మరియు ఇన్‌క్లూజన్ ప్రూఫ్‌ల సమితిని నిల్వ చేస్తాయి. всех ప్రస్తుతానికి UTXO. బ్రిడ్జ్ నోడ్ అన్ని పూర్తి నోడ్‌లకు పూర్తి నోడ్‌గా మరియు అన్ని కాంపాక్ట్ నోడ్‌లకు కాంపాక్ట్ నోడ్‌గా నటిస్తూ తనంతట తానుగా ప్రచారం చేసుకోదు. వంతెనలు రెండు నెట్‌వర్క్‌లను ఒకదానితో ఒకటి అనుసంధానించినప్పటికీ, వాస్తవానికి వాటిని ఒక దిశలో మాత్రమే కనెక్ట్ చేయాలి: ఇప్పటికే ఉన్న పూర్తి నోడ్‌ల నుండి కాంపాక్ట్ నోడ్‌లకు. లావాదేవీ ఆకృతిని మార్చాల్సిన అవసరం లేనందున ఇది సాధ్యమవుతుంది మరియు కాంపాక్ట్ నోడ్‌ల కోసం UTXO ప్రూఫ్‌లు విస్మరించబడతాయి, కాబట్టి ఏదైనా కాంపాక్ట్ నోడ్ బ్రిడ్జ్ నోడ్‌ల భాగస్వామ్యం లేకుండానే నెట్వర్క్ పార్టిసిపెంట్లందరికీ లావాదేవీలను ప్రసారం చేయగలదు.
తీర్మానం
మేము Utreexo బ్యాటరీని చూసాము మరియు రస్ట్‌లో దాని నమూనాను అమలు చేసాము. బ్యాటరీ ఆధారిత నోడ్‌ల ఏకీకరణను అనుమతించే నెట్వర్క్ నిర్మాణాన్ని మేము చూశాము. కాంపాక్ట్ క్యాచ్‌ల యొక్క ప్రయోజనం నిల్వ చేయబడిన డేటా యొక్క పరిమాణం, ఇది UTXOల సమితి యొక్క శక్తిపై లాగరిథమిక్‌గా ఆధారపడి ఉంటుంది, ఇది డిస్క్ స్థలం మరియు అటువంటి నోడ్‌ల నిల్వ పనితీరు కోసం అవసరాలను బాగా తగ్గిస్తుంది. ప్రతికూలత ఏమిటంటే రుజువులను ప్రసారం చేయడానికి అదనపు నోడ్ ట్రాఫిక్, కానీ సాక్ష్యం అగ్రిగేషన్ పద్ధతులు (ఒక రుజువు అనేక మూలకాల ఉనికిని రుజువు చేసినప్పుడు) మరియు కాషింగ్ ఆమోదయోగ్యమైన పరిమితుల్లో ట్రాఫిక్‌ను ఉంచడంలో సహాయపడతాయి.
సూచనలు:
- -
మూలం: www.habr.com