Radice di Merkle e albero di Bitcoin – Come costruire?

Segui e Condividi ora!

Quando si impara a conoscere le valute crittografate si trova il termine Radice di Merkle o Merkle Tree, rispettivamente. E 'in Bitcoin utilizzato come funzione elementare per costruire blocchi. Sapere come costruire l'albero Merkle è essenziale per sviluppare software che hanno bisogno di costruire blocchi, come un software di pool o minerario.

Impronte digitali – integrità dei dati sicura:

Un'impronta digitale o in questo contesto piuttosto Hash è il risultato di una funzione e di una sequenza di byte. Il risultato della stessa funzione e di una sequenza uguale di byte nello stesso ordine sarà sempre lo stesso, solo il più piccolo cambiamento restituisce con molto grande correttamente un altro hash completo.

Utilizzo di fè:

Ci sono tre grandi usi di hashe:

  • Poiché non è possibile calcolare tale hash nella sequenza di byte di input, i sistemi con autenticazione utente archiviano in genere solo l'hash anziché una semplice password per una maggiore sicurezza. Il sistema confronta all'autenticazione solo l'hash archiviato con l'hash dell'input della password.
  • Gli hashes sono utilizzati per un confronto dei dati molto semplice. Molti siti Web mostrano un hash di file nelle pagine di download. Hai solo bisogno di calcolare l'hash del file scaricato e confrontarli con l'hash sul sito web per essere quasi assolutamente sicuro, hai scaricato il file giusto, dal momento che solo un cambiamento di bit produrrebbe probabilmente qualsiasi altro hash.
  • L'hash di una sequenza di byte è tranne che calcolarli non prevedibili, le valute crittografate utilizzano gli hash come sfida per la regolazione.

Cos'è una radice di Merkle?

Una Merkle Root, chiamata su Ralph Merkle che li brevettò, è un hash, calcolato da una sequenza ordinata di hash. Bitcoin memorizza una radice Merkle nelle sequenze di byte chiamati Block, questo campo è chiamato Merkle Root troppo. Diventano calcolati da un costrutto virtuale, chiamato Merkle Tree.

Cos'è un Merkle Tree?

Il nome Albero di Merkle proviene da alberi binari come grafici diretti, dove ogni elemento tranne il più in alto ha un pretendente e al massimo due successori. L'elemento superiore è chiamato nodo radice, quindi la radice Merkle è solo il nodo radice di un albero Merkle. L'albero viene creato solo per ottenere il nodo radice e viene buttato via in seguito.

Come costruire un Merkle Tree? – Passo dopo passo:

Basta seguire questi semplici passaggi per calcolare un Merkle Tree da una sequenza di hash:

  1. Nei casi in cui, si inizia con un solo hash, questo è già la radice Merkle.
  2. Prendi gli ori ordinati in gruppi di due. Se si dispone di un conteggio degli errori dispari, l'ultimo gruppo contiene l'ultimo elemento due volte.
  3. Concatenare gli hash nell'ordine dei byte little endian, quindi il bit meno significativo del primo hash è il bit meno significativo della concatenazione.
  4. Hash la concatenazione e archiviare il risultato nell'ordine last-in-last-out, il risultato dei primi due hash è il primo elemento della riga successiva.
  5. Continuare i tre passaggi precedenti, fino a quando non si dispone del singolo nodo radice superiore.

Questa immagine descrive l'Albero Merkle virtuale dei tre hash A, B e C in Bitcoin utilizzando l'algoritmo SHA-256 due volte:

How to build a merkle tree

Scopo della radice Merkle in Bitcoin:

La radice Merkle nel campo di intestazione del blocco Bitcoin con lo stesso nome viene calcolata dagli ishe delle transazioni di questo blocco.

Garantire l'integrità dei dati:

L'unica connessione tra un'intestazione Block e le transazioni è la radice Merkle archiviata. Tuttavia, l'integrità dei dati è garantita, una modifica di una transazione modificherebbe l'hash della transazione, questo cambierebbe l'albero Merkle e questo l'hash dell'intestazione del blocco.

Hash dell'intestazione di blocco più veloci:

Il tempo di hashing di un'intestazione di blocco non dipende dal numero di transazioni archiviate in questo blocco. Questo è per l'estrazione equa molto importante. L'albero Merkle ha solo bisogno di essere ricalcolato, ogni volta che le transazioni cambiano, ma questo è molto veloce, anche rispetto a trovare un blocco con la difficoltà più bassa possibile. Sarebbe altrimenti una competizione tra la velocità di generazione e test delle intestazioni di blocco e il conteggio delle transazioni.

Meno traffico internet per minatori e piscine:

Grandi piscine ha bisogno di una connessione internet molto forte. Dal momento che i minatori hanno bisogno di costruire costantemente bloccare intestazioni, un minatore ha bisogno di conoscere la radice di Merkle. Il pool trasferisce solo con il metodo mining.notify gli ishe delle transazioni per costruire l'albero locale, un trasferimento di tutte le transazioni costerebbe molto più traffico, la maggior parte delle transazioni sono più grandi dell'intestazione del blocco.

Meno spazio di archiviazione necessario:

È possibile testare un blocco per contenere una transazione semplicemente conoscendo gli ise. I clienti Bitcoin leggeri utilizzano questo fatto per memorizzare solo gli hasheinvece invece delle transazioni complete per ridurre lo spazio di archiviazione del database blockchain globale.

Codice di esempio Merkle Root della build Java:

La classe Java MerkleRootBuilder riportata di seguito implementa il calcolo di una radice Merkle. Si prevede come argomenti del costruttore un'istanza di un ordinato java.util.Collection (ad esempio, java.util.ArrayList), contenente gli eseri come piccole matrici di byte endian e un'implementazione dell'interfaccia HashFunction, correttamente un'istanza della classe DoubleSha256HashFunction. Il primo elemento delle matrici di byte deve essere il byte meno significativo degli zocchi, il primo elemento della raccolta (elemento 0 nelle raccolte indicizzate) deve essere la transazione coinbase, l'elemento 1 la seconda transazione del blocco e così via.

Il metodo build inizia in fondo all'albero con due Deques. Uno contiene gli iseri della riga corrente, l'altro è la destinazione dei risultati. Se la deque di origine contiene un conteggio dispari di elementi, l'ultimo elemento si trova all'inizio della riga successiva non copiato aggiunto una seconda volta. In un albero binario perfetto aumenta il numero di elementi di riga esponenziale alla crescita lineare delle righe, quindi l'aggiunta dell'elemento un secondo volte diventa il numero di elementi più grande più velocemente rispetto al test di ogni elemento per essere l'ultimo. Le matrici non vengono mai modificate né inviate all'esterno delle istanze di classe, pertanto non è necessario copiarle. Il ciclo interno ottiene gli elementi in coppie di due, li concats, li hash (per l'astrazione in due passaggi, potrebbe essere un passaggio per più prestazioni) e aggiunge il risultato all'altra deque. Dopo che gli ultimi due elementi sono stati gestiti, le deques di origine e di destinazione vengono invertite e il gioco inizia da zero, insieme a un hash è rimasto più di un hash.

public final class MerkleRootBuilder implements Factory<byte[]> {
	private final Collection<byte[]> elements;
	private final HashFunction hashFunc;

	/**
	 * 
	 * @param elements A sorted collection of hashes, each in little endian order. (elements.get(x)[0] = the least significant byte)
	 * @param hashFunc
	 */
	public MerkleRootBuilder(final Collection<byte[]> elements,
			final HashFunction hashFunc) {
		if(elements == null) {
			throw new IllegalArgumentException("elements == null");
		} else if(elements.size() == 0) {
			throw new IllegalArgumentException("elements.size() == 0");
		} else if(hashFunc == null) {
			throw new IllegalArgumentException("hashFunc == null");
		}
		
		this.elements = new ArrayList<byte[]>(elements.size());
		this.elements.addAll(elements);
		
		// Check from field to avoid race manipulation
		for(final byte[] bs:this.elements) {
			if(bs == null) {
				throw new IllegalArgumentException("elements contains null");
			}
		}
		this.hashFunc = hashFunc;
	}
	@Override
	public byte[] build() {
		// Just one hash? We have the root already =)
		if(elements.size() == 1) {
			// Get the single element
			for(final byte[] once:elements) {
				return(once);
			}
		}
		
		Deque<byte[]> now = new LinkedList<byte[]>(elements);
		Deque<byte[]> nxt = new LinkedList<byte[]>();
				
	
		
		do {
			// If the current row of the Merkle Tree contains
			// an even element count, the last hash become
			// concatted by itself.
			// Doesn't copy it, we won't change it!
			if((now.size() & 1) != 0) {
				now.addLast(now.getLast());
			}
						
			while(now.size() > 0) {
				final byte[] h0 = now.removeFirst();
				final byte[] h1 = now.removeFirst();
				final byte[] cat = concatBytes(h0, h1);
				final byte[] hash = hashFunc.hash(cat);
				nxt.addLast(hash);
			}
			// Triangle swap of source and destination for the next
			// level.
			final Deque<byte[]> tri = now;
			now = nxt;
			nxt = tri;
		} while(now.size() > 1);
		return(now.getFirst());
	}
	/**
	 * 
	 * @param a
	 * @param b
	 * @return (a[0],a[1],a[2]...a[n-1],b[0],b[1],b[2]...)
	 */
	private byte[] concatBytes(final byte[] a, final byte[] b) {
		final int aLen = a.length;
		final int bLen = b.length;
		
		final byte[] c = Arrays.copyOf(a, aLen + bLen);
		System.arraycopy(b, 0, c, aLen, bLen);
		return(c);
	}
}
public final class DoubleSha256HashFunction implements HashFunction {
	@Override
	public byte[] hash(final byte[] in) {
		try {
			final MessageDigest d = MessageDigest.getInstance("SHA-256");
			d.update(in, 0, in.length);
			final byte[] firstTurn = d.digest();
			d.reset();
			d.update(firstTurn, 0, 32); // 256 Bit = 32 Byte
			return(d.digest());
		} catch (final NoSuchAlgorithmException e) {
			throw new RuntimeException(e);
		}
	}
}
public interface HashFunction {
	public byte[] hash(byte[] in);
}
public interface Factory<T> {
	T build();
}

Esempi di Merkle Root:

Ecco alcuni esempi per testare il software e giocare con. Le stringhe esadecimali sono little endian, ma le riconvertono in byte reali prima dell'hashing.

Esempio 0:

Input:


 

Output:

<error>

 

Esempio 1:

Input:

982051fd1e4ba744bbbe680e1fee14677ba1a3c3540bf7b1cdb606e857233e0e

(Fonte: Blocca #1)

Output:

982051fd1e4ba744bbbe680e1fee14677ba1a3c3540bf7b1cdb606e857233e0e

 

Esempio 2:

Input:

252bf9d75c4f481ebb6278d708257d1f12beb6dd30301d26c623f789b2ba6fc0
e2d32adb5f8ca820731dff234a84e78ec30bce4ec69dbd562d0b2b8266bf4e5a

(Fonte: Blocca #80000)

Output:

190760b278fe7b8565fda3b968b918d5fd997f993b23674c0af3b6fde300b38f

 

Albero:

 

 

Esempio 3:

Input:

c6f2ba9c82a506b634cea1047e0993c0d7205f08561262cc4a5e69cdbd659cf8
4f21bb697bf3d5293fc6e137440855358b86f2b599d90ede09edaec6f9be1818
0d02210b9177cfc8193b95254473ff7bd986ed1179c276d12bad5bdba2403ad4

(Fonte: #99960 di blocco)

Output:

f94b61259c7e9af3455b277275800d0d6a58b929eedf9e0153a6ef2278a5d534

 

Albero:

 

Esempio 4:

Input:

876dd0a3ef4a2816ffd1c12ab649825a958b0ff3bb3d6f3e1250f13ddbf0148c
c40297f730dd7b5a99567eb8d27b78758f607507c52292d02d4031895b52f2ff
c46e239ab7d28e2c019b6d66ad8fae98a56ef1f21aeecb94d1b1718186f05963
1d0cb83721529a062d9675b98d6e5c587e4a770fc84ed00abc5a5de04568a6e9

(Fonte: Blocca #100000)

Output:

6657a9252aacd5c0b2940996ecff952228c3067cc38d4885efb5a4ac4247e9f3

 

Albero:

 

Esempio 5:

Input:

3658837f39d3c6e170726ebccde47edaf5340ac830991ea7b3aaffee453f5ddc
48cc12597887c93dc161f82d8b0adf4166cc169c7be8b1cf78bfbf29448bd90e
eaaee2b601061be3fd3a547c8bbdab5658fdcd0fb633de09b06059be17da0881
d968b21afa85d6fab016c39176604fed99487f98975dc295b2139bf28fa4ffec
e7f42d1556feef839d84257262435be1417baa4048a39594990e1dedef797fb5
66d7577163c932b4f9690ca6a80b6e4eb001f0a2fa9023df5595602aae96ed8d

(Fonte: Bloccare #99974)

Output:

cce3697d67c0fe334b1c0040be1368c5ffb2c563f2486fbbe28ecf0c47662027

 

Albero:

(Fare clic/suggerimento per ingrandire)

Pubblica qui il tuo commento

L'indirizzo email non verrà pubblicato. i campi richiesti sono contrassegnati *

Demo gratuita!

Registrati ora, il sistema di Crypto Calloway
per ottenere un account demo gratuita:

Join the Calloway Crypto Soft now!

Ora leggi tutto recensione!

Se avete ulteriori domande o inciampare, si prega di e-mail immediato per earnmoneytodayblog@gmail.com oppure utilizzare il semplice Modulo di Contatto.

 

money.today guadagnare sfida riuscita: 1041/2000 trader di successo. Prova ora Sistema crittografico Calloway o sistemi di trading gratis altri verificati e inviarci quanto riuscito siete e quanto profitto si e cosa possiamo fare per voi il diritto.

52%

Ultimo trader di successo:
B. Antje
Essere il prossimo!