Rejoignez-Nous sur

Multicoin Capital: la séparation du temps et de l'état

Proof of Work   Time Chain   Clock

News

Multicoin Capital: la séparation du temps et de l'état

De nombreuses plates-formes de contrats intelligents (par exemple, Ethereum 2.0, Polkadot, Dfinity, Near Protocol, Algorand, Kadena, Spacemesh et Solana) vont être lancées au cours des deux prochaines années. Chaque équipe poursuit une stratégie de dimensionnement unique.

Cependant, la plupart de ces approches ne résolvent pas l'un des problèmes fondamentaux des systèmes informatiques distribués dans les environnements byzantins: le problème de l'horloge. Pour parvenir à un consensus, au moins 51% des machines du réseau doivent exécuter les mêmes transactions dans le même ordre et au même moment. Pour ce faire, les machines doivent se mettre d’accord sur une horloge globale. Le «problème de l'horloge» est le défi qui consiste à amener de nombreuses machines méfiantes à s'accorder sur une horloge globale dans un contexte byzantin. Une fois que tout le monde s’accorde sur une horloge globale, l’ordre des transactions devient un problème beaucoup plus simple, car chaque transaction est horodatée à l’aide de la même horloge globale.

Le problème de l'horloge s'est manifesté dans d'autres réseaux à grande échelle avant l'ère de la cryptographie moderne, notamment dans le monde des communications sans fil. Les tours cellulaires doivent prendre en charge des dizaines de milliers de téléphones portables à la fois. Il n’y avait pas assez de bande passante pour que chaque téléphone dispose de sa propre fréquence radio, les télécoms avaient donc besoin de «technologies d’accès multiples» pour encaisser plusieurs appels téléphoniques sur la même fréquence.

CDMA (Code-Division Multiple Access) a été inventé pendant la Seconde Guerre mondiale. CDMA exige que chaque téléphone chiffre ses données avec une clé unique et les transmette sur plusieurs fréquences en même temps que d’autres téléphones, en s’appuyant sur la tour cellulaire pour répartir le signal combiné en appels individuels. L’efficacité de ce schéma ne s’améliore qu’au fur et à mesure de la complexité du schéma de chiffrement. Pour les réseaux largement disponibles qui doivent prendre en charge des terminaux finaux bon marché, ce taux d'amélioration a toujours été lent et constant.

Les entreprises de télécommunication ont réalisé des gains d’efficacité beaucoup plus rapides en mettant en œuvre l’accès multiple par répartition dans le temps (TDMA), qui est devenu la solution standard pour faire face au problème de l’horloge depuis l’avènement des réseaux à cellules 2G. TDMA spécifie que les tours divisent chaque fréquence radio en intervalles de temps et attribuent ces intervalles à chaque appel téléphonique. De cette manière, la tour de cellules fournit une horloge disponible globalement pour le réseau. Cela augmente considérablement l'évolutivité de la bande passante limitée en permettant à chaque fréquence de prendre en charge plusieurs canaux de données simultanés et en réduisant les interférences provenant de plusieurs téléphones diffusant sur la même fréquence au même moment.

Dans cet article, je vais explorer comment différentes blockchains traitent le problème du temps dans les environnements byzantins. Je conclurai en affirmant que la blockchain qui construit l’horloge la plus efficace séparera avec succès le temps et l’état et pourra évoluer pour prendre en charge le débit de millions d’utilisateurs de manière sécurisée et décentralisée.

Consensus décentralisé avec une horloge

Base de données Google Spanner est l'une des bases de données distribuées dans le monde les plus performantes au monde avec 18 instances toutes les transactions de traitement en parallèle. Il prend en charge plus de 50 000 transactions par seconde (TPS) avec un délai de réalisation (TTF) inférieur à 1 seconde. Spanner utilise l'algorithme de consensus Paxos, qui a été publié pour la première fois en 1989. Spanner est une base de données approuvée et autorisée. Paxos permet à Spanner de progresser face aux pannes de courant, aux pannes de serveur, aux bugs malveillants et à de nombreuses autres défaillances.

Comment Paxos parvient-il à atteindre de telles performances alors que la blockchain au débit le plus élevé peine aujourd'hui à atteindre plus de 5 000 TPS avec seulement 21 instances? Google paie des ingénieurs à plein temps pour être sur site et synchronise régulièrement les horloges atomiques de chaque centre de données avec une très grande précision. Fournir une horloge de confiance disponible au niveau mondial permet de chronométrer les transactions de manière à ce que chaque instance puisse recevoir des transactions dans le désordre tout en les traitant dans le bon ordre. Il s'agit d'une séparation de l'heure et de l'état, chaque instance mettant à jour son état sans avoir à vérifier auprès de ses pairs pour s'assurer qu'ils effectuent les mêmes actions dans le même ordre.

Que pouvons-nous apprendre de Spanner? S'il existe une horloge disponible globalement dans un cadre non byzantin, parvenir à un consensus est trivial. Malheureusement, les plates-formes de contrat intelligentes ont aujourd’hui deux contraintes supplémentaires que Spanner n’a pas:

  1. Devenir un validateur doit être sans autorisation pour que la plate-forme résiste à la censure.
  2. Les blockchains doivent protéger les fonds des utilisateurs même si jusqu'à ⅓ des validateurs sont malveillants

Si quelqu'un peut créer une instance de validateur n'importe où dans le monde, des algorithmes consensuels doivent être conçus pour prendre en charge différentes configurations de matériel et de réseau, et doivent également gérer des validateurs malveillants. De plus, afin de résister réellement à la censure, aucune information hors bande ne peut être fiable (alias le problème d'Oracle).

20 ans après l'invention de Paxos, quelqu'un a découvert comment obtenir un consensus sur un réseau d'ordinateurs sans autorisation pour parvenir à un consensus sur un ordre canonique des transactions. Il s’agissait de Satoshi Nakamoto et la solution reposait sur un consensus sur la validation du travail.

Preuve de travail + Timechain = Clock

Racontant, La version préliminaire du code Bitcoin de Satoshi effectivement appelé la structure de données blockchain familière "le timechain" à la place. Ce timechain est conçu pour cocher toutes les 10 minutes en moyenne (via un ingénieux enchevêtrement de preuves de travail, l’adaptation de la difficulté et la règle de la chaîne la plus longue, ce qui dépasse le cadre de cet essai), dans lequel chaque tick est présenté sous la forme: un bloc de transactions qui met à jour l'état global. Une fois qu'un nœud a exécuté un bloc de transactions, il ne peut effectuer aucune mise à jour d'état avant de créer un nouveau bloc valide ou de recevoir un nouveau bloc valide du réseau. Dans PoW, le temps et l'état sont couplés, progressant toujours à l'unisson. Le temps ne peut pas avancer sans mise à jour.

Ce qui rend un bloc "valide" est un sujet très controversé. Les formats de transaction et les tailles de bloc ne sont que deux des nombreuses qualités prises en compte. Un aspect d'un bloc valide qui ne fait pas l'objet d'un débat, cependant, est qu'il doit contenir le hachage d'un bloc précédent pour que le réseau sache le placer après ce bloc précédent dans la chaîne de temps.

Preuve de travail + chaîne du temps = horloge

Image: Chaque bloc d'une blockchain inclut le hachage du bloc précédent comme preuve qu'il est venu après.

La timechain a pour but de répondre à l'exigence n ° 2 ci-dessus: devenir un validateur doit être sans autorisation. Le seul moyen de valider la validité de l'état actuel du réseau Bitcoin consiste à partir de l'état du bloc de genèse et à exécuter chaque transaction de la genèse à l'état actuel. Timechain fournit la trace d'audit à suivre par un nouveau validateur en prouvant que les transactions dans le bloc de hauteur 12 ont été exécutées et doivent être exécutées après les transactions dans le bloc de hauteur 11. Parce que le bloc 12 doit inclure le hachage du bloc 11, le bloc 12 n'a pu être créé qu'après le bloc 11. Cette chaîne temporelle de hachages produit une horloge logique, monotone – quoique irrégulière et peu granulaire – que tout validateur du réseau peut vérifier indépendamment sans aucune information hors bande.

Produire cette horloge mondialement fiable et de confiance dans un environnement ouvert et sans autorisation est la plus grande innovation de Satoshi. Étant donné que l'état global est verrouillé jusqu'à ce que l'horloge globale se déclenche avec un nouveau bloc, le calcul de l'évolutivité est simple:

Débit (TPS) = Taille du bloc (txs par bloc) / Durée du bloc (secondes par bloc)

Pour augmenter le débit, le protocole doit soit augmenter la taille du bloc, soit réduire sa durée. L'augmentation de la taille des blocs nuit à la décentralisation des producteurs de blocs, et la réduction du temps de blocage augmente la probabilité des fourches en chaîne.

Parce que le temps et l'état sont liés, il n'y a pas moyen de contourner cela.

Pour revenir à l’exemple de communication sans fil, comparons ce problème à CDMA. En CDMA, les tours radio ont une largeur de bande fixe de fréquences qu’elles peuvent écouter, ce qui est analogue à la façon dont les producteurs de blocs ont une taille de bloc fixe qu’ils peuvent traiter. L'augmentation de l'évolutivité dans CDMA signifie la création de schémas de codage plus complexes pour adapter davantage d'appels téléphoniques dans cette bande passante limitée. Ceci est analogue aux signatures Segwit, aux canaux Lightning et aux signatures Schnorr, qui sont des schémas de codage plus complexes permettant des performances améliorées.

Bitcoin a des blocs de 1 Mo, un temps de bloc de 600 secondes et une taille de transaction minimale de 250 B, soit un débit théorique maximal de 7 TPS. Cela représente environ 7 000 fois moins de débit et 3 600 fois plus lent que TTF (puisqu'il faut 6 temps de bloc pour atteindre une finalité irréversible probabiliste) par rapport à Spanner.

Clairement, il y a place à amélioration.

Preuve de participation + Timechain = Horloge plus rapide

La croissance de Bitcoin a déclenché une renaissance de la recherche sur les algorithmes de consensus. le Théorème de la PAC nous indique que, dans le cas d’une partition réseau, un système de base de données répartie doit choisir entre la cohérence (un arrêt du réseau) et la disponibilité (une connexion réseau). L’algorithme de Satoshi est le premier algorithme de consensus BFT sans permission de la famille du consensus Nakamoto, qui choisit tous la disponibilité plutôt que la cohérence. Il y a beaucoup algorithmes de consensus dans la famille Nakamoto.

L’algorithme Paxos de Leslie Lamport a été le premier de la Famille de consensus classique, qui privilégient la cohérence plutôt que la disponibilité.

Dans Paxos et dans de nombreux autres algorithmes de la famille Classical Consensus, chaque nœud participant au consensus doit communiquer de manière synchrone avec chaque autre validateur du réseau pour chaque mise à jour d'état. Cela rend la complexité de la communication O (n ^ 2) (où n est le nombre de validateurs), ce qui signifie que le temps requis entre chaque mise à jour d'état augmente de manière exponentielle à mesure que le nombre de validateurs augmente.

Jae Kwon et Ethan Buchman ont été les premiers à utiliser les 20 années de recherche sur le consensus classique et à les doter d'une structure incitative cryptoéconomique appelée Bonded Proof of Stake (BPoS) pour limiter en toute sécurité le nombre de validateurs. Le résultat de leurs travaux est le premier algorithme de consensus BFT performant, sans permission, de la famille Classical Consensus: Tendermint.

Comme le consensus de Nakamoto, Tendermint regroupe les mises à jour des états et des temps, de sorte que son débit n'augmente que lorsque la taille des blocs augmente ou que la durée des blocs diminue. Lorsque Bitcoin a été inventé en 2009, un bloc de 10 minutes était raisonnable. Cependant, la bande passante a augmenté de façon exponentielle depuis lors, permettant aux chaînes Tendermint de réduire les temps de blocage à quelques secondes seulement.

Comme les fourchettes sont impossibles, car Tendermint privilégie la cohérence, le temps de blocage peut être réduit jusqu’à atteindre les limites des performances du système goulot d’étranglement réseau pour un nombre de validateurs donné. Aujourd'hui, Tendermint permet au réseau de limiter en toute sécurité son nombre de validateurs à 100, ce qui présente l'avantage de filtrer les nœuds avec une bande passante insuffisante et de permettre des blocs plus grands.

Tendermint est en production. Le Cosmos Hub (la première instance live de Tendermint) est exécuté à une Bloc de 6 secondes avec Blocs de 150 ko, ce qui permet un débit maximum de 100 TPS (en supposant des transactions de 250 octets). Il n'a encore que quelques mois et mûrira rapidement. Théoriquement, un réseau Tendermint avec des temps de bloc de 5 secondes et des blocs de 5 Mo pourrait atteindre 4 000 TPS avec des sacrifices minimes en termes de résistance à la censure et d’absence de permission par rapport à Bitcoin – c’est une augmentation de 570x du débit et une diminution de 720x du TTF!

Malheureusement, en raison de la nature synchrone des algorithmes Classical Consensus, l'appariement de Spanner aurait un impact négatif sur les propriétés de résistance à la censure et d'absence de permission du système. Les blocs plus gros prendront inévitablement plus de temps à se propager sur le réseau et plus de temps aux validateurs à vérifier, ce qui permettra de déterminer à quel point les temps de blocage peuvent être longs. Pour augmenter la vitesse de l'horloge, le nombre de validateurs devrait diminuer considérablement et tous devraient être connectés directement au même réseau à fibre optique. Cela augmenterait à la fois le risque de collusion entre validateurs et la barrière à l'entrée pour les nouveaux validateurs, et ferait de l'opérateur du réseau à fibres un point de centralisation.

La prochaine évolution du consensus sur la blockchain représente une étape importante dans la séparation du temps et de l’état, en augmentant considérablement le débit, mais à un coût relativement élevé.

Sharding + Timechain = horloges indépendantes

Avec BPoS, Tendermint a dissocié la résistance à la censure du nombre de validateurs, ce qui a permis à l’horloge du réseau de passer toutes les 600 secondes à toutes les 5 secondes, permettant ainsi d’améliorer considérablement les performances. Cependant, entre chaque tic-tac d'horloge, tout l'état global est toujours verrouillé pour maintenir un état cohérent à l'échelle mondiale.

L'un des moyens d'atténuer ce problème consiste à décomposer l'état global en un groupe de petits morceaux, chacun avec leurs propres horloges indépendantes, qui peuvent progresser indépendamment les uns des autres. Tant que ces fragments n'ont pas besoin d'interagir entre eux, les performances de chaque fragment restent inchangées et le débit global de tous les fragments augmente linéairement avec le nombre de fragments.

Cosmos envisage de nombreux réseaux de chaînes de blocs indépendants existant en parallèle, capables de transférer de la valeur entre eux, mais effectuant surtout des transactions au sein de leurs propres systèmes. Si chaque réseau peut traiter 4 000 TPS et qu'il y a 13 réseaux différents, le système dans son ensemble peut surperformer Spanner à 52 000 TPS! Cependant, cette approche pose deux problèmes:

  1. La sécurité d’une blockchain avec une preuve de prise est mesurée par le coût que représentent l’acquisition de 33% de jetons jalonnés et l’approbation de transactions non valides. Si au lieu d'une seule alimentation en jetons, il y a 13 réseaux distincts, le coût d'acquisition de 33% d'un réseau donné est considérablement réduit. Ceci est beaucoup moins sûr et nuit considérablement à la proposition de valeur d’une blockchain, dans laquelle la sécurité est une fonction de la valeur du réseau.

  2. La durée de vie (TTF) pour les transferts inter-réseaux augmente d'au moins 4x par rapport aux transferts intra-réseau. Les réseaux doivent communiquer d'avant en arrière pour synchroniser leurs horloges et s'assurer que si Alice envoie des jetons à Bob, il reçoit correctement de la valeur sur son réseau avant que ses jetons ne soient brûlés sur son réseau.

Alors que Cosmos envisage un monde avec de nombreux réseaux souverains qui gèrent leur propre sécurité, Ethereum 2.0, Polkadot, Algorand, Dfinity et Near Protocol construisent des systèmes pour résoudre au moins le problème de sécurité partagée (n ° 1 ci-dessus). L’approche de chaque équipe présente des différences nuancées, mais l’architecture de base repose sur une chaîne de balises unique qui fournit une horloge pour le reste du réseau et qui mélange de manière sécurisée les validateurs d’un fragment à l’autre afin qu’ils partagent le même pool de sécurité. Comme avec Cosmos, augmenter le débit est facile: ajoutez simplement plus de fragments!

Sharding "src =" http://images.ctfassets.net/qtbqvna1l0yq/1S9pFmO9VhdH5l66iKddds/11dcb4fe803496bce8cd1bac4f4e368c/Sharding.jpg "/></p><p><em><a href=Image: Ethereum 2.0, chaîne unique et état fragmenté.

Malheureusement, le facteur TTF élevé pour les transferts inter-réseaux (n ° 2 ci-dessus) demeure. Même si la chaîne de balises fournit une horloge globale, chaque fragment synchronise uniquement son horloge locale avec celle de la chaîne de balises. Pour qu'Alice envoie des jetons de la partition A à Bob de la division B, les validateurs de la division A doivent prouver qu'ils ont gravé les jetons d'Alice avant que les validateurs de la partition B ne frappent un nombre équivalent de jetons pour Bob. Pour la conception actuelle d’Ethereum 2.0, ce processus prendra 6 minutes, 60 fois la durée du bloc entre fragments.

Bien que le sharding puisse aider, les limitations fondamentales de la mise à l'échelle sont toujours liées au fait que les mises à jour de temps et d'état dans chaque fragment sont couplées. Chaque fragment est toujours soumis aux mêmes limites que Tendermint en ce qui concerne la taille et le temps des blocs.

L'éclatement est analogue à certains éléments de la TDMA; l'État est divisé en fragments séparés avec leurs propres horloges, d'une manière comparable à la façon dont les tours de téléphonie cellulaire divisent leur bande passante en fréquences radio et créneaux horaires distincts. Les avantages de cette opération sont clairs, mais pas pleinement exploités, comme en témoigne la latence entre fragments.

Mais que se passe-t-il s’il est possible de découpler complètement les mises à jour de temps et d’état dans un paramètre sans autorisation?

Séparer le temps et l'état

Jusqu'à présent, nous avons expliqué comment Satoshi avait créé la structure de données timechain afin de fournir une horloge sans confiance au réseau Bitcoin. comment Kwon et Buchman ont appliqué BPoS à Paxos pour réduire en toute sécurité le nombre de validateurs et accélérer l'horloge réseau Tendermint; et comment la fragmentation du réseau en plusieurs parties avec des horloges indépendantes peut considérablement augmenter le débit (tant que les transactions entre fragments sont minimisées). Au cours de chacune de ces progressions, nous avons toutefois noté que les mises à jour des états et des heures restaient couplées, qu'elles n'étaient mises à jour que parallèlement aux horloges et que cela créait des limites fondamentales au débit et au temps requis pour la censure et l'absence de permission. réseaux informatiques.

La séparation du temps et de l'état nécessite une horloge disponible à l'échelle mondiale, rapide, précise et dont la confiance est minimisée. Avec une telle horloge, les mises à jour d'état peuvent se produire de manière continue et asynchrone, comme c'est le cas dans Spanner. Tant que tout le monde s'accorde sur une horloge globale et que les transactions sont horodatées, les transactions peuvent circuler en continu sur le réseau.

Solana a créé une horloge minimisant la confiance pour sa plate-forme de contrat intelligent en séparant la timechain basée sur le hachage du consensus sur les mises à jour d'état. Au lieu d'enchaîner les hachages à chaque bloc, les validateurs du réseau Solana hachent les hachages eux-mêmes en continu, intra-bloc. Ce mécanisme, appelé Proof of History (PoH), produit une timechain granulaire disponible au niveau mondial, minimisant la confiance, avec laquelle tous les nœuds du réseau doivent se synchroniser.

Plonger dans la mécanique de PoH est hors de portée pour cet essai. Pour plus de détails sur le fonctionnement de PoH, veuillez consulter Documentation PoH de Solana.

Temps et état de séparation

Image: Comment Preuve de l'Histoire tisse un horodatage standardisé dans la blockchain.

La présence de cette chaîne de temps indépendante permet au dirigeant de propager au comité les transactions horodatées dès qu'elles sont reçues. L'horodatage fournit l'ordre canonique au lieu d'un ordre arbitraire déterminé par le producteur de blocs. Les tentatives de doubler les dépenses sont maintenant faciles à résoudre, car tout le réseau est capable de s’entendre sur la transaction qui est arrivée en premier.

Cela change tout.

Au lieu d'obliger les validateurs à parvenir à un consensus toutes les 6 à 600 secondes afin de vérifier le temps qui passe, les validateurs de Solana peuvent transmettre en continu en temps réel les mises à jour de l'état à leurs pairs.

Au lieu de devoir attendre la confirmation de chaque validateur comme dans toutes les autres chaînes de blocs, Solana peut utiliser un nouveau mécanisme de déploiement appelé Turbine (inspiré par BitTorrent) pour conserver la complexité de la communication O (log (n)) au lieu de O (n ^ 2). Cela permet à Solana de traiter plus de 50 000 TPS sur un seul et même état global avec une finalité rapide, sans requérir de fragmentation.

Cela signifie que la taille du pool de validateur est comparable à Tendermint, de l'ordre de 100 à 1 000, mais que les fourchettes en chaîne sont autorisées. Une politique de gestion de fourche agressive est nécessaire pour que le système converge rapidement sur une seule chaîne chaque fois qu'un segment de chaîne se présente, un compromis nécessaire pour une progression asynchrone et une disponibilité constante.

PoH a pour but de verrouiller ce que la TDMA est aux réseaux cellulaires. Imaginez les 1 000 validateurs de Solana en tant que tours radio utilisant leurs horloges synchronisées pour subdiviser leur bande passante en créneaux horaires individuels. Ils reçoivent en permanence de nouvelles transactions, chacune avec un hachage PoH signé attaché par l'expéditeur, et les transmettent à leurs voisins qui peuvent immédiatement les commander en utilisant ces hachages PoH. Lorsque les leaders tournent en fonction de l'horloge globale, chaque leader choisit un ensemble ordonné de transactions à exécuter, puis commère cette "entrée" sur le réseau. Les validateurs renvoient leurs votes sur chaque «entrée» et finalisent les transactions quand ils constatent que ⅔ des validateurs ont voté à leurs côtés.

Le réseau dans son ensemble traite en permanence les transactions dans le même ordre avec des volumes incroyablement élevés, mais chaque validateur progresse indépendamment. C'est un changement subtil mais profond par rapport aux autres chaînes. À Solana, les validateurs ne cessent jamais de progresser. Ils avancent toujours indépendamment, quelles que soient les conditions du réseau et le consensus.

Il existe d’autres problèmes tangentiels (croissance rapide de la chaîne, nouveau modèle de programmation, non-stabilité de la chaîne temporelle, parallélisme, par exemple) soulevés par cette nouvelle conception qui dépassent le cadre de cet essai, bien qu’ils soient abordés dans Documentation de Solana. Les réseaux de test de Solana traitent aujourd’hui plus de 50 000 TPS avec une durée de vie moyenne de 1,5 seconde sur des réseaux de 200 validateurs répartis sur 5 continents. C’est comparable à Spanner, à la différence qu’il est véritablement décentralisé.

Ce niveau de performance dans un ordinateur mondial sans confiance et minimisé en confiance n’est possible que grâce à la séparation du temps et de l’état de Solana. L’horloge globalement disponible du réseau Solana permet à chaque nœud de mettre à jour son état sans avoir à communiquer avec d’autres nœuds, tout comme Spanner.

Recadrage de l'évolutivité

Bien que la communauté cryptographique ait écrit ad nauseam sur les modèles d’évolutivité et de consensus, aucune n’a exploré spécifiquement le problème de l’horloge distribuée. Avec plusieurs années de recherche sur les preuves de participation qui ont abouti à Tendermint + BPoS en tant que meilleur résultat de sa catégorie, et de nombreuses propositions de découpage, toutes convergeant essentiellement autour de l’architecture balise chaîne + état, une chaîne de temps granulaire qui permet la progression asynchrone fournir les meilleures performances pour les systèmes non durcis qui préfèrent la disponibilité à la cohérence.

Fournir une horloge disponible dans le monde entier permet à l'équipe Solana de s'appuyer sur plus de 40 années de recherche sur les systèmes distribués, ce qui est par ailleurs inapplicable. Des concepts comme Contrôle de concurrence optimiste ont été inventés en 1981 et ont été utilisés dans des projets informatiques à grande échelle pendant des années, mais ne peuvent pas être appliqués lorsque le temps et l'état doivent progresser ensemble. Le traitement parallèle avec les GPU existe depuis 1995, bien qu'il se soit largement limité aux cartes graphiques jusqu'à la publication par Nvidia de l'environnement de développement CUDA en 2007, mais il ne peut pas être pleinement exploité par des systèmes basés sur des chaînes de blocs qui verrouillent de manière pessimiste tous les états, à l'exception des comptes actuellement touchés par un conflit. transaction.

Comprendre le passage du temps est primordial pour la performance des systèmes distribués dans les paramètres avec et sans autorisation. Le temps est primordial, et grâce à une nouvelle façon de coder le passage du temps sous forme de preuve d'histoire, les systèmes sans autorisation peuvent égaler les performances de fournisseurs de calcul en nuage centralisés et éprouvés.

Grâce à Anatoly Yakovenko et Zaki Manian pour fournir des commentaires sur cet essai.


与 状态 之 分离

Ryan Gentry
译 June Chan

Haut de la page 2.0 sur le Polkadot Définition de la finesse près du protocole Algorand sur Kadena sur Spacemesh avec Solana sur Solana avec Solana sur l'écran

大多数 这些 中 分布式 的 一 : : 问题。一点 一事务

加密 时代 大 规模自己 的 无线 ,

(CDMA) 二战 一 个 唯信号

G 网络 TD (TDMA) 解决时间并 一 频率 的 广播 干扰

本文 中 , 的去 中心 的 方式 的 吞吐量。

· 中心 化 共识 与 时钟

Sp 歌 的 SpannerPlus de 50 000+ points de vente (TPS) Plus de 50 000+ points de vente (TTF) Plus de 50 000+ points de vente (TPS) à partir de (TTF) à partir de 1 heure Clé par 1989 par Paxos par Spanner par le bogue Paxos par Spanner par le bogue

Plus de détails sur 21000 produits de plus de 5 000 TPS dans la région de Paxos dans la région de Paxos.中心 的 原子钟。 提供 一提供都会 更新

学 学 能从 能从 能从 能从 能从

  1. 一个 的 的 抗
  2. 必须 保护 的 的 的

任何 人 都(预言 机 问题

Paxos 20 avril 20, 10 h 30 hi hi hi (Satoshi Nakamoto) .

· 证明 + 时间 链 = 时钟

的 是 ,中 本 聪 提前 发布 的 比特 币 源 代码将 人们 熟悉 的 区块 数据 结构 “时间 链” (Timechain) 链 时间 链 的 tick tick tick tick tick tick整合 在一起 , 文 的 范围生成 一个 的 新 一 的 有效

能令 区块 “” 这个 一话题 的它 必须 包含 个 一个 的 哈希 中 中 的 前 一

Preuve de travail + chaîne du temps = horloge: 链 中 的 每个 一个 的 哈希。

的 目的 是 的 # 2 : 一个 验证当前 状态 的 每 一笔 的 12必须 包含 第 11 的 哈希 12 11网络 中 的 任何

一个 开放 的 、 的 中 生产 最:

Débit (TPS) = Taille du bloc (txs par bloc) / Durée du bloc (secondes par bloc)

(TPS) = 大小 (区块 txs) / 时间 (块 秒)

吞吐量 大小

和 的 , 它

无线 通信 的 例子 , 与 与 MA MA MA 处理。 提高 MA MA 提高 提高 提高 提高 提高 提高 提高 MA MA MA MA MA MA MA MA MA MA MA MA MA MA MA MA均 可以 性能。

À propos de 1 MB Aide à propos de 600 Avis de livraison 7 jours avant 7 jours avant 7 jours ouvrables à partir de 7 mois 3600 personnes 6 personnes 6 personnes aiment ça

比特 币 的 空间。

· 证明 + 时间 链 = 的 时钟

币 的 发展 研究 的 研究CAP, 在 的 情况 致性 致性 致性 断 中断 中 中算法 这个 大 家族 中 有 本 本

相较中本聪家族,经典共识算法家族则更喜欢一致性而非可用性,其中之首是Leslie Lamport的Paxos算法。

在Paxos和许多其他经典共识家族的算法中,每个参与共识的节点必须与网络中的其他所有验证器同步通信,以进行每个状态更新。这使得通信复杂度为O(n2) (其中n是验证器计数),这意味着随着验证器计数的增加,每个状态更新之间所需的时间呈指数级增长。

Jae Kwon和Ethan Buchman率先从事经典共识研究,为之倾注了20年的时间,他们将一种名为“绑定权益证明”(BPoS)的加密经济激励结构注入其中,以安全地限制验证器的数量。他们所取得的工作成果,便是经典共识家族中的第一个高性能、无许可的BFT共识算法:Tendermint

与中本聪共识一样,Tendermint捆绑了时间和状态更新,因此只有当区块大小增加或区块时间减少时,它的吞吐量才会增加。2009年比特币问世时,10分钟的区块时间是合理的。然而,自那以后,带宽呈指数级增长,使得Tendermint链的区块时间缩短到了几秒钟。

因为Tendermint更喜欢一致性,不可能分叉,所以可以减少区块时间,直到某个给定验证器计数的网络吞吐量瓶颈系统性能达到极限为止。现在,Tendermint允许网络安全地将验证器数量限制在100个以内,这样做的好处是过滤掉带宽差的节点,并允许使用更大的区块。

Tendermint正在生产中。Cosmos Hub(第一个实时Tendermint实例)以6秒的区块时间运行,区块大小为150 kB,最大吞吐量为100 TPS(假设事务为250字节)。它还只有几个月的历史,不过很快就会成熟。从理论上讲,拥有5 秒出块时间和5 MB区块大小的Tendermint网络可以达到4000 TPS吞吐量,而与比特币相比,它在抗审查性和无许可性方面所做出的牺牲最小——这意味着吞吐量增加了570倍,TTF减少了720倍!

遗憾的是,由于经典共识算法的同步特性,匹配Spanner会对系统的抗审查性和无许可性产生不利影响。更大的区块将不可避免地需要更长的时间来在网络中传播,验证器也需要更长的时间进行验证,这就为出块时间设定了一个下限。为了提高时钟的速度,验证器的数量需要显著减少,而且它们都需要直接连接到同一个光纤网络。这将增加验证器串通合谋的可能性和新验证器进入的障碍,并使光纤网络的操作员成为一个中心点。

区块链共识的下一个演进将采取一个重要步骤来分离时间和状态,以相当高的成本获得巨大的吞吐量提升。

·分片+时间链=独立时钟

使用BPoS, Tendermint解除了验证器数量带来的抗审查性,这使得网络时钟从每600秒滴答一次加速到每5秒一次,从而大大提高了性能。然而,在时钟的每一次滴答之间,整个全局状态仍然被锁定,以保持全局一致的状态。

缓解这一问题的一种方法是将全局状态分割成一串更小的碎片,每个碎片都有自己独立的时钟,可以彼此独立前进。只要这些分片不需要相互交互,每个分片的性能就能保持不变,并且所有分片的总吞吐量随切分的数量线性增加。

Cosmos设想许多独立的区块链网络并行存在,能够在彼此之间传递价值,但主要是在各自的系统内进行交易。如果每个网络可以处理4000TPS,并且有13个不同的网络,那么整个系统可以达到52000 TPS,超过Spanner的吞吐量!不过,这种方法存在两个问题:

1) 权益证明区块链的安全性是通过获得33%的抵押代币和批准无效交易的成本来衡量的。如果不是单一的代币供应,而是有13个单独的网络,那么获得给定网络33%的份额的成本将大大降低。这远谈不上安全,而且严重损害了区块链的价值主张,其中安全是网络价值的一个功能
 2) 与网络内传输相比,网络间传输的TTF至少增加4倍。网络必须来回通信以同步它们的时 钟,并确保如果Alice向Bob发送代币,需要在网络上烧掉Alice的代币之前,令Bob成功在他的网络上接收到价值。

尽管Cosmos设想了一个由许多自主网络管理自身安全的世界,但以太坊2.0、Polkadot、Algorand、Dfinity和Near Protocol正在构建至少能够解决共享安全问题的系统(上述需求#1)。每个团队的方法都有细微的差别,但是基本的体系结构包括一个信标链,它既为网络的其余部分提供时钟,又安全地将验证器跨分片打乱,以便它们都共享一个公共的安全池。与Cosmos一样,增加吞吐量很容易:只需添加更多的分片!

Sharding" src="http://images.ctfassets.net/qtbqvna1l0yq/1S9pFmO9VhdH5l66iKddds/11dcb4fe803496bce8cd1bac4f4e368c/Sharding.jpg"/><a href=图说:以太坊2.0的单链和分片状态。

遗憾的是,网络间传输的高TTF问题(上述需求#2)仍然存在。即使信标链提供了一个全局时钟,每个分片也只是周期性地将其本地时钟与信标链的时钟同步。为了让Alice从分片A向分片B中的Bob发送代币,分片A中的验证器必须证明它们烧掉了Alice的代币,然后分片B中的验证器才能为Bob生成等量的代币。按照以太坊 2.0目前的设计来计,这个过程将花费6分钟,是跨分片区块时间的60倍。

虽然分片有用,但是基本的扩展限制仍然基于每个分片中的时间和状态更新是耦合的这一事实。面对Tendermint有关区块大小和区块时间的问题,每个分片仍然受到同样的限制。

分片类似于TDMA的某些元素;状态被划分成独立的分片,使用它们自己的时钟,就像手机信号塔把它们的带宽划分成独立的无线电频率和时间段一样。这样做的好处很明显,但并没有得到充分利用,这一点可以从跨分片延迟得到证明。
但是,如果可以在无许可设置中完全解耦时间和状态更新,情况会怎样呢?

·分离时间和状态

到目前为止,我们已经讨论了中本聪如何创建时间链数据结构,来为比特币网络提供一个免信任的时钟;Kwon和Buchman如何将BPoS应用于PBFT中,从而安全地减少验证器数量并加快Tendermint网络时钟;以及使用独立时钟将网络分片成许多小块将如何极大地提高吞吐量(只要将跨分片事务最小化)。然而,通过这些进展,我们已经注意到状态和时间的更新仍然是耦合的,状态更新只与时钟滴答同时发生,这为抗审查和无许可的计算网络的吞吐量和实现最终性的时间造成了根本上的限制。

分离时间和状态需要一个全局可用的时钟,它是快速、精确和信任最小化的。使用这样的时钟,状态更新可以像在Spanner中一样连续和异步地发生。只要每个人都同意使用一个全局时钟,并且事务具有时间戳,事务就可以在网络中持续流动。

通过将基于哈希的时间链与对状态更新的共识中分离,Solana已经为他们的智能合约平台构建了一个信任最小化的时钟。Solana网络中的验证器不是将哈希链接到每个块上,而是在块内连续地散列哈希本身。这种机制称为历史证明(Proof of History, PoH),它为网络中要同步的所有节点生成一个全局可用、信任最小化的细粒度时间链。
深入研究PoH的机制超出了本文的范围。有关PoH如何运作的更多细节,请参阅Solana的PoH文档

Seperating Time and State图说:历史证明将标准化的时间戳编织到区块链中的方式。

这种独立的时间链的存在使得领导者在收到分配有时间戳的交易后,会尽快向委员会传播。时间戳提供规范的顺序,而不是由区块生成者确定的任意顺序。由于整个网络都能够就哪个事务先发生达成一致,所以现在解决双花的尝试是很容易的。

它改变了一切。

Solana中的验证器可以不断地向其对等方实时发送状态更新,而不是强制验证器每隔6-600秒达成共识,以验证时间的推移。

Solana不需要像其他所有区块链一样等待每个验证器的确认,而是可以使用一种名为Turbine的新型扇出机制(灵感来自BitTorrent)来保持通信复杂度,即复杂度为O(log(n)),而不是O(n2)。这使得Solana可以在单个全局状态下处理超过 50,000 TPS,且能实现快速最终性,而且还不需要分片。

这意味着验证器池的大小与Tendermint相当,大约100-1,000个,但是允许进行链分叉。需要一个积极的分叉管理策略,以确保无论何时出现一个链分叉,系统都能快速地收敛到单个链上,这是异步进程和恒定可用性的必要折衷。

将无线通信比喻成一个完整的轮回,PoH对于区块链的意义就像TDMA对于蜂窝网络的意义一样。把Solana的1,000个验证器想象成无线电发射塔,利用它们的同步时钟将它们的带宽细分为各个时间段。它们不断地接收新的事务,每个事务都有发送者附加的签名PoH哈希,并将它们转发给邻居,邻居可以立即使用这些PoH哈希进行排序。当领导者根据全局时钟进行轮换时,每个领导者都会选择一组有序的事务来执行,然后将“条目”传播到网络。验证器对每个“条目”投票,在他们看到⅔的验证器与自己一起投票后,确认事务终结。

这个网络作为一个整体,不断地以难以置信的高容量,按照相同的顺序处理事务,但是每个验证器都在独立地进行。相对于其他链条,这是一个微妙而深刻的变化。在Solana中,验证器永远不会停止前进。而且不管网络条件和共识如何,他们总是独立前进。

还有其他一些相关但不太重要的问题(例如快速的链增长、新的编程模型、时间链的不偏性、并行性),这些新设计超出了本文的讨论范围,不过在Solana的文档中已经讨论过了。如今,Solana的测试网在5大洲200个验证器的网络上处理超过50,000个TPS,平均TTF为1.5秒。这些参数与Spanner旗鼓相当,只不过Solana是在有目的地去中心化。
在一个信任最小化、无许可的计算机领域中,这种级别的性能只有在Solana将时间和状态分离的情况下才可能实现。Solana网络的全局可用时钟允许每个节点更新其状态,而不需要像Spanner那样与任何其他节点通信。

·重构可伸缩性

尽管加密社区已经就可伸缩性和一致性模型撰写了连篇累牍的文章,但是没有人专门研究分布式时钟的问题。几年来对权益证明的研究,带来的最佳成果是Tendermint + BpoS,无数分片方案基本上都围绕着信标链+状态分片架构展开,而允许异步状态进展的细粒度时间链将为喜欢可用性而不是一致性的非分片系统提供最佳性能。

提供一个全局可用的时钟,这使得Solana团队能善加利用40多年来的分布式系统研究。乐观并发控制(又名“乐观锁”,Optimistic Concurrency Control,简称“OCC”)等概念是1981年发明的,多年来一直应用于大型计算项目中,但在时间和状态必须同时进行时则无法应用。与GPU的并行处理从1995年开始就已经存在,不过在2007年英伟达(Nvidia)发布CUDA开发环境之前主要局限于图形卡,无法被基于区块链的系统充分利用,这类系统悲观地锁定除当前正在处理事务的账户以外的一切状态。

理解时间的推移对于分布式系统在许可和无许可设置下的性能都是至关重要的。时间就是一切,使用一种以历史证明的形式编码时间推移的新方法,无许可系统可以与经过验证的中心化云计算供应商的性能相匹配。

感谢Anatoly YakovenkoZaki Manian对本文的反馈。



Traduction de l’article de Ryan Gentry : Article Original

BlockBlog

Le Meilleur de l'Actualité Blockchain Francophone & Internationale | News, Guides, Avis & Tutoriels pour s'informer et démarrer facilement avec Bitcoin, les Crypto-Monnaies et le Blockchain. En Savoir Plus sur L'Équipe BlockBlog

Commenter cet Article

Commenter cet Article

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Plus dans News

Les Plus Populaires

Acheter des Bitcoin

Acheter des Alt-Coins

Sécuriser vos Cryptos

Vêtements et Produits Dérivés

Top
risus. Aenean Curabitur commodo vulputate, Aliquam velit, mattis tristique