🥇Utreexo: بہت سے UTXO Bitcoin کو کمپریس کرنا

ارے حبر!

بٹ کوائن نیٹ ورک میں، تمام نوڈس، اتفاق رائے سے، UTXOs کے ایک سیٹ پر متفق ہیں: خرچ کرنے کے لیے کتنے سکے دستیاب ہیں، بالکل کس کے لیے، اور کن حالات میں۔ UTXO سیٹ ایک تصدیق کنندہ نوڈ کے لیے درکار ڈیٹا کا کم از کم سیٹ ہے، جس کے بغیر نوڈ آنے والی ٹرانزیکشنز اور ان پر مشتمل بلاکس کی درستگی کی تصدیق نہیں کر سکے گا۔

اس سلسلے میں، ہر ممکن طریقے سے کوشش کی جا رہی ہے کہ اس سیٹ کی ذخیرہ شدہ نمائندگی کو کم کیا جائے، حفاظتی ضمانتوں سے محروم کیے بغیر اسے کم کیا جائے۔ ذخیرہ شدہ ڈیٹا کا حجم جتنا کم ہوگا، ویلیڈیٹر نوڈ کی ڈسک اسپیس کی ضروریات اتنی ہی کم ہوں گی، جو کہ ایک توثیق کار نوڈ کو شروع کرنا سستا بناتا ہے، آپ کو نیٹ ورک کو وسعت دینے اور اس طرح نیٹ ورک کے استحکام کو بڑھانے کی اجازت دیتا ہے۔

اس پوسٹ میں ہم شریک مصنف کی طرف سے حالیہ تجویز کا ایک مورچا پروٹو ٹائپ پوسٹ کریں گے۔ بجلی کا نیٹ ورک پیپر, تھڈیوس ڈریجا - Utreexo: Bitcoin UTXO سیٹ کے لیے ایک متحرک ہیش پر مبنی جمع کرنے والا، جو توثیق کرنے والے نوڈس کے لئے ڈسک کی جگہ کی ضروریات کو کم کرنے کی اجازت دیتا ہے۔

مسئلہ کیا ہے؟

بٹ کوائن کے بارہماسی مسائل میں سے ایک اس کی توسیع پذیری ہے۔ "آپ کے اپنے بینک" کے خیال کے لیے نیٹ ورک کے شرکاء کو استعمال کے لیے دستیاب تمام فنڈز کا ریکارڈ رکھنے کی ضرورت ہوتی ہے۔ Bitcoin میں، دستیاب فنڈز کو غیر خرچ شدہ پیداوار کے ایک سیٹ کے طور پر ظاہر کیا جاتا ہے - ایک UTXO- سیٹ۔ اگرچہ یہ کوئی خاص طور پر بدیہی نمائندگی نہیں ہے، لیکن یہ ایک ایسی نمائندگی پر عمل درآمد کی کارکردگی کے لحاظ سے فائدہ مند ہے جس میں ہر "بٹوے" میں ایک الگ اندراج کے طور پر "بیلنس" ہوتا ہے، اور رازداری بھی شامل کرتا ہے (مثال کے طور پر CoinJoin).

لین دین کی تاریخ (جسے بلاک چین کہا جاتا ہے) اور نظام کی موجودہ حالت کے درمیان فرق کرنا ضروری ہے۔ بٹ کوائن کی لین دین کی تاریخ فی الحال تقریباً 200 GB ڈسک کی جگہ پر قابض ہے، اور بڑھ رہی ہے۔ تاہم، نظام کی حالت 4 جی بی کے آرڈر پر بہت چھوٹی ہے، اور صرف اس حقیقت کو مدنظر رکھتی ہے کہ فی الحال کسی کے پاس سکے ہیں۔ اس ڈیٹا کا حجم بھی وقت کے ساتھ بڑھتا جاتا ہے، لیکن بہت سست رفتار سے اور بعض اوقات کم ہونے کا رجحان بھی ہوتا ہے (سی ڈی پی وی دیکھیں)۔

ہلکے کلائنٹس (SPVs) تجارتی تحفظ کی ضمانت دیتا ہے کہ نجی چابیاں کے علاوہ کوئی کم از کم حالت (UTXO-set) ذخیرہ کرنے کی صلاحیت نہیں ہے۔

UTXO اور UTXO سیٹ

UTXO (غیر خرچ شدہ ٹرانزیکشن آؤٹ پٹ) غیر خرچ شدہ ٹرانزیکشن آؤٹ پٹ ہے، لین دین میں منتقل ہونے والے ہر ساتوشی کے سفر کا آخری نقطہ۔ غیر خرچ شدہ آؤٹ پٹ نئے لین دین کے ان پٹ بن جاتے ہیں اور اس طرح خرچ (خرچ) اور UTXO سیٹ سے ہٹا دیا جاتا ہے۔

نئے UTXO ہمیشہ لین دین کے ذریعے بنائے جاتے ہیں:

ان پٹ کے بغیر سکے بیس لین دین: جب کان کن سکے جاری کرتے ہیں تو نئے UTXOs بنائیں
باقاعدہ لین دین: موجودہ UTXOs کے ایک مخصوص سیٹ کو خرچ کرتے ہوئے نئے UTXOs بنائیں

UTXO کے ساتھ کام کرنے کا عمل:

بٹوے خرچ کرنے کے لیے دستیاب UTXO کی مقدار کی بنیاد پر خرچ کرنے کے لیے دستیاب سکوں کی تعداد (بیلنس) شمار کرتے ہیں۔

ہر توثیق کرنے والے نوڈ کو، دوگنا خرچ کرنے کی کوششوں کو روکنے کے لیے، سیٹ کی نگرانی کرنی چاہیے۔ تمام چیک کرتے وقت UTXO ہر ایک لین دین ہر ایک بلاک

نوڈ میں منطق ہونا ضروری ہے:

UTXO سیٹ میں اضافے
UTXO سیٹ سے حذف کرنا
ایک سیٹ میں واحد UTXO کی موجودگی کی جانچ کرنا

عناصر کو شامل کرنے اور ہٹانے کی صلاحیت کو برقرار رکھتے ہوئے، سیٹ کے بارے میں ذخیرہ شدہ معلومات کی ضروریات کو کم کرنے کے طریقے ہیں کرپٹوگرافک جمع کرنے والے.

UTXO کے لیے بیٹریاں

متعدد UTXOs کو ذخیرہ کرنے کے لیے بیٹریاں استعمال کرنے کا خیال بحث کی گئی پہلے.

ابتدائی بلاک ڈاؤن لوڈ (IBD) کے دوران، UTXO-set کو فلائی پر بنایا گیا ہے، مکمل اور مستقل طور پر ذخیرہ کیا جاتا ہے، جبکہ نیٹ ورک کے ہر نئے اور درست بلاک سے لین دین کی کارروائی کے بعد اس کے مواد تبدیل ہو جاتے ہیں۔ اس عمل کے لیے تقریباً 200 GB بلاک ڈیٹا ڈاؤن لوڈ کرنے اور لاکھوں ڈیجیٹل دستخطوں کی تصدیق کی ضرورت ہوتی ہے۔ IBD عمل مکمل ہونے کے بعد، سب سے اہم بات یہ ہے کہ UTXO-set تقریباً 4 GB پر قبضہ کرے گا۔

تاہم، جمع کرنے والوں کے ساتھ، فنڈز کے لیے اتفاق رائے کے قوانین کو خفیہ ثبوتوں کی تصدیق اور تخلیق تک کم کر دیا جاتا ہے، اور دستیاب فنڈز کو ٹریک کرنے کا بوجھ ان فنڈز کے مالک پر ڈال دیا جاتا ہے، جو ان کے وجود اور ملکیت کا ثبوت فراہم کرتا ہے۔

ایک جمع کرنے والے کو سیٹ کی کمپیکٹ نمائندگی کہا جا سکتا ہے۔ ذخیرہ شدہ نمائندگی کا سائز یا تو مستقل ہونا چاہیے۔ ، یا سیٹ کی بنیادی حیثیت اور عنصر کے سائز کے حوالے سے ذیلی طور پر اضافہ کریں، مثال کے طور پر ، جہاں n ذخیرہ شدہ سیٹ کی بنیادی حیثیت ہے۔

اس صورت میں، جمع کرنے والے کو سیٹ میں کسی عنصر کی شمولیت کا ثبوت (انکلوزیشن پروف) پیدا کرنے کی اجازت دینی چاہیے اور اس ثبوت کی مؤثر طریقے سے تصدیق کرنا ممکن بنانا چاہیے۔

بیٹری کہا جاتا ہے۔ متحرک اگر آپ کو عناصر کو شامل کرنے اور سیٹ سے عناصر کو ہٹانے کی اجازت دیتا ہے۔

اس طرح کی بیٹری کی ایک مثال ہوگی۔ دسمبر 2018 میں Boneh، Bunz، Fisch کی طرف سے تجویز کردہ RSA جمع کرنے والا. اس طرح کے جمع کرنے والے میں ذخیرہ شدہ نمائندگی کا مستقل سائز ہوتا ہے، لیکن اس کی موجودگی کی ضرورت ہوتی ہے۔ مشترکہ راز (قابل اعتماد سیٹ اپ)۔ یہ ضرورت Bitcoin جیسے بے اعتماد نیٹ ورکس کے لیے اس طرح کے جمع کرنے والے کے قابل اطلاق ہونے کی نفی کرتی ہے، کیونکہ خفیہ جنریشن کے دوران ڈیٹا کا اخراج حملہ آوروں کو UTXO کے وجود کا جھوٹا ثبوت بنانے کی اجازت دے سکتا ہے، اس طرح کے جمع کرنے والے کی بنیاد پر UTXO-سیٹ والے نوڈس کو دھوکہ دے سکتا ہے۔

Utreexo

Thaddeus Dryja کی طرف سے تجویز کردہ 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()، جو دو دیئے گئے عناصر کے لئے پیرنٹ نوڈ کو پہچانتا ہے۔

والدین () فنکشن

چونکہ ہم مرکل کے درختوں کا استعمال کر رہے ہیں، اس لیے دونوں نوڈس میں سے ہر ایک کا پیرنٹ ایک نوڈ ہے جو چائلڈ نوڈس کی ہیشز کے کنکٹنیشن کی ہیش کو اسٹور کرتا ہے:

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

شامل کیے جانے والے عناصر کو شامل کریں (array 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,
}

عنصر شامل کرتے وقت پہلے حاصل کردہ معلومات کا استعمال کرتے ہوئے (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, &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" کو ہٹانے کا عمل:

موجودہ نیٹ ورک میں انضمام

مجوزہ جمع کرنے والے کا استعمال کرتے ہوئے، نوڈس تمام UTXOs کو ذخیرہ کرنے کے لیے DB استعمال کرنے سے گریز کر سکتے ہیں جبکہ UTXO-set کو تبدیل کرنے کے قابل بھی ہیں۔ تاہم، ثبوت کے ساتھ کام کرنے کا مسئلہ پیدا ہوتا ہے.

آئیے تصدیق کرنے والے نوڈ کو کال کریں جو UTXO جمع کرنے والا استعمال کرتا ہے۔ کمپیکٹ (compact-state node)، اور validator بغیر جمع کرنے والا ہے۔ مکمل (مکمل نوڈ) نوڈس کے دو طبقوں کا وجود انہیں ایک نیٹ ورک میں ضم کرنے میں ایک مسئلہ پیدا کرتا ہے، کیونکہ کمپیکٹ نوڈس کو UTXOs کے وجود کے ثبوت کی ضرورت ہوتی ہے، جو کہ لین دین میں خرچ ہوتے ہیں، جبکہ مکمل نوڈس ایسا نہیں کرتے ہیں۔ اگر تمام نیٹ ورک نوڈس بیک وقت اور مربوط طریقے سے Utreexo استعمال کرنے پر سوئچ نہیں کرتے ہیں، تو کمپیکٹ نوڈس پیچھے رہ جائیں گے اور Bitcoin نیٹ ورک پر کام نہیں کر سکیں گے۔

نیٹ ورک میں کمپیکٹ نوڈس کو ضم کرنے کے مسئلے کو حل کرنے کے لیے، نوڈس کی ایک اضافی کلاس متعارف کرانے کی تجویز ہے۔ پل. برج نوڈ ایک مکمل نوڈ ہے جو Utreexo بیٹری اور پاور آن پروف کو بھی ذخیرہ کرتا ہے تمام UTXO سیٹ سے UTXO۔ لین دین کے نئے بلاکس آتے ہی پل نئی ہیشوں کا حساب لگاتے ہیں اور جمع کرنے والے اور ثبوتوں کو اپ ڈیٹ کرتے ہیں۔ جمع کرنے والے اور ثبوتوں کو برقرار رکھنے اور اپ ڈیٹ کرنے سے ایسے نوڈس پر اضافی کمپیوٹیشنل بوجھ نہیں پڑتا ہے۔ پل ڈسک کی جگہ کی قربانی دیتے ہیں: چیزوں کو منظم رکھنے کی ضرورت ہے۔ ہیش، کے مقابلے میں کمپیکٹ نوڈس کے لیے ہیش، جہاں n UTXO سیٹ کی طاقت ہے۔

نیٹ ورک فن تعمیر

پل موجودہ نوڈس کے سافٹ ویئر کو تبدیل کیے بغیر نیٹ ورک میں بتدریج کمپیکٹ نوڈس کو شامل کرنا ممکن بناتے ہیں۔ مکمل نوڈس پہلے کی طرح کام کرتے ہیں، آپس میں لین دین اور بلاکس تقسیم کرتے ہیں۔ برج نوڈس مکمل نوڈس ہیں جو اضافی طور پر Utreexo بیٹری کا ڈیٹا اور شامل کرنے کے ثبوتوں کا ایک سیٹ ذخیرہ کرتے ہیں۔ تمام UTXO ابھی کے لیے۔ برج نوڈ اپنی تشہیر اس طرح نہیں کرتا ہے، تمام مکمل نوڈس کے لیے ایک مکمل نوڈ اور تمام کمپیکٹ والوں کے لیے ایک کمپیکٹ نوڈ ہونے کا بہانہ کرتا ہے۔ اگرچہ پل دونوں نیٹ ورکس کو آپس میں جوڑتے ہیں، لیکن انہیں درحقیقت انہیں صرف ایک سمت میں جوڑنے کی ضرورت ہوتی ہے: موجودہ مکمل نوڈس سے کمپیکٹ نوڈس تک۔ یہ اس لیے ممکن ہے کیونکہ لین دین کی شکل کو تبدیل کرنے کی ضرورت نہیں ہے، اور کمپیکٹ نوڈس کے لیے UTXO ثبوتوں کو رد کیا جا سکتا ہے، اس لیے کوئی بھی کمپیکٹ نوڈ برج نوڈس کی شرکت کے بغیر تمام نیٹ ورک کے شرکاء کے لیے لین دین کو اسی طرح نشر کر سکتا ہے۔

حاصل يہ ہوا

ہم نے Utreexo بیٹری کو دیکھا اور اس کے پروٹو ٹائپ کو Rust میں نافذ کیا۔ ہم نے نیٹ ورک کے فن تعمیر کو دیکھا جو بیٹری پر مبنی نوڈس کے انضمام کی اجازت دے گا۔ کمپیکٹ کیچز کا فائدہ ذخیرہ شدہ ڈیٹا کا سائز ہے، جس کا انحصار UTXOs کے سیٹ کی طاقت پر ہوتا ہے، جو اس طرح کے نوڈس کے لیے ڈسک کی جگہ اور اسٹوریج کی کارکردگی کی ضروریات کو بہت کم کر دیتا ہے۔ نقصان ثبوتوں کو منتقل کرنے کے لیے اضافی نوڈ ٹریفک ہے، لیکن ثبوت جمع کرنے کی تکنیک (جب ایک ثبوت کئی عناصر کی موجودگی کو ثابت کرتا ہے) اور کیشنگ ٹریفک کو قابل قبول حدود میں رکھنے میں مدد کر سکتی ہے۔

حوالہ جات:

ماخذ: www.habr.com

Utreexo: بہت سے UTXO Bitcoin کو کمپریس کرنا

مسئلہ کیا ہے؟

UTXO اور UTXO سیٹ

UTXO کے لیے بیٹریاں

Utreexo

بیٹری کا منطقی ڈھانچہ

عناصر کو شامل کرنا

اضافی عناصر کے لیے ثبوت بنانا

کسی عنصر کے ثبوت کی جانچ کرنا

اشیاء کو ہٹانا

موجودہ نیٹ ورک میں انضمام

نیٹ ورک فن تعمیر

حاصل يہ ہوا

نیا تبصرہ شامل کریں جواب منسوخ کریں