Hey Habr!
Nan rezo Bitcoin a, tout nœuds, atravè konsansis, dakò sou yon seri UTXO: konbyen pyès monnen ki disponib pou depanse, pou ki moun egzakteman, ak nan ki kondisyon. Ansanm UTXO a se seri minimòm done ki nesesè pou yon ne validateur, san yo pa ne ki pa pral kapab verifye validite tranzaksyon k ap fèk ap rantre yo ak blòk ki genyen yo.
Nan sans sa a, tantativ yo ap fèt nan tout fason posib diminye reprezantasyon ki estoke nan seri sa a, konprese li san yo pa pèdi garanti sekirite. Pi piti volim nan done ki estoke, pi ba kondisyon espas disk nan ne validateur a, ki fè lansman yon ne validateur bon mache, pèmèt ou elaji rezo a ak kidonk ogmante estabilite nan rezo a.
Nan pòs sa a nou pral poste yon pwototip Rust nan yon pwopozisyon resan soti nan yon ko-otè , - , ki pèmèt diminye kondisyon espas disk pou nœuds validateur.
Kisa pwoblèm nan ye?
Youn nan pwoblèm kontinuèl Bitcoin a se évolutivité li yo. Lide "pwòp bank ou" mande pou patisipan rezo yo kenbe dosye tout lajan ki disponib pou itilize. Nan Bitcoin, lajan ki disponib yo eksprime kòm yon seri rezilta ki pa depanse - yon seri UTXO. Pandan ke sa a se pa yon reprezantasyon patikilyèman entwisyon, li benefisye an tèm de pèfòmans aplikasyon sou yon reprezantasyon kote chak "bous" gen yon "balans" kòm yon antre separe, epi tou ajoute vi prive (egzanp. ).
Li enpòtan pou fè distenksyon ant istwa tranzaksyon yo (sa yo rele blockchain la) ak eta aktyèl sistèm lan. Istwa tranzaksyon Bitcoin kounye a okipe apeprè 200 GB espas ki gen kapasite, epi li kontinye ap grandi. Sepandan, eta a sistèm se pi piti anpil, sou lòd la nan 4 GB, epi sèlman pran an kont lefèt ke yon moun kounye a posede pyès monnen. Volim done sa yo ogmante tou sou tan, men nan yon vitès pi dousman epi pafwa menm gen tandans diminye (gade CDPV).
Kliyan limyè (SPVs) garanti sekirite komès pou kapasite nan magazen pa gen okenn eta minimòm (UTXO-set) lòt pase kle prive.
UTXO ak UTXO-set
UTXO (Sòti Tranzaksyon Unspent) se pwodiksyon tranzaksyon ki pa depanse, pwen final vwayaj chak Satoshi transfere nan tranzaksyon yo. Pwodiksyon ki pa depanse yo vin antre nan nouvo tranzaksyon yo epi yo konsa depanse (depanse) epi yo retire yo nan seri UTXO la.
Nouvo UTXO yo toujou kreye pa tranzaksyon:
- tranzaksyon coinbase san antre: kreye nouvo UTXO lè minè yo bay pyès monnen
- tranzaksyon regilye: kreye nouvo UTXO pandan y ap depanse yon seri UTXO ki egziste deja
Pwosesis travay ak UTXO:
Bous konte kantite pyès monnen ki disponib pou depans (balans) dapre kantite UTXO ki disponib pou bous sa a pou depanse.
Chak ne validateur, pou anpeche tantativ depans doub, dwe kontwole seri a nan tout UTXO lè w tcheke chak tranzaksyon yo chak blòk.
Ne a dwe gen lojik:
- Ajoute nan UTXO-set
- Sipresyon nan UTXO-set
- Tcheke prezans yon sèl UTXO nan yon seri
Gen fason pou diminye kondisyon pou enfòmasyon ki estoke sou yon seri, pandan w ap kenbe kapasite pou ajoute ak retire eleman, tcheke ak pwouve egzistans yon eleman nan yon seri lè l sèvi avèk .
Batri pou UTXO
Lide a nan sèvi ak pil pou estoke plizyè UTXO .
Se UTXO-set la bati sou vole, pandan telechajman inisyal blòk la (IBD), ki estoke an plen ak pèmanan, pandan y ap sa li yo chanje apre yo fin trete tranzaksyon nan chak blòk nouvo ak kòrèk nan rezo a. Pwosesis sa a mande pou telechaje apeprè 200 GB done blòk ak verifye dè santèn de milyon siyati dijital. Apre pwosesis IBD la fini, liy anba a se ke UTXO-seri a pral okipe apeprè 4 GB.
Sepandan, ak akimilatè, règ konsansis pou lajan yo redwi a verifikasyon ak jenerasyon prèv kriptografik, epi fado pou swiv lajan ki disponib yo transfere bay pwopriyetè fon sa yo, ki bay prèv egzistans yo ak pwopriyetè yo.
Yon akimilatè ka rele yon reprezantasyon kontra enfòmèl ant yon seri. Gwosè reprezantasyon ki estoke a dwe swa konstan , oswa ogmante sublinearly ki gen rapò ak kardinalite nan seri a ak gwosè a nan eleman nan tèt li, pou egzanp , kote n se kardinalite ansanm ki estoke a.
Nan ka sa a, akimilatè a ta dwe pèmèt jenere yon prèv enklizyon yon eleman nan seri a (prèv enklizyon) epi fè li posib pou verifye efektivman prèv sa a.
Yo rele batri a dinamik si pèmèt ou ajoute eleman epi retire eleman nan yon seri.
Yon egzanp tankou yon batri ta dwe . Tankou yon akimilatè gen yon gwosè konstan nan reprezantasyon ki estoke, men mande pou prezans la sekrè pataje (konfigirasyon ou fè konfyans). Egzijans sa a nye aplikasyon pou yon akimilatè sa a pou rezo san konfyans tankou Bitcoin, depi flit done pandan jenerasyon sekrè ka pèmèt atakè yo kreye prèv fo egzistans lan nan yon UTXO, twonpe nœuds ak yon UTXO-set ki baze sou yon akimilatè konsa.
Utreexo
Konsepsyon Utreexo ki te pwopoze pa Thaddeus Dryja fè li posib pou kreye dinamik akimile san yo pa fè konfyans-konfigirasyon.
Utreexo se yon forè nan binè pafè epi li se yon devlopman nan lide yo prezante nan , ajoute kapasite pou retire eleman nan yon seri.
Estrikti lojik batri
Selil batri yo ranje nan yon forè nan pye bwa binè ideyal. Pye bwa yo òdone dapre wotè. Sa a te chwazi reprezantasyon kòm pi vizyèl la epi li pèmèt ou visualiser fusion de pyebwa yo pandan operasyon yo sou batri a.
Otè a note ke piske tout pye bwa yo nan forè a se ideyal, wotè yo eksprime kòm yon pouvwa de de, menm jan nenpòt nonm natirèl ka reprezante kòm yon sòm de pouvwa nan de. An konsekans, nenpòt seri fèy yo ka gwoupe nan pye bwa binè, ak nan tout ka, ajoute yon nouvo eleman mande pou konesans. sèlman sou nœuds rasin yo nan pye bwa ki estoke.
Kidonk, reprezantasyon ki estoke nan akimilatè Utreexo a se yon lis nœuds rasin (Merkle rasin), epi pa tout forè a nan pye bwa.
Ann reprezante lis eleman rasin yo kòm Vec<Option<Hash>>. Kalite opsyonèl Option<Hash> endike ke eleman rasin lan ka manke, ki vle di ke pa gen okenn pye bwa ki gen wotè ki apwopriye a nan akimilatè a.
/// 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],
}
}
}Ajoute eleman
Premyèman, ann dekri fonksyon an parent(), ki rekonèt ne paran an pou de eleman yo bay yo.
paran() fonksyon
Depi nou ap itilize pye bwa Merkle, paran chak nan de nœuds yo se yon sèl nœud ki estoke hachaj nan konkatènasyon hash yo nan nœuds timoun yo:
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[..])
}Otè a fè remake ke pou anpeche atak yo dekri pa Charles Bouillaguet, Pierre-Alain Fouque, Adi Shamir, ak Sebastien Zimmer nan
, Anplis de hashes yo, wotè andedan pye bwa a ta dwe ajoute tou nan konkatènasyon an.
Pandan w ap ajoute eleman nan akimilatè a, ou bezwen kenbe tras ki eleman rasin yo chanje. Lè w swiv chemen pou chanje eleman rasin yo pou chak eleman ou ajoute, ou ka pita konstwi yon prèv prezans eleman sa yo.
Swiv chanjman yo pandan w ap ajoute yo
Pou swiv chanjman ki fèt yo, ann deklare estrikti a Update, ki pral estoke done sou chanjman ne yo.
#[derive(Debug)]
pub struct Update<'a> {
pub utreexo: &'a mut Utreexo,
// ProofStep хранит "соседа" элемента и его положение
pub updated: HashMap<Hash, ProofStep>,
}Pou ajoute yon eleman nan batri a, ou bezwen:
- Kreye yon etalaj de panyen eleman rasin yo
new_rootsepi mete eleman rasin ki egziste deja yo la, youn pou chak bokit:
Kòd
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);
}- Mete eleman yo dwe ajoute (etalaj
insertions) nan premye kabwa anew_roots[0]:
Kòd
new_roots[0].extend_from_slice(insertions);- Konbine atik ki ajoute nan premye panyen an ak rès la:
- Pou tout charyo ki gen plis pase yon atik:
- Pran de eleman nan fen panyen an, kalkile paran yo, retire tou de eleman yo
- Ajoute paran an kalkile nan pwochen kabwa a
- Pou tout charyo ki gen plis pase yon atik:
Kòd
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 });
}
}- Deplase eleman rasin soti nan posode nan etalaj akimilatè ki kapab lakòz
Kòd
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]);
}
}Kreye yon prèv pou eleman ajoute
Prèv enklizyon selil la nan batri a (Proof) pral sèvi kòm Chemen Merkle a, ki gen ladann yon chèn ProofStep. Si chemen an pa mennen okenn kote, Lè sa a, prèv la pa kòrèk.
/// Единичный шаг на пути к элементу в дереве Меркла.
#[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,
}Sèvi ak enfòmasyon yo jwenn pi bonè lè w ajoute yon eleman (estrikti Update), ou ka kreye prèv ke yo te ajoute yon eleman nan batri a. Pou fè sa, nou ale nan tablo chanjman ki fèt yo epi ajoute chak etap nan chemen Merkle a, ki pral imedyatman sèvi kòm prèv:
Kòd
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
}
}Pwosesis pou kreye yon prèv
Tcheke prèv la pou yon eleman
Tcheke prèv enklizyon yon eleman se desann nan swiv chemen Merkle a jiskaske li mennen nan yon eleman rasin ki egziste deja:
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
}
}Vizyèlman:
Pwosesis pou tcheke prèv la pou A
Retire atik yo
Pou retire yon selil nan yon batri, ou dwe bay prèv valab ke selil la la. Sèvi ak done ki soti nan prèv la, li posib pou kalkile nouvo eleman rasin akimilatè a pou ki prèv yo bay la p ap vrè ankò.
Algoritm lan se jan sa a:
- Menm jan ak adisyon, nou òganize yon seri panyen vid ki koresponn ak pye bwa Merkle ak yon wotè ki egal a pouvwa a nan de nan endèks la panyen.
- Nou mete eleman ki soti nan etap yo nan chemen an Merkle nan panyen yo; endèks panyen an egal a kantite etap aktyèl la
- Nou retire eleman rasin nan ki chemen an soti nan prèv la mennen
- Menm jan ak ajoute, nou kalkile nouvo eleman rasin nan konbine eleman ki soti nan panyen an pè epi deplase rezilta inyon an nan pwochen panyen an.
Kòd
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;
}
}Pwosesis pou retire eleman "A":
Entegrasyon nan yon rezo ki egziste deja
Sèvi ak akimilatè yo pwopoze a, nœuds ka evite itilize yon DB pou estoke tout UTXO yo pandan y ap toujou kapab chanje UTXO-set la. Sepandan, pwoblèm nan nan travay ak prèv rive.
Ann rele nœud validateur ki itilize akimilatè UTXO a kontra enfòmèl ant (konpak-eta ne), ak validateur a san yon akimilatè se konplè (nœud plen). Egzistans de klas nœuds kreye yon pwoblèm pou entegre yo nan yon sèl rezo, depi nœuds kontra enfòmèl ant mande pou prèv egzistans UTXO yo, ki depanse nan tranzaksyon, pandan nœuds plen pa fè sa. Si tout nœuds rezo yo pa chanje an menm tan ak nan yon fason kowòdone nan itilize Utreexo, Lè sa a, nœuds kontra enfòmèl ant yo pral kite dèyè epi yo pa yo pral kapab opere sou rezo Bitcoin a.
Pou rezoud pwoblèm nan entegre nœuds kontra enfòmèl ant nan rezo a, li pwopoze prezante yon klas adisyonèl nan nœuds - pon. Yon ne pon se yon ne konplè ki tou estoke batri a Utreexo ak prèv pouvwa-sou pou nan tout UTXO soti nan UTXO-set. Bridges kalkile nouvo hashes epi mete ajou akimilatè a ak prèv kòm nouvo blòk tranzaksyon yo rive. Kenbe ak ajou akimilatè a ak prèv yo pa enpoze chaj enfòmatik adisyonèl sou nœuds sa yo. Pon yo sakrifye espas disk: bezwen kenbe bagay yo òganize hashes, konpare ak hashes pou nœuds kontra enfòmèl ant, kote n se pouvwa a nan seri a UTXO.
Achitekti rezo
Pon yo fè li posib pou ajoute piti piti nœuds kontra enfòmèl ant nan rezo a san yo pa chanje lojisyèl an nan nœuds ki egziste deja. Nœuds konplè opere tankou anvan, distribye tranzaksyon ak blòk nan mitan tèt yo. Nœuds pon yo se nœuds plen ki anplis sere done batri Utreexo ak yon seri prèv enklizyon pou nan tout UTXO pou kounye a. Nœud pon an pa fè piblisite tèt li kòm sa yo, pretann yo dwe yon ne plen pou tout nœuds plen ak yon ne kontra enfòmèl ant pou tout moun ki kontra enfòmèl ant. Malgre ke pon konekte tou de rezo yo ansanm, yo aktyèlman sèlman bezwen konekte yo nan yon direksyon: soti nan nœuds konplè ki deja egziste nan nœuds kontra enfòmèl ant. Sa a se posib paske fòma tranzaksyon an pa bezwen chanje, epi prèv UTXO pou nœuds kontra enfòmèl ant yo ka jete, kidonk nenpòt nœud kontra enfòmèl ant ka menm jan an difize tranzaksyon yo bay tout patisipan rezo san patisipasyon nœuds pon yo.
Konklizyon
Nou te gade batri Utreexo a epi nou te aplike pwototip li nan Rust. Nou te gade achitekti rezo a ki pral pèmèt entegrasyon nœuds ki baze sou batri. Avantaj nan kaptire kontra enfòmèl ant se gwosè a nan done yo ki estoke, ki depann logaritmikman sou pouvwa a nan seri a nan UTXOs, ki anpil diminye kondisyon yo pou espas ki gen kapasite ak pèfòmans depo pou nœuds sa yo. Dezavantaj la se trafik ne adisyonèl pou transmèt prèv, men teknik agrégation prèv (lè yon prèv pwouve egzistans plizyè eleman) ak kachèt ka ede kenbe trafik nan limit akseptab.
Referans:
- -
Sous: www.habr.com