Le mystère derrière Block Time – Bitcoin investissement

Carte de paiement Crypto

Demandez votre Carte de paiement Crypto ici

Recevez 8 € de BTC gratuitement

Inscrivez-vous à CoinBase









Actualité bitcoin


Prabath Siriwardena

Le temps de blocage définit le temps nécessaire pour exploiter un bloc. Tant dans bitcoin blockchain que dans ethereum blockchain, il existe un temps de blocage attendu et un temps de blocage moyen. En bitcoin, la durée de blocage attendue est de 10 minutes, contre 10 à 19 secondes dans l’éthereum. Au moment de la rédaction de cet article, bitcoin et ethereum utilisent tous deux un algorithme de consensus distribué basé sur la preuve du travail (ethereum est prévu pour passer à un algorithme basé sur la preuve de la mise en jeu avec son sérénité Libération). La durée de blocage attendue est définie sur une valeur constante pour vous assurer que les mineurs ne peuvent pas affecter la sécurité du réseau en ajoutant davantage de puissance de calcul. Le temps moyen de blocage du réseau est évalué après n le nombre de blocs et, s'il est supérieur au temps de bloc attendu, le niveau de difficulté de l'algorithme de preuve de travail sera réduit, et s'il est inférieur au temps de bloc prévu, le niveau de difficulté sera augmenté. C’est le principe de base du temps bloc, mais vous verrez, au fur et à mesure, comment bitcoin et ethereum se différencient l’un de l’autre.

Niveau de difficulté (Bitcoin)

Le niveau de difficulté varie avec le temps, selon la formule suivante. Il essaie d'évaluer la vitesse du réseau minier et de déterminer son écart par rapport au niveau attendu. L'attente est d'exploiter un bloc en 10 minutes. Par exemple, si la vitesse moyenne d'extraction des derniers blocs de 2016 est de 8 minutes, le nouveau facteur de difficulté sera supérieur à un, de sorte que le niveau de difficulté actuel sera augmenté. Dans le cas où – la moyenne est supérieure à 10 minutes, le facteur sera inférieur à 1 et le niveau de difficulté sera réduit pour les prochains blocs de 2016. Le niveau de difficulté est réévalué après chaque bloc de 2016, soit environ toutes les deux semaines.

new_difficulty = old_difficulty X (blocs 2016 X 10 minutes) / (le temps a pris en quelques minutes pour exploiter les derniers blocs 2016)

La figure suivante montre comment le niveau de difficulté a changé avec le temps écoulé depuis le lancement de Bitcoin. En d'autres termes, le niveau de difficulté reflète la difficulté du calcul de la preuve de travail par rapport à la valeur de difficulté définie au début – ce qui est 1. Par exemple, la difficulté actuelle est de 678 760 110 11083 – ce qui signifie que nous exploitons les blocs avec le même hachage taux, ce qui était au moment du 1er bloc, alors il faudrait plus de 678 milliards de fois pour exploiter un bloc avec la difficulté actuelle. Mais dans la pratique, la puissance de calcul injectée dans l’exploitation de Bitcoin s’améliorant considérablement, le temps nécessaire à l’exploitation d’un bloc est maintenu à un nombre constant (ce qui correspond à 10 minutes), en augmentant le niveau de difficulté. Au cours des cinq premières années de bitcoin, le niveau de difficulté est passé de 1 milliard à 50 milliards.

Dans chaque bloc, dans l'en-tête, il y a un paramètre appelé, morceaux – et dans le bloc de genèse, la valeur des bits est 486604799. Si nous représentons la même chose en hexadécimal, ce serait 1D00FFFF. Ceci est un format compact – qui peut être utilisé pour trouver le cible valeur de hachage pour ce bloc (actuel). En fait, le hachage de ce bloc doit être inférieur ou égal à la cible. La valeur de la cible est calculé uniquement après les blocs de 2016, avec le calcul du niveau de difficulté – et, une fois calculés, les prochains blocs de 2016 conserveront la même valeur morceaux paramètre d'en-tête de bloc.

cible = coefficient * 2 ^ (8 * (exposant – 3))

Les deux premiers chiffres de la valeur hexadécimale ci-dessus sont appelés le exposant, qui est 1D et les six prochains chiffres (00FFFF) sont connus comme le coefficient. Maintenant, si nous appliquons ces valeurs à la fonction ci-dessus, cela ressemblera à ce qui suit.

cible = 00FFFF * 2 ^ (8 * (1D - 3))cible = 00FFFF * 2 ^ (8 * 1A)cible = 00FFFF * 2 ^ D0

Maintenant, si nous faisons l’arithmétique hexadécimale pour ce qui précède, nous trouverons la valeur de cible en hexadécimal. Converti cela en décimal serait 2,69 * 10 ^ 67 – et ce serait en binaire.

11111111011011100100011000111110010010000011111111111001001110101001001010010011101110011001100110011001100110011001101001

Pour que ce soit bien clair – puisque le hachage du bloc doit être en 256 bits – représentons également la cible en 256 bits en ajoutant des zéros non significatifs.

00000000000000000000000000000000000011111111111111111111111111111100110010010000011111111111111001100111011101101110011001110010010010000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Maintenant, le hachage du bloc de genèse doit être inférieur ou égal à ce qui précède, qui est:

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Comme nous l'avons expliqué précédemment, la difficulté du bloc de genèse est de 1. Après chaque bloc de 2016, la cible est recalculée de la manière suivante.

new_target = old_target / new_difficulty, où le old_target est montré ci-dessus (qui est du bloc de genèse, dans ce cas).

La difficulté est calculée de la manière suivante:

new_difficulty = old_difficulty X (blocs 2016 X 10 minutes) / (le temps a pris en quelques minutes pour exploiter les derniers blocs 2016)

Par exemple, le nouveau niveau de difficulté du bloc 2017e est calculé de la manière suivante:

Supposons que la durée moyenne des blocs pour les premiers blocs de 2016 est de 8 minutes. Ceci n’est qu’une hypothèse – en réalité, le niveau de difficulté de la blockchain de bitcoin est resté inchangé jusqu’au bloc 32255 – et n’est passé que de 1 à 1,18 en bloc 32256 (2016 X 16).

new_difficulty = 1 X (2016 X 10) / (8 * 2016) = 1,25La nouvelle cible = (2,69 * 10 ^ 67) / 1,25 = 2,15 * 10 ^ 671100110000100111100110111111111111111111111111111111111111111110111011101110111011101001111100100111110011111001111111111111110110111110110

Maintenant, si nous ajoutons des zéros à gauche pour faire le nombre de 256 ci-dessus, alors la cible sera:

00000000000000000000000000000000000011001100001001111101101111111111111111111111111111111111111111111111101110111011101101110110110110110110

La nouvelle cible est inférieure à la précédente. Le logiciel d'exploration de données doit donc trouver une valeur nonce, ce qui rend le hachage du bloc inférieur ou égal à ce qui précède. Lorsque la puissance de calcul augmente, le temps moyen de blocage diminue – puis le niveau de difficulté augmente avec une valeur cible basse. Les prochains blocs 2016 porteront dans l'en-tête de bloc, la valeur de la nouvelle cible en tant que morceaux paramètre – et la valeur du nouveau niveau de difficulté en tant que difficulté paramètre.

La manière dont le niveau de difficulté augmente et comment il est calculé est écrit dans le logiciel d’exploitation lui-même. Si un mineur veut tromper le système en modifiant les règles de sa propre copie, il peut bien sûr le faire. Mais cela le rendra isolé. Une fois que vous avez triché puis envoyé la copie du bloc miné à d’autres, les mineurs légitimes qui le valident le trouveront mal exécuté et le rejetteront. Le mineur qui triche alors tombera automatiquement dans sa propre copie de la blockchain.

Niveau de difficulté (Ethereum)

Dans l'éthereum, propriété relâché, le niveau de difficulté est calculé de la manière suivante – où // dénote la division entière et 2 ** dénote les deux au pouvoir. le int fonction renvoie le plus grand entier inférieur ou égal à un nombre donné.

block_time = current_block_timestamp - parent_block_timestampcurrent_block_difficulty = parent_block_difficulty + (parent_block_difficulty // 2048) * max (1 - (block_time // 10), -99) + int (2 ** ((current_block_number // 100000) - 2))

Si vous regardez la formule ci-dessus, elle comporte deux parties principales. La première partie détermine de quelle manière le temps de blocage s'écarte du temps de blocage attendu (10 à 19 secondes). Cela trouvera un facteur de la parent_block_difficulty, en fonction du temps nécessaire à l’exploitation du bloc actuel. Si le bloc en cours est exploité plus rapidement, en moins de 10 secondes, ce facteur sera un nombre positif, ce qui augmentera la difficulté. Si le temps de blocage est compris entre 10 et 19 secondes (inclus), la difficulté ne sera pas modifiée. Il en résultera une valeur négative lorsque le temps de blocage sera supérieur ou égal à 20 secondes et la difficulté sera diminuée (mais aura tout de même l'impact de la bombe de difficulté, dont nous parlerons plus tard).

Examinons en détail chacun des cas ci-dessus et voyons comment la formule ci-dessus sera réduite.

Si block_time est inférieur à 10 secondes, l'équation ci-dessus sera réduite à (par exemple: block_time // 10 → 8 // 10 → 0):

current_block_difficulty = parent_block_difficulty + (parent_block_difficulty // 2048) * max (1 - 0, -99) + int(2 ** ((current_block_number // 100000) - 2))current_block_difficulty = parent_block_difficulty + (parent_block_difficulty // 2048) * 1 + int (2 ** ((current_block_number // 100000) - 2))

Si block_time est compris entre 10 et 19 secondes, l'équation ci-dessus sera réduite à (par exemple: block_time // 10 → 12 // 10 → 1):

current_block_difficulty = parent_block_difficulty + (parent_block_difficulty // 2048) * max (1 - 1, -99) + int(2 ** ((current_block_number // 100000) - 2))current_block_difficulty = parent_block_difficulty + int (2 ** ((current_block_number // 100000) - 2))

Si block_time est supérieur ou égal à 20 secondes, l'équation ci-dessus sera réduite à (en supposant qu'elle soit inférieure à 30 secondes, par exemple: block_time // 10 → 22 // 10 → 2):

current_block_difficulty = parent_block_difficulty + (parent_block_difficulty // 2048) * max (1 - 2, -99) + int(2 ** ((current_block_number // 100000) - 2))current_block_difficulty = parent_block_difficulty - (parent_block_difficulty // 2048) + int (2 ** ((current_block_number // 100000) - 2))

La valeur maximale descendante se produit dans ce cas, lorsque le temps block_time est égal ou supérieur à 1000 secondes, ce qui correspond à (par exemple: block_time // 10 → 1000 // 10 → 100):

current_block_difficulty = parent_block_difficulty + (parent_block_difficulty // 2048) * max (1–100, -99) + int(2 ** ((current_block_number // 100000) - 2))current_block_difficulty = parent_block_difficulty - 99 * (parent_block_difficulty // 2048) + int (2 ** ((current_block_number // 100000) - 2))

La deuxième partie de la formule ci-dessus est connue sous le nom de bombe de difficulté.

int (2 ** ((current_block_number // 100000) - 2))

Quand le current_block_number est inférieur à 100000 la valeur de ce qui précède sera int (2 ** (0 – 2)) ou int (2 ** – 2) ou int (1/4) qui est 0 – donc il n’y aura pas d’impact sur le niveau de difficulté. Lorsque current_block_number est inférieur à 200000 mais supérieur à 100000, la valeur ci-dessus sera int (2 ** – 2) ou ou int (1/2) qui est à nouveau 0 – donc pas d'impact. Cela aura un impact uniquement si le numéro de bloc est supérieur à 200 000. Supposons que le numéro de bloc est supérieur à 200 000 mais inférieur à 300 000, puis current_block_number // 100000 – sera 2 – donc la valeur de ce qui précède sera int (2 ** 0) ou int (1) qui est 1. Donc, la difficulté totale sera.

current_block_difficulty = parent_block_difficulty + (parent_block_difficulty // 2048) * 1 + 1.

Pour le numéro de bloc actuel au moment de l'écriture, soit 4356873, ce deuxième facteur est le suivant: int (2 ** 41), qui est 2199023255552, où (4356873 // 100000–2) → (43–2) → 41.

Remarque: Frontier, la première version de l’éthereum, lancée en juillet 2015, visait à maintenir le temps de blocage de l’éthereum autour de 12 secondes. La discussion ci-dessus est liée à la propriété libération d'éthereum – pas le frontière. Ce qui suit montre le calcul de la difficulté utilisé dans frontière.

current_block_difficulty = parent_block_difficulty + (parent_block_difficulty // 2048) * (1 si current_block_timestamp – parent_block_timestamp <13 sinon -1) + int (2 ** ((bloc.numéro // 100000) – 2))

La principale différence entre le niveau de difficulté de Bitcoin et celui de l'Ethereum est que, dans bitcoin, le réglage de la difficulté est effectué après 2016 blocs pour maintenir le temps de blocage à une valeur constante (même si la puissance de calcul augmente), mais dans Ethereum, basé sur le puissance, le temps de blocage augmentera (ou diminuera) en raison de l’impact de la bombe difficile (ne pas essayer de le maintenir à une valeur constante) – et l’ajustement est effectué dans chaque bloc. Donc, pour maintenir le temps de blocage d'éthereum à un niveau considérable, la puissance de calcul doit également augmenter avec le temps (à la hauteur de la bombe de difficulté) – sinon, il sera difficile d'extraire Ethereum, ce qui entraînera un gel de la chaîne d'Ethereum – également connu comme âge de glace.

La bombe de difficulté Ethereum

La bombe à difficulté Ethereum, qui rend l'exploitation plus difficile avec un niveau de difficulté en augmentation exponentielle au fil du temps, a été introduite pour décourager les mineurs de poursuivre l'exploitation avec la preuve du travail d'extraction, lorsque l'Ethereum sérénité la publication à l’avenir introduit la preuve de l’exploitation minière. Le niveau de difficulté a été introduit avec le premier patch à la éthéré frontière. Frontier était la première version d'Ethereum, lancée en juillet 2015.

Comme nous en avons discuté dans la section précédente, voici le changement (audacieux) introduit l'algorithme de difficulté Ethereum pour supporter la bombe de difficulté:

current_block_difficulty = parent_block_difficulty + (parent_block_difficulty // 2048) * 1 + int (2 ** ((current_block_number // 100000) - 2))

Notez que, l'algorithme ci-dessus est basé sur le ethereum propriété libérer, pas de la frontière communiqué, où la bombe de difficulté a été introduite. Quoi qu'il en soit, entre ces deux versions, même si l'algorithme de difficulté a été modifié, la partie bombe à difficulté n'a pas changé.

Avec les modifications apportées à l'algorithme de difficulté Ethereum pour prendre en charge la bombe de difficulté, à partir du bloc 200 000 (vers septembre 2015), la difficulté a augmenté de façon exponentielle, mais n'est devenue perceptible que dans environ un an plus tard. À partir de ce moment, la difficulté augmente considérablement, ce qui a commencé à augmenter le temps de résolution de bloc. Comme nous continuons ainsi, en raison des objectifs miniers plus difficiles, le réseau continuera à être utile pendant quelques mois, mais finira par atteindre un âge de glace, la difficulté sera simplement trop élevée pour que quiconque puisse trouver un bloc. Le plan était de présenter une preuve d’enjeu à ce moment-là avec l’éthereum sérénité Libération.

Comme les plans pour la sérénité la libération a été retardée, il y a une fourchette difficile qui attend avec le Byzance libérer (toujours avec preuve de travail), dans le réseau ethereum, dans quelques jours entre 12h00 UTC et 13h00 UTC le lundi 16 octobre 2017, au numéro de bloc 4 370 000. Byzance fait partie de la métropole phase de développement d'Ethereum qui comprend deux fourchettes dures: Byzance et Constantinople. Constantinople n’a pas de date de sortie pour le moment, mais est attendue pour 2018. Avec la proposition EIP 649, qui inclut dans Byzance, la bombe de difficulté Ethereum est encore retardée. Maintenant, le temps moyen de blocage est de 17,49 secondes et augmente lentement en raison de la difficulté de la bombe. Cela rend les utilisateurs / mineurs découragés. La proposition d’amélioration Ethereum (PIE) suggère de retarder considérablement la bombe de difficulté, de réduire le temps moyen de blocage en dessous de 15 secondes et de donner plus de temps aux sérénité développement.

Pourquoi Bitcoin Block Time est 10 minutes?

Bitcoin essaie de maintenir son temps de blocage autour de 10 minutes avec son algorithme de difficulté. Pourquoi c'est 10 minutes? Pourquoi pas 2 ou 20 minutes? La toute première référence à 10 minutes en tant que bloc de bitcoins provient du document de recherche original, qui introduisait bitcoin en 2008, de Satoshi Nakamoto. Il n’ya qu’une référence, et 10 minutes n’est pas une suggestion concrète, mais un exemple.

Un en-tête de bloc sans transaction serait d'environ 80 octets. Si nous supposons que des blocs sont générés toutes les 10 minutes, 80 octets * 6 * 24 * 365 = 4,2 Mo par an. Avec les systèmes informatiques vendant généralement avec 2 Go de RAM à partir de 2008 et la loi de Moore prévoyant une croissance actuelle de 1,2 Go par an, le stockage ne devrait pas poser de problème, même si les en-têtes de bloc doivent être conservés en mémoire.

Supposons que le temps de blocage est de 2 minutes – et que le temps de latence moyen du réseau pour atteindre ce bloc par les autres mineurs du réseau Bitcoin est de 1 minute (il s’agit d’un exemple, c’est pratiquement moins que cela). Cette valeur de latence est indépendante du temps de blocage. Tous les mineurs du réseau minent simultanément et indépendamment. Disons que tout le monde exploite le 3500ème bloc (supposons que tous commencent l’extraction au moment voulu). t0) – et le mineur à M résout le puzzle en premier et diffuse le bloc au reste des mineurs à l'heure t0 + t, t est le temps pris par à M pour exploiter le 3500ème bloc. À présent peter, un autre mineur moyen trouve tom bloquer à (t0 + t) + 1, en raison de la latence du réseau de 1 minute. Peter et tous les autres mineurs qui achèvent d’exploiter le même bloc avec (delta_t) i temps de retard, où; (t0 + t) <(t0 + t) + (delta_t) i < (t0 + t) + 1 ou peut être réduit à 0<(delta_t) i <1, réussir à résoudre le puzzle, mais gaspillent toute leur énergie – et tous ces blocs seront des blocs orphelins sans récompense minière. Le gaspillage total de hachages dans l'ensemble du réseau en raison des blocs orphelins serait:

somme de (t + (delta_t) i) * (hr) i pour chaque i

(delta_t) i est le temps supplémentaire de t, le mineur jeth pris avant de remarquer le bloc miné par à M – et (h) i est le nombre de hachages par minute du jele mineur génère.

Si nous augmentons la difficulté de p%puis les deux t et (delta_t) i augmentera, disons la même chose p1%. Depuis cela fait (delta_t) i augmente, le nombre de mineurs qui achèvent l'exploitation minière où (t0 + t) + (delta_t) i < (t0 + t) + 1 va descendre. Ainsi, dans la fonction de gaspillage ci-dessus, le nombre de jes va descendre – alors le gaspillage. Passons en revue quelques exemples avec des valeurs concrètes.

  1. Si la valeur de t est de 2 minutes, puis chaque mineur qui termine l'extraction d'un bloc avant une période de 3 minutes (avec une latence du réseau de 1 minute) ne contribuera qu'aux déchets (à l'exception du mineur qui termine tout en premier et reçoit la récompense). Ici, vous pouvez voir qu’il ya 50% d’écart de temps où un mineur peut tomber dans cette période. [ 50% = (3–2)/2 * 100]
  2. Si la valeur de t est de 4 minutes, puis chaque mineur qui termine l’exploitation d’un bloc avant une période de 5 minutes (avec une latence du réseau de 1 minute) ne contribuera qu’au gaspillage. Ici, vous pouvez voir qu’il ya 25% d’écart de temps où un mineur peut tomber dans cette période. [ 25% = (5–4)/4 * 100]
  3. Si la valeur de t est de 8 minutes, puis chaque mineur qui termine l’exploitation d’un bloc avant une période de 9 minutes (avec une latence du réseau de 1 minute) ne contribuera qu’au gaspillage. Ici, vous pouvez voir qu’il existe un intervalle de temps de 12,5% dans lequel un mineur peut tomber dans cette période. [ 12.5% = (9–8)/8 * 100]
  4. Si la valeur de t 10 minutes, puis chaque mineur qui termine l’extraction d’un bloc avant 11 minutes (avec une latence du réseau de 1 minute) ne contribuera qu’au gaspillage. Ici, vous pouvez voir qu’il ya 10% d’écart de temps où un mineur peut tomber dans cette période. [ 10% = (11–10)/10 * 100]

Vous pouvez maintenant voir que le pourcentage de gaspillage diminue à mesure que le temps de blocage augmente. Selon tous les autres facteurs, Satoshi Nakamoto pense que le gaspillage à 10 minutes du bloc est acceptable. Parallèlement au gaspillage, si plusieurs nœuds commencent à générer le même bloc simultanément ou dans un court laps de temps, cela se traduira par plusieurs fourchettes de bitcoins plus fréquentes. Les personnes assidues rendront le réseau bitcoin moins sain et le temps de confirmation de la transaction augmentera, car tout le monde devra attendre que le réseau bitcoin soit finalement cohérent.

Remarque: Dans le calcul ci-dessus, 1 minute de latence du réseau a été prise à titre d'exemple pour faciliter le calcul. Un article publié en 2013 par Decker et Wattenhofer à Zurich mesure le temps de latence du réseau bitcoin et détermine que 12,6 secondes est le temps qu’il faut pour qu'un nouveau bloc se propage à 95% des nœuds.

Pourquoi le temps de blocage d’Ethereum est-il considérablement inférieur à celui de Bitcoin?

La durée moyenne des blocs d’Ethereum au moment de l’écriture est d’environ 17 secondes. Si l’histoire que nous avons racontée dans la section précédente est vraie, comment l’éthereum réduirait-il le gaspillage avec un temps de blocage aussi court – et réduirait également le risque de multiples fourchettes fréquentes. Ceci est résolu par la version modifiée du Sous-arbre glouton le plus lourd observé (GHOST) protocole suivi d'éthereum. Le GHOST est une innovation introduite par Yonatan Sompolinsky et Aviv Zohar en décembre 2013 et constitue la première tentative sérieuse de résolution des problèmes empêchant des blocages beaucoup plus rapides.

Comme indiqué dans la section précédente, le principal défi associé à la réduction de la durée des blocs est qu’il y aura plus de mineurs produisant le même bloc et qu’ils ne bénéficieront pas d’incitatifs économiques – et gaspilleront beaucoup de puissance de calcul sans impact sur la stabilité du réseau. De plus, cela se traduira par des fourches plus fréquentes. Quand une fourchette se produit, le réseau recherche la plus longue blockchain et chaque mineur y basculera. GHOST résout ce problème en incluant ces blocs obsolètes / orphelins dans le calcul de la recherche de la chaîne la plus longue – et en les récompensant. Dans l’éthereum, ces blocs sont appelés oncle des blocs. Un bloc oncle reçoit un pourcentage de la récompense normale du bloc – de sorte que la puissance de calcul dépensée pour exploiter les blocs périmés ne soit pas gaspillée sans incitation économique. Alors la question est, pourquoi ce n'est pas 1 seconde?

Ethereum choisit une durée de blocage comprise entre 10 et 19 secondes car elle est aussi rapide que possible, mais elle est en même temps considérablement plus longue que la latence du réseau. Un article publié en 2013 par Decker et Wattenhofer à Zurich mesure le temps de latence du réseau bitcoin et détermine qu’un délai de 12,6 secondes correspond au temps qu’il faut à un nouveau bloc pour se propager à 95% des nœuds; Cependant, le document souligne également que la plus grande partie du temps de propagation est proportionnelle à la taille du bloc.

Une autre raison est que, dans le Ethereum, tous les blocs oncle ne sont pas récompensés – et le temps de bloc ne devrait pas encourager plus de blocs oncle que ce qui peut être récompensé. Un bloc peut inclure jusqu'à deux oncles. Si un bloc fait référence à deux oncles, chaque oncle gagnera 7 / 8e des 5 ETH auprès de celui qui l'a miné. Chaque oncle référencé gagnera également une petite récompense par oncle (1/32 sur 5 ETH) au mineur qui fera référence aux oncles de son bloc. Comme vous pouvez le constater, le référencement peut atteindre un nombre illimité de niveaux – un bloc désigne deux blocs oncle – et l'un de ces blocs oncle désigne deux autres blocs oncle – et l'un de ces blocs oncle désigne deux autres blocs oncle. , également. Dans Ethereum, un bloc éventé ne peut être inclus comme oncle que par un descendant jusqu'à la septième génération d'un de ses frères et sœurs directs, et non par un bloc avec une relation plus éloignée. Cela a été fait pour plusieurs raisons [ref].

  1. GHOST illimité inclurait trop de complications dans le calcul des oncles valables pour un bloc donné.
  2. Les incitations illimitées pour les oncles, telles qu’elles sont utilisées dans Ethereum, éliminent l’incitation, pour un mineur, à exploiter sur la chaîne principale et non la chaîne d’un attaquant public.
  3. Les calculs montrent que la limitation à sept niveaux fournit la plupart des effets souhaités sans en subir les conséquences négatives.

Résumé

Le temps de blocage définit le temps nécessaire pour exploiter un bloc. Tant dans bitcoin blockchain que dans ethereum blockchain, il existe un temps de blocage attendu et un temps de blocage moyen. En bitcoin, la durée de blocage attendue est de 10 minutes, contre 10 à 20 secondes dans l’éthereum. Le temps de blocage est ajusté en fonction du niveau de difficulté. La principale différence entre le niveau de difficulté de Bitcoin et celui de l'Ethereum est que, dans bitcoin, le réglage de la difficulté est effectué après 2016 blocs pour maintenir le temps de blocage à une valeur constante (même si la puissance de calcul augmente), mais dans Ethereum, sur la base du calcul puissance, le temps de blocage augmentera (ou diminuera) en raison de la bombe de difficulté (ne pas essayer de le maintenir à une valeur constante) – et l’ajustement est effectué dans chaque bloc.



Traduit depuis https://medium.facilelogin.com/the-mystery-behind-block-time-63351e35603a

Carte de paiement Crypto

Demandez votre Carte de paiement Crypto ici

Recevez 8 € de BTC gratuitement


Inscrivez-vous à CoinBase