ZeroBlock

Une chose m’a fait arrêter de défiler. Ce n’était pas le bogue lui-même. C’était la ligne indiquant que la fenêtre de course n’existe qu’entre une lecture de base de données et une écriture de base de données. Cela ressemblait à un tout petit détail d’implémentation jusqu’à ce que je commence à réfléchir à ce que cela dit sur le modèle d’exécution de Babylon.

J’ai cessé de chercher un attaquant et j’ai commencé à regarder le flux. Je suis revenu comparer le chemin de validation et j’ai passé un moment à tracer où les changements d’état deviennent réellement définitifs. Puis j’ai pris un café et j’ai relu la séquence encore une fois. Plus j’y regardais, moins cela me semblait être uniquement un problème de sécurité. Cela ressemblait davantage à un choix de conception concernant le niveau de risque temporel que le protocole est prêt à tolérer.

Ce qui a fini par devenir évident, c’est que la protection n’est pas conçue pour rendre la course impossible. Elle est conçue pour rendre l’occasion extrêmement faible. Ce sont deux idées différentes. La première supprime la condition. La seconde réduit la probabilité. Cette différence est facile à manquer car, de l’extérieur, les deux peuvent sembler sécurisées.

C’est la partie que personne ne met dans la présentation. Babylon dépend du fait que les validateurs et les services traitent l’état dans un ordre prévisible tout en acceptant qu’un minuscule intervalle d’exécution subsiste. Le protocole dit, en pratique, que le coût opérationnel lié à l’élimination de chaque course possible est supérieur au risque restant de laisser une fenêtre aussi étroite.

Peut-être que c’est le bon compromis pour la performance. Peut-être que l’exposition restante est tellement faible que rajouter davantage de synchronisation créerait ailleurs des problèmes plus importants.

Ce que je n’arrive toujours pas à décider, c’est où Babylon trace la frontière entre une hypothèse temporelle acceptable et une garantie de protocole qui ne devrait jamais dépendre du timing.
@BabylonLabs_io
#baby $BABY

Je pensais que la partie intéressante serait l’architecture de staking. En réalité, il ne s’agissait que d’une phrase unique au sujet de l’arbitrage et de l’exécution par les tribunaux, qui a fini par détourner mon attention de la conception technique.
Au début, cela ressemblait à un langage juridique courant. Puis je l’ai lu en parallèle avec les avertissements répétés limitant la responsabilité des Parties de Babylon, et je suis revenu à la documentation du protocole décrivant des coffres-forts sans confiance, la coordination des validateurs et les flux de rachat. Les trois éléments ont commencé à décrire le même système sous des angles différents.
Le protocole cherche à minimiser le besoin de confiance dans le logiciel, mais les documents consacrent un effort surprenant à définir ce qui se passe lorsque la confiance se brise en dehors du logiciel.
Cela a changé la façon dont j’ai envisagé l’architecture.
Un ensemble de validateurs peut parvenir à un consensus. Un coffre-fort peut vérifier des conditions avant de libérer des actifs. Les contrats intelligents peuvent appliquer des règles prédéfinies. Aucun de ces mécanismes ne peut résoudre tous les désaccords dès que des personnes, des juridictions ou des obligations hors chaîne entrent en jeu. C’est là que les clauses d’arbitrage et l’exécution par les tribunaux apparaissent discrètement.
Cela m’a fait penser que la décentralisation ne remplace pas l’infrastructure juridique aussi souvent que les gens le supposent. Elle réduit plutôt les situations dans lesquelles l’infrastructure juridique doit intervenir.
La conception technique réduit la friction opérationnelle pour l’activité normale du protocole. Le cadre juridique existe pour le faible pourcentage de situations où le code seul ne peut pas produire un résultat final.
Après avoir lu les deux ensemble, le protocole m’a semblé moins être un logiciel cherchant à éliminer les institutions, et davantage un logiciel qui définit soigneusement le point exact où l’application institutionnelle commence.
@BabylonLabs_io
#baby $BABY

Je pensais que la partie la plus intéressante serait l’architecture de mise en jeu de Babylon. En fait, il s’est avéré qu’il ne s’agissait que d’un paragraphe dans les documents juridiques, qui n’a cessé de me ramener en arrière.
La clause indiquant qu’aucune partie de Babylon, y compris ses membres, représentants ou agents, ne sera responsable semblait d’abord être une protection juridique ordinaire. Après l’avoir lue en parallèle avec la conception du protocole et les responsabilités des validateurs, j’ai commencé à la ressentir comme davantage liée à l’architecture que je ne l’aurais cru.
Le protocole pousse constamment des décisions importantes vers des règles cryptographiques, le comportement des validateurs et des conditions prédéfinies, au lieu de compter sur un opérateur central pour résoudre les problèmes plus tard. Ce langage juridique reflète la même direction. Si la responsabilité ne peut pas être concentrée dans une seule organisation, alors la fiabilité doit venir de la coordination entre de nombreux participants indépendants.
Cela change ma façon de considérer le risque opérationnel. Il ne s’agit plus seulement de savoir si le logiciel fonctionne. Il s’agit de savoir si les incitations restent alignées quand personne n’est censé intervenir pour corriger des erreurs après coup. Les validateurs sécurisent le réseau, la gouvernance ajuste les paramètres au fil du temps et Bitcoin fournit la base de règlement, mais aucune de ces couches ne promet une responsabilité individuelle si quelque chose tourne mal.
J’ai aussi remarqué que cela crée une charge différente pour les développeurs et les intégrateurs. Ils ne peuvent pas traiter le protocole comme un service traditionnel, adossé à une organisation qui garantit chaque résultat. Ils doivent comprendre les hypothèses de confiance avant de déployer du capital ou de construire des applications.
Plus je comparais la formulation juridique avec l’architecture technique, plus il me semblait qu’il s’agissait de deux documents différents décrivant le même système sous des angles distincts.
@BabylonLabs_io
#baby $BABY

Je pensais que la partie intéressante serait la preuve de remboursement du prêt. Il s’avère que tout ce qui doit se produire avant que cette preuve soit même utile est plus important.
Au début, « Bob prouve qu’il a remboursé le prêt et la condition de prix est remplie » semblait être la fin d’une transaction. Après l’avoir relu plusieurs fois, cela a commencé à ressembler davantage au début d’un problème de coordination.
Une preuve de remboursement a très peu de valeur à elle seule. Quelqu’un doit accepter que la preuve est valide. Quelqu’un doit accepter que la source de prix est fiable. Quelqu’un doit savoir exactement quelles conditions ont été définies avant que le prêt n’existe. Ce sont des systèmes distincts qui doivent rester alignés même quand personne n’observe.
Cela m’a amené à réfléchir autrement à l’architecture de Babylon. Le protocole ne s’intéresse pas seulement à savoir si une affirmation est vraie. Il doit aussi préserver la confiance que chaque participant vérifie la même affirmation avec les mêmes hypothèses. Si un validateur interprète une condition différemment d’un autre, la preuve elle-même cesse d’être la partie la plus difficile.
L’infrastructure intéressante n’est pas la cryptographie. C’est la couche de coordination autour de la cryptographie.
J’ai aussi remarqué à quel point le travail opérationnel disparaît une fois que les preuves remplacent des vérifications répétées. Les prêteurs n’ont pas besoin de reconstruire manuellement chaque événement. Les validateurs n’ont pas besoin de faire confiance à des contreparties individuelles. Ils ont seulement besoin d’être sûrs que le processus de vérification reste cohérent dans le temps.
La preuve clôture le prêt, mais le protocole protège en réalité quelque chose de moins évident. Il protège un accord partagé sur la réalité avant que la valeur ne bouge.
@BabylonLabs_io
#baby $BABY