In che modo il codice sorgente di bitcoin definisce il suo tetto di 21 milioni?

Un passeggiata tra le pieghe del codice sorgente alla scoperta del'hard cap. | Ted Stevenot

In che modo il codice sorgente di bitcoin definisce il suo tetto di 21 milioni?
In che modo il codice sorgente di bitcoin definisce il suo tetto di 21 milioni?

Un passeggiata tra le pieghe del codice sorgente alla scoperta del'hard cap.

Traduzione dall'originale di Ted Stevenot - pubblicato il 23 giu 2022

Molti dei critici più accaniti di bitcoin hanno espresso dubbi sul suo tetto di 21 milioni, ma forse la critica più insensata riguarda il fatto che il limite della supply non è specificato nel suo codice in un linguaggio chiaro. Questo può essere vero, ma questa parte di bitcoin - come esattamente il limite della supply è definito nel suo codice - è relativamente facile da dimostrare.

Sfiderò il gruppo su un'altra cosa: come fate a sapere che finisce a 21 milioni? Avete tutti letto gli algoritmi? Ci credete tutti? Non lo so, sono sempre stato uno scettico su queste cose.
- Jamie Dimon, CEO di JP Morgan Chase, 11 ottobre 2021

Il codice bitcoin utilizza un mix di regole di consenso e di semplice matematica concordata da tutti coloro che gestiscono un nodo bitcoin per stabilire implicitamente il limite. In questa sede, analizzeremo il codice per verificare con certezza che il limite massimo di bitcoin è di 21 milioni. Se questo è un po' troppo tecnico e preferite una panoramica di più alto livello su 21 milioni e il suo significato, eccovi serviti (in inglese, n.d.t.).

La funzione GetBlockSubsidy

Per capire cosa dice il codice riguardo al tetto totale (hard cap, n.d.t.) di bitcoin, il primo punto da guardare è la funzione per le sovvenzioni di blocco. Questa parte del codice è fondamentale per verificare l'offerta fissa di bitcoin, perché tutti i nuovi bitcoin provengono dalle sovvenzioni di blocco (che sono incluse, insieme alle commissioni di transazione, come parte delle sovvenzioni di blocco) pagate ai minatori.

Ecco la funzione del codice di bitcoin che determina la sovvenzione di blocco, chiamata GetBlockSubsidy():

Questa sezione del codice definisce l'importo della sovvenzione di blocco e determina il programma per la sua riduzione nel tempo attraverso i dimezzamenti (halving, n.d.t.). Quando la sovvenzione di blocco raggiunge lo zero, significa che l'offerta totale di bitcoin ha raggiunto il suo limite. Alla fine raggiungerà lo zero, grazie a 33 dimezzamenti pre-programmati.

Procediamo a stabilire, riga per riga, come funziona il dimezzamento:

  1. Come si calcola l'epoca di halving,
  2. Come viene calcolato la sovvenzione di blocco, ed infine
  3. Come il tetto di 21 milioni è implicito nella somma delle sovvenzioni di blocco.

1. Calcolo dell'epoca di halving

Cominciamo con l'esaminare il modo in cui il bitcoin definisce il numero di halving che si sono verificati.

CAmount GetBlockSubsidy (int nHeight, const Consensus::Params& consensusParams)

Questa prima riga apre la funzione e specifica che quelli che seguono sono i parametri per la sovvenzione in blocco. Successivamente, si ottiene un'equazione che calcola il numero di halving:

int halvings = nHeight / consensusParams.nSubsidyHalvingInterval

Questa riga dice molte cose, quindi vediamo di analizzarla:

  • int halvings specifica il numero intero chiamato halvings, arrotondato per difetto al numero intero più vicino.
  • nHeight è il numero attuale di blocchi della blockchain. Quando nuovi blocchi si aggiungono alla blockchain di bitcoin, questa diventa "più alta". Al momento in cui scriviamo, l'"altezza dei blocchi" di bitcoin è di 740.805 blocchi.
  • nSubsidyHalvingInterval specifica il numero di blocchi che devono passare prima che si verifichi un altro dimezzamento.

L'ultimo parametro, nSubsidyHalvingInterval, è un valore statico impostato su 210.000 blocchi come definito in altre parti del codice di bitcoin, come mostrato di seguito:

Con i valori di nHeight (altezza attuale del blocco = 740.805) e nSubsidyHalvingInterval (quanti blocchi devono passare prima di un altro dimezzamento = 210.000) in mano, possiamo dividere l'altezza attuale del blocco per l'intervallo di dimezzamento. Questo valore, che rappresenta l'epoca di dimezzamento corrente in cui ci troviamo, viene assegnato all'intero halvings:

int halvings = 740.805 / 210.000

ovvero

int halvings = 3,52764286 (arrotondato a 3)

Il risultato finale rivela che ci troviamo nell'epoca successiva al terzo dimezzamento. Si noti che prima dell'arrotondamento al numero intero dimezzato 3, abbiamo il quoziente 3,52764286. Anche questo numero è utile, perché indica che siamo appena oltre la metà tra il terzo e il quarto dimezzamento.

Poi abbiamo una riga di commento:

// Force block reward to zero when right shift is undefined,

Questo commento aiuta i programmatori e gli osservatori a capire meglio cosa sta accadendo con il codice, in questo caso definendo una correzione del bug per forzare la sovvenzione di blocco a zero in una circostanza, come descritto di seguito:

if (halvings >=64) return 0;

Queste righe spesso causano confusione perché sembrerebbero definire che ci saranno 64 dimezzamenti. Non è così: se volete, potete leggere i dettagli tecnici sul motivo per cui questa correzione è stata necessaria.

2. Calcolo della sovvenzione di blocco

Per capire come viene calcolato la sovvenzione di blocco, è necessario innanzitutto conoscere il COIN. Il COIN è un valore concordato, specificato in altre parti del codice come "100000000", ovvero il totale delle unità più piccole divisibili di un bitcoin. Al giorno d'oggi si chiamano satoshi o sats (1 bitcoin = 100.000.000 di sats).

Ecco il parametro del codice che specifica la quantità di COIN:

CAmount nSubsidy = 50 * COIN;

La riga successiva della funzione GetBlockSubsidy() definisce un numero fisso pari alla sovvenzione di blocco pagata su ciascuno dei primi blocchi di bitcoin estratti - i 210.000 blocchi che si sono verificati prima del primo dimezzamento. In parole povere, nSubsidy è pari a 50 volte il valore di COIN, ovvero 50 bitcoin.

La rappresentazione binaria di nSubsidy (o 50 * 1000000) è lunga 33 bit, il che sarà utile in seguito per capire come il codice divide la sovvenzione dei blocchi a ogni dimezzamento:

100101010000001011111001000000000

La riga successiva è un altro commento.

// Subsidy is cut in half every 210,000 blocks which will occur every 4 years.

A partire dalla ricompensa del primo blocco di "50 * COIN" (50 bitcoin), la sovvenzione viene successivamente dimezzata ogni 210.000 blocchi. Le righe che seguono descrivono la funzione che divide la sovvenzione a metà in base al dimezzamento corrente, come descritto in precedenza.

nSubsidy >>= halvings; return nSubsidy;

L'elemento critico del codice sopra riportato è ">>" o "bitwise right shift". Il bitwise shift è un operatore standard del linguaggio di programmazione C++. In questo caso, significa uno "spostamento aritmetico a destra di un bit", che equivale a dividere per due. È importante perché aiuta a capire come il programma di supply sappia dove terminare la divisione.

Come calcolato in precedenza, oggi ci troviamo nel terzo halving. Quindi, sappiamo tre cose: 1) nSubsidy = 50 * 100.000.000 (o 50 bitcoin), 2) l'operatore >> 3; e 3) return nSubsidy;.

Il primo valore nel calcolo di cui sopra è un numero fisso. Il secondo valore cambia in base alla posizione in cui ci troviamo nel programma di halving Ecco di nuovo la rappresentazione binaria del valore fisso di 50 * 1000000 (la sovvenzione iniziale del blocco):

100101010000001011111001000000000

Un singolo "bitwise right shift" rimuove l'ultima cifra all'estrema destra dalla stringa di cui sopra. La conversione di questi numeri binari in numeri decimali equivalenti rivela la sovvenzione dopo il primo dimezzamento:

Prima: 100101010000001011111001000000000 = 5.000.000.000 unità di COIN (o 50 bitcoin)

Dopo:      10010101000000101111100100000000 = 2.500.000.000 unità di COIN (o 25 bitcoin)

Un " >>3" sposta il nostro numero binario iniziale di tre spazi a destra, facendo cadere le tre cifre più lontane e creando un altro numero.

Prima: 100101010000001011111001000000000

Dopo:       100101010000001011111001000000

Quando questo nuovo numero binario viene convertito nel suo equivalente decimale, equivale a 625.000.000 unità di COIN, ovvero 6,25 bitcoin.

Potete visitare il sito rapidtables.com se volete giocare da soli con questa operazione. Ogni volta che si sposta una cifra supplementare dal lato destro della stringa binaria iniziale, il numero decimale equivalente si dimezza.

3. Riassumendo

La scarsità di bitcoin di nuova emissione dovuta a questi spostamenti bitwise right, che si verificano ogni 210.000 blocchi, è impressionante:

Come si può intuire, sommando tutte le sovvenzioni dei blocchi in questa tabella si arriva a poco meno di 21 milioni, per un totale di 20.999.999,9769 bitcoin.

Pieter Wuille, fino a poco tempo fa collaboratore di Core, ha spiegato che il totale reale è leggermente inferiore. Mentre la somma delle sovvenzioni di blocco, se raccolte nella loro interezza, è di 20.999.999,9769, dopo aver tenuto conto delle monete create nel blocco genesi che non sono spendibili, dei bug iniziali e dei minatori che sperimentano con il codice (alcuni blocchi hanno richiesto meno di quanto consentito), l'offerta totale è in realtà inferiore: si avvicina a 20.999.817 bitcoin.

Ted Stevenot