اي حبر!
Bitcoin نيٽ ورڪ ۾، سڀئي نوڊس، اتفاق راءِ سان، UTXOs جي هڪ سيٽ تي متفق آهن: خرچ ڪرڻ لاءِ ڪيترا سڪا موجود آهن، جن کي بلڪل، ۽ ڪهڙين حالتن هيٺ. UTXO سيٽ ڊيٽا جو گھٽ ۾ گھٽ سيٽ آھي جيڪو ھڪ تصديق ڪندڙ نوڊ لاءِ گھربل آھي، جنھن کان سواءِ نوڊ ايندڙ ٽرانزيڪشن ۽ انھن تي مشتمل بلاڪن جي صحيحيت جي تصديق نه ڪري سگھندو.
ان سلسلي ۾، هر ممڪن ڪوشش ڪئي پئي وڃي ته هن سيٽ جي محفوظ ڪيل نمائندگي کي گهٽائڻ لاء، ان کي حفاظتي ضمانتون وڃائڻ کان سواء ان کي دٻايو وڃي. ذخيرو ٿيل ڊيٽا جو حجم جيترو ننڍو هوندو، اوترو ئي گھٽ هوندو ڊسڪ اسپيس جي ضرورتن جي تصديق ڪندڙ نوڊ جي، جيڪو سستو هڪ تصديق ڪندڙ نوڊ شروع ڪري ٿو، توهان کي نيٽ ورڪ کي وڌائڻ جي اجازت ڏئي ٿو ۽ انهي سان نيٽ ورڪ جي استحڪام کي وڌايو.
هن پوسٽ ۾ اسان پوسٽ ڪنداسين هڪ زنگ پروٽوٽائپ جو هڪ تازو تجويز جو هڪ ليکڪ کان , - ، جيڪو تصديق ڪندڙ نوڊس لاءِ ڊسڪ اسپيس گهرجن کي گهٽائڻ جي اجازت ڏئي ٿو.
ڇا مسئلو آهي؟
Bitcoin جي دائمي مسئلن مان هڪ آهي ان جي اسپيبلبلٽي. "توهان جي پنهنجي بئنڪ" جو خيال نيٽ ورڪ شرڪت ڪندڙن کي استعمال ڪرڻ لاء موجود سڀني فنڊن جو رڪارڊ رکڻ جي ضرورت آهي. Bitcoin ۾، موجود پئسن جو اظهار ڪيو ويو آهي هڪ سيٽ جي طور تي اڻ خرچ ٿيل پيداوار - هڪ UTXO-سيٽ. جڏهن ته هي هڪ خاص طور تي سمجهه واري نمائندگي نه آهي، اهو هڪ نمائندگي تي عمل درآمد جي ڪارڪردگي جي لحاظ کان فائدي وارو آهي جنهن ۾ هر "والٽ" ۾ هڪ الڳ داخلا طور "بيلنس" آهي، ۽ رازداري پڻ شامل ڪري ٿي (مثال طور. ).
اهو ضروري آهي ته ٽرانزيڪشن جي تاريخ (جنهن کي بلاڪچين سڏيو ويندو آهي) ۽ سسٽم جي موجوده حالت جي وچ ۾ فرق ڪرڻ ضروري آهي. Bitcoin ٽرانزيڪشن جي تاريخ هن وقت تقريباً 200 GB ڊسڪ اسپيس تي قبضو ڪري ٿي، ۽ وڌندي رهي ٿي. بهرحال، سسٽم اسٽيٽ تمام ننڍو آهي، 4 GB جي آرڊر تي، ۽ صرف ان حقيقت تي ڌيان ڏئي ٿو ته ڪو ماڻهو هن وقت سکن جو مالڪ آهي. هن ڊيٽا جو حجم پڻ وقت سان وڌي ٿو، پر تمام سست رفتار تي ۽ ڪڏهن ڪڏهن به گهٽجي ويندو آهي (ڏسو CDPV).
لائيٽ ڪلائنٽ (SPVs) واپاري حفاظت جي ضمانت ڏئي ٿو محفوظ ڪرڻ جي صلاحيت لاءِ گھٽ ۾ گھٽ اسٽيٽ (UTXO-set) پرائيويٽ ڪنجين کان سواءِ.
UTXO ۽ UTXO-سيٽ
UTXO (اڻ خرچ ٿيل ٽرانزيڪشن آئوٽ) اڻ خرچ ٿيل ٽرانزيڪشن آئوٽ آهي، ٽرانزيڪشن ۾ منتقل ڪيل هر ستوشي جي سفر جو آخري نقطو. غير خرچ ٿيل پيداوار نئين ٽرانزيڪشن جا ان پٽ بڻجي ويندا آهن ۽ اهڙي طرح خرچ ڪيا ويندا آهن (خرچ) ۽ UTXO-سيٽ مان هٽايو ويندو آهي.
نوان UTXO هميشه ٽرانزيڪشن ذريعي ٺاهيا ويا آهن:
- ڪوئن بيس ٽرانزيڪشن بغير انپٽس جي: نوان UTXOs ٺاھيو جڏھن miners سڪا جاري ڪن
- باقاعده ٽرانزيڪشن: نئين UTXOs ٺاهيو جڏهن ته موجوده UTXOs جو هڪ خاص سيٽ خرچ ڪندي
UTXO سان ڪم ڪرڻ جو عمل:
Wallets خرچ ڪرڻ لاءِ موجود سڪن جو تعداد شمار ڪن ٿا (بيلنس) خرچ ڪرڻ لاءِ هن والٽ وٽ موجود UTXO جي رقم جي بنياد تي.
هر تصديق ڪندڙ نوڊ، ڊبل خرچ جي ڪوشش کي روڪڻ لاء، سيٽ جي نگراني ڪرڻ گهرجي всех UTXO جڏھن چيڪ ڪريو هر هڪ ٽرانزيڪشن هر هڪ جو بلاڪ.
نوڊ کي منطق هجڻ گهرجي:
- UTXO-set ۾ اضافو
- UTXO-set مان حذف
- ھڪڙي سيٽ ۾ ھڪڙي UTXO جي موجودگي جي جانچ ڪندي
هڪ سيٽ بابت ذخيرو ٿيل معلومات جي گهرج کي گهٽائڻ جا طريقا آهن، جڏهن ته عناصر کي شامل ڪرڻ ۽ ختم ڪرڻ جي صلاحيت کي برقرار رکڻ، هڪ سيٽ ۾ عنصر جي موجودگي کي جانچڻ ۽ ثابت ڪرڻ .
UTXO لاءِ بيٽريون
ڪيترن ئي UTXOs کي ذخيرو ڪرڻ لاء بيٽري استعمال ڪرڻ جو خيال .
UTXO-سيٽ اڏام تي ٺهيل آهي، شروعاتي بلاڪ ڊائون لوڊ (IBD) دوران، مڪمل ۽ مستقل طور تي ذخيرو ٿيل آهي، جڏهن ته ان جو مواد نيٽ ورڪ جي هر نئين ۽ صحيح بلاڪ کان ٽرانزيڪشن جي پروسيسنگ کان پوء تبديل ٿي ويندو آهي. هن عمل کي لڳ ڀڳ 200 GB بلاڪ ڊيٽا ڊائون لوڊ ڪرڻ ۽ سوين لکن ڊجيٽل دستخطن جي تصديق ڪرڻ جي ضرورت آهي. IBD پروسيس مڪمل ٿيڻ کان پوء، هيٺئين لائن اها آهي ته UTXO-سيٽ تقريبا 4 GB تي قبضو ڪندو.
جڏهن ته، جمع ڪندڙن سان، فنڊن لاءِ اتفاق راءِ جا ضابطا ڪرپٽوگرافڪ ثبوتن جي تصديق ۽ پيدا ڪرڻ ۾ گھٽجي ويندا آهن، ۽ دستياب فنڊن کي ٽريڪ ڪرڻ جو بار انهن فنڊن جي مالڪ ڏانهن منتقل ڪيو ويندو آهي، جيڪو انهن جي وجود ۽ ملڪيت جو ثبوت فراهم ڪري ٿو.
هڪ جمع ڪندڙ کي هڪ سيٽ جي ٺهيل نمائندگي سڏيو وڃي ٿو. ذخيرو ٿيل نمائندگي جي سائيز يا ته مسلسل هجڻ گهرجي ، يا سيٽ جي بنيادي حيثيت ۽ عنصر جي سائيز جي حوالي سان sublinearly وڌايو، مثال طور ، جتي n ذخيرو ٿيل سيٽ جي بنيادي حيثيت آهي.
انهي صورت ۾، جمع ڪندڙ کي سيٽ ۾ هڪ عنصر جي شموليت جو ثبوت پيدا ڪرڻ جي اجازت ڏيڻ گهرجي (شامل ڪرڻ جو ثبوت) ۽ ان کي مؤثر طور تي هن ثبوت جي تصديق ڪرڻ ممڪن بڻائي.
بيٽري سڏيو ويندو آهي متحرڪ جيڪڏهن توهان کي عناصر شامل ڪرڻ ۽ سيٽ مان عناصر کي هٽائڻ جي اجازت ڏئي ٿي.
اهڙي بيٽري جو هڪ مثال ٿيندو . اهڙي هڪ جمع ڪندڙ کي محفوظ ڪيل نمائندگي جي مسلسل سائيز آهي، پر موجودگي جي ضرورت آهي گڏيل راز (قابل اعتماد سيٽ اپ). اها گهرج بي اعتمادي نيٽ ورڪن جهڙوڪ Bitcoin لاءِ اهڙي جمع ڪندڙ جي قابل اطلاق جي نفي ڪري ٿي، ڇو ته ڳجهي نسل جي دوران ڊيٽا جي ليڪ حملي ڪندڙن کي اجازت ڏئي سگهي ٿي ته هو UTXO جي وجود جو غلط ثبوت ٺاهي، اهڙي جمع ڪندڙ جي بنياد تي UTXO-سيٽ سان نوڊس کي ٺڳي.
Utreexo
Thaddeus Dryja پاران تجويز ڪيل Utreexo ڊيزائن کي ٺاهڻ ممڪن بڻائي ٿو متحرڪ аккумулятор بغير قابل اعتماد سيٽ اپ.
Utreexo مڪمل بائنري جو هڪ ٻيلو آهي ۽ پيش ڪيل خيالن جي ترقي آهي ، سيٽ مان عناصر کي هٽائڻ جي صلاحيت شامل ڪرڻ.
بيٽري جي منطقي جوڙجڪ
بيٽري سيلز مثالي بائنري وڻن جي جنگل ۾ ترتيب ڏنل آهن. وڻن جي اوچائي ترتيب ڏني وئي آهي. هي نمائندگي سڀ کان وڌيڪ بصري طور چونڊيو ويو آهي ۽ توهان کي بيٽري تي آپريشن دوران وڻن جي ميلاپ کي ڏسڻ جي اجازت ڏئي ٿي.
ليکڪ نوٽ ڪري ٿو ته جيئن ته جنگل ۾ سڀئي وڻ مثالي آهن، انهن جي اوچائي ٻن طاقتن جي طور تي ظاهر ڪئي وئي آهي، جيئن ڪنهن به قدرتي انگ کي ٻن طاقتن جي مجموعي طور پيش ڪري سگهجي ٿو. ان مطابق، پنن جي ڪنهن به سيٽ کي بائنري وڻن ۾ گروپ ڪري سگهجي ٿو، ۽ سڀني صورتن ۾، نئين عنصر شامل ڪرڻ لاء علم جي ضرورت آهي. صرف ذخيرو ٿيل وڻن جي روٽ نوڊس بابت.
اهڙيء طرح، 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()، جيڪو ٻن ڏنل عنصرن لاءِ والدين نوڊ کي سڃاڻي ٿو.
والدين () فنڪشن
جيئن ته اسان 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[..])
}ليکڪ نوٽ ڪري ٿو ته حملن کي روڪڻ لاءِ بيان ڪيل چارلس بوئليگٽ، پيئر الائن فوڪ، ادي شامير ۽ سيبسٽين زيمر
, ٻن hashes کان علاوه, وڻ جي اندر جي اوچائي به concatenation ۾ شامل ڪيو وڃي.
جئين توهان عناصر کي جمع ڪندڙ ۾ شامل ڪيو ٿا، توهان کي ٽريڪ رکڻ جي ضرورت آهي ته ڪهڙا جزا تبديل ڪيا ويا آهن. هر عنصر جي روٽ عناصر کي تبديل ڪرڻ جي رستي تي عمل ڪندي توهان شامل ڪيو ٿا، توهان بعد ۾ انهن عناصر جي موجودگي جو ثبوت ٺاهي سگهو ٿا.
تبديلين کي ٽريڪ ڪريو جيئن توھان انھن کي شامل ڪريو
ڪيل تبديلين کي ٽريڪ ڪرڻ لاء، اچو ته ساخت جو اعلان ڪريو 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);
}- شامل ڪرڻ لاء عناصر شامل ڪريو (array
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) Merkle Path جي طور تي ڪم ڪندو، ھڪڙي زنجير تي مشتمل آھي 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,
}اڳ ۾ حاصل ڪيل معلومات کي استعمال ڪندي جڏهن هڪ عنصر شامل ڪيو وڃي (structure 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 لاء ثبوت چيڪ ڪرڻ جو عمل
شيون ڪڍڻ
هڪ بيٽري مان سيل کي هٽائڻ لاء، توهان کي لازمي ثبوت مهيا ڪرڻ گهرجي ته سيل موجود آهي. ثبوت مان ڊيٽا استعمال ڪندي، اهو ممڪن آهي ته جمع ڪندڙ جي نئين روٽ عناصر کي ڳڻڻ لاء، جنهن لاء ڏنل ثبوت هاڻي صحيح نه ٿيندو.
الگورتھم ھي as ڏنل آھي:
- اضافي طور تي، اسان مرڪل جي وڻن سان ملندڙ خالي ٽوڪرين جو هڪ سيٽ ترتيب ڏيون ٿا جن جي اوچائي ٽوڪري جي انڊيڪس مان ٻن جي طاقت جي برابر آهي.
- اسان مرڪل رستي جي قدمن مان عناصر کي ٽوڪرين ۾ داخل ڪندا آهيون؛ ٽوڪري انڊيڪس موجوده قدم جي تعداد جي برابر آهي
- اسان روٽ عنصر کي هٽائي ڇڏيون ٿا جنهن ڏانهن ثبوت کان رستو وٺي ٿو
- جيئن شامل ڪرڻ سان، اسان نئين روٽ عناصر کي ٽوڪري مان عناصر کي جوڙي ۾ گڏ ڪندي ۽ يونين جي نتيجي کي ايندڙ ٽوڪري ۾ منتقل ڪندي حساب ڪندا آهيون.
ڪوڊ
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-سيٽ کي تبديل ڪرڻ جي قابل ٿي رهيا آهن. بهرحال، ثبوت سان ڪم ڪرڻ جو مسئلو پيدا ٿئي ٿو.
اچو ته تصديق ڪندڙ نوڊ کي سڏين جيڪو UTXO جمع ڪندڙ استعمال ڪري ٿو ڪمپيڪٽ (compact-state node)، ۽ هڪ جمع ڪندڙ کان سواءِ تصديق ڪندڙ آهي مڪمل (مڪمل نوڊ). نوڊس جي ٻن طبقن جو وجود انھن کي ھڪڙي نيٽ ورڪ ۾ ضم ڪرڻ لاءِ ھڪڙو مسئلو پيدا ڪري ٿو، ڇاڪاڻ ته ڪمپيڪٽ نوڊس کي UTXOs جي وجود جي ثبوت جي ضرورت آھي، جيڪي ٽرانزيڪشن ۾ خرچ ڪيا وڃن ٿا، جڏھن ته مڪمل نوڊس نه آھن. جيڪڏهن سڀئي نيٽ ورڪ نوڊس گڏ نه ٿين ۽ هڪ هموار طريقي سان Utreexo استعمال ڪرڻ لاءِ سوئچ ڪن، ته پوءِ ڪمپيڪٽ نوڊس پوئتي رهجي ويندا ۽ Bitcoin نيٽ ورڪ تي هلائڻ جي قابل نه هوندا.
نيٽ ورڪ ۾ ڪمپيڪٽ نوڊس کي ضم ڪرڻ جي مسئلي کي حل ڪرڻ لاء، اهو تجويز ڪيل آهي ته نوڊس جو هڪ اضافي ڪلاس متعارف ڪرايو. پل. هڪ پل نوڊ هڪ مڪمل نوڊ آهي جيڪو Utreexo جي بيٽري ۽ پاور آن ثبوت کي پڻ محفوظ ڪري ٿو. всех UTXO UTXO-set کان. پل نوان هيش ڳڻڻ ۽ جمع ڪندڙ ۽ ثبوتن کي اپڊيٽ ڪن ٿا جيئن ٽرانزيڪشن جا نوان بلاڪ اچن. جمع ڪندڙ ۽ ثبوتن کي برقرار رکڻ ۽ تازه ڪاري ڪرڻ اهڙن نوڊس تي اضافي ڪمپيوٽيشنل لوڊ نه ٿو ڪري. پل ڊسڪ اسپيس کي قربان ڪن ٿا: شين کي منظم رکڻ جي ضرورت آهي hashes، جي مقابلي ۾ ڪمپيڪٽ نوڊس لاءِ هيش، جتي n UTXO سيٽ جي طاقت آهي.
نيٽ ورڪ فن تعمير
پل اهو ممڪن بڻائي ٿو ته تدريجي طور تي موجوده نوڊس جي سافٽ ويئر کي تبديل ڪرڻ کان سواء نيٽ ورڪ ۾ ڪمپيڪٽ نوڊس شامل ڪرڻ. مڪمل نوڊس اڳ وانگر هلن ٿا، پاڻ ۾ ٽرانزيڪشن ۽ بلاڪ ورهائڻ. پل نوڊس مڪمل نوڊس آھن جيڪي اضافي طور تي Utreexo جي بيٽري ڊيٽا کي ذخيرو ڪن ٿا ۽ شامل ڪرڻ جي ثبوتن جو ھڪڙو سيٽ всех UTXO في الحال. پل نوڊ پاڻ کي اشتهار نٿو ڏئي، جيئن سڀني مڪمل نوڊس لاء مڪمل نوڊ ۽ سڀني ڪمپيڪٽ وارن لاء هڪ ڪمپيڪٽ نوڊ. جيتوڻيڪ پل ٻنهي نيٽ ورڪن کي هڪٻئي سان ڳنڍيندا آهن، انهن کي اصل ۾ صرف انهن کي هڪ طرفي ۾ ڳنڍڻ جي ضرورت آهي: موجوده مڪمل نوڊس کان ڪمپيڪٽ نوڊس تائين. اهو ممڪن آهي ڇاڪاڻ ته ٽرانزيڪشن فارميٽ کي تبديل ڪرڻ جي ضرورت ناهي، ۽ ڪمپيڪٽ نوڊس لاءِ UTXO ثبوت رد ڪري سگھجن ٿا، تنهن ڪري ڪو به ڪمپيڪٽ نوڊ ساڳئي طرح برج نوڊس جي شموليت کان سواءِ سڀني نيٽ ورڪ شرڪت ڪندڙن لاءِ ٽرانزيڪشن نشر ڪري سگهي ٿو.
ٿڪل
اسان Utreexo بيٽري کي ڏٺو ۽ ان جي پروٽوٽائپ کي Rust ۾ لاڳو ڪيو. اسان نيٽ ورڪ آرڪيٽيڪچر کي ڏٺو جيڪو بيٽري تي ٻڌل نوڊس جي انضمام جي اجازت ڏيندو. ڪمپيڪٽ ڪيچز جو فائدو ذخيرو ٿيل ڊيٽا جي سائيز آهي، جيڪو منطقي طور تي UTXOs جي سيٽ جي طاقت تي منحصر هوندو آهي، جيڪو ڊسڪ اسپيس جي ضرورتن کي تمام گهڻو گھٽائي ٿو ۽ اهڙن نوڊس لاء اسٽوريج ڪارڪردگي. نقصان ثبوتن جي منتقلي لاءِ اضافي نوڊ ٽريفڪ آھي، پر ثبوت گڏ ڪرڻ جي ٽيڪنڪ (جڏھن ھڪڙو ثبوت ڪيترن ئي عنصرن جي موجودگي کي ثابت ڪري ٿو) ۽ ڪيشنگ ٽرئفڪ کي قابل قبول حدن اندر رکڻ ۾ مدد ڪري سگھن ٿا.
حوالن:
- -
جو ذريعو: www.habr.com