Salman49

J’ai cessé de partager mon Bitcoin

L’emprunt était facile à comprendre.

Je n’y ai pas passé beaucoup de temps.

Une phrase provenant d’une autre section continuait à m’attirer en arrière. Elle n’expliquait pas ce que je pouvais faire avec le Bitcoin. Elle expliquait comment Babylon refuse de le traiter avant que tout le reste ne se produise.

Les mots semblaient ordinaires.

« Vos bitcoins ne se mélangent avec ceux de personne d’autre. »

Je l’ai lu, j’ai tourné la page, puis je suis revenu. Si séparer le Bitcoin de chaque utilisateur crée plus de travail, il doit y avoir une raison. Personne ne rend un système plus difficile sans y gagner quelque chose en retour.

La documentation ne répond pas à cette question en un seul paragraphe. Elle y répond à travers l’architecture. Chaque utilisateur dispose d’un coffre-fort Taproot distinct. Aucun solde partagé en attente en arrière-plan.

Puis l’ampleur a commencé à changer la façon dont je percevais cette décision.

56 853 BTC se trouvent déjà dans cette architecture de coffre-fort. C’est un système en temps réel, pas une simple idée. À peu près à la même période, a16z a engagé 15 millions de dollars pour aider à construire des coffres-forts Bitcoin sans confiance (Trustless). Ces chiffres ne me disent pas que la conception est correcte.

Ils me disent que la conception mérite un second regard.

C’est là que je suis retourné au début.

Si ce n’était question que d’emprunt, un seul grand coffre-fort aurait été l’histoire la plus simple à raconter. Babylon n’a pas suivi cette voie. Elle a choisi de conserver le Bitcoin de chaque utilisateur séparé avant de parler de prêts, de liquidité ou de quoi que ce soit d’autre.

J’ai arrêté de lire cela comme une simple fonctionnalité de coffre-fort.

Tout ce qui a suivi a commencé à ressembler à une conséquence de cette seule décision.@BabylonLabs_io #baby $BABY

Babylon ne construit pas un protocole de staking. Il construit un marché pour la sécurité du Bitcoin.

La plupart des gens décrivent Babylon comme un protocole de staking Bitcoin, mais après avoir analysé l’architecture, je ne pense pas que le staking soit l’histoire principale.

Le staking est le mécanisme, mais pas l’objectif final.

L’idée plus vaste consiste à transformer le Bitcoin en sécurité économique que des réseaux externes peuvent utiliser sans que le BTC quitte jamais le Bitcoin lui-même.

Au lieu de demander aux utilisateurs de faire un pont ou d’envelopper le BTC, Babylon conserve le Bitcoin sur sa chaîne native tout en permettant aux BSN d’en hériter sa sécurité économique. Les détenteurs de BTC fournissent la sécurité, les Finality Providers la coordonnent, et les BSN la consomment.

À ce stade, le système ressemble davantage à un marché d’allocation de sécurité qu’à un protocole de staking traditionnel.

Le plus intéressant, c’est que la conception de Babylon va au-delà de la simple génération de rendement en BTC. À mesure que davantage de BSN s’intègrent, la même mise Bitcoin peut éventuellement sécuriser plusieurs réseaux via le multi-staking, créant ainsi des flux de récompenses supplémentaires sans déplacer le BTC hors chaîne.

Si ce modèle se généralise, le Bitcoin cesse de se comporter comme un collatéral dormant et commence à agir comme une sécurité partagée réutilisable.

C’est ce que la plupart des gens manquent.

Qualifier Babylon de « place de marché de la sécurité » reste une interprétation plutôt qu’un langage officiel du protocole. Mais l’architecture soutient de plus en plus ce cadrage : des prestataires de sécurité, des opérateurs et des consommateurs distincts coordonnés via Babylon Genesis.

Toute la thèse dépend de la question de savoir si les BSN exigent réellement une sécurité adossée au Bitcoin à grande échelle. Sans adoption significative, l’architecture reste davantage théorique qu’économique.

Mais si l’adoption arrive, Babylon sera peut-être finalement davantage retenu comme le système qui a transformé le Bitcoin en infrastructure de sécurité partagée pour l’économie crypto au sens large, plutôt que comme un simple protocole de staking.

Source : La thèse de Babylon Source : Staking Bitcoin Source : Qu’est-ce que le staking Bitcoin Source : Babylon : Une approche révolutionnaire pour le scaling du Bitcoin

#baby $BABY @BabylonLabs_io

Un détroit. Quatre marchés. Pourquoi chaque investisseur crypto devrait surveiller Hormuz.

La plupart des investisseurs en crypto ne suivent pas les routes maritimes. Je ne le fais généralement pas non plus. Mais le détroit d’Hormuz fait partie de ces endroits où des événements extérieurs au secteur crypto peuvent rapidement atteindre votre portefeuille.

Des données récentes montrent que le trafic des navires dans le détroit d’Hormuz a chuté d’environ 52 %, tandis que le Brent grimpait au-dessus de 85 $ le baril, à mesure que les craintes de perturbations de l’approvisionnement augmentaient. Dans le même temps, des informations faisant état d’une hausse de la volatilité des marchés ont déclenché de fortes liquidations sur l’ensemble des marchés crypto, rappelant aux traders à quelle vitesse les événements mondiaux peuvent changer le sentiment de risque.

Leçon à retenir : ce n’est pas que chaque événement géopolitique fera s’effondrer la crypto. C’est que les marchés sont liés. Des prix du pétrole plus élevés peuvent renforcer les craintes d’inflation, une incertitude plus forte pousse souvent les investisseurs à s’éloigner des actifs à risque, et les positions à effet de levier deviennent bien plus faciles à dénouer en cas de volatilité soudaine.

Pour moi, la principale idée n’est pas de prédire le prochain titre. C’est de comprendre la réaction en chaîne. Une perturbation sur l’une des routes énergétiques les plus fréquentées au monde peut influencer le pétrole, les actions, les devises et, finalement, la crypto. Au moment où Bitcoin réagit, l’histoire a généralement commencé ailleurs.

Si vous tradez la crypto, surveiller uniquement la crypto n’est plus suffisant. Parfois, le premier signal apparaît à des centaines de kilomètres de toute blockchain. NFA.DYOR.

Le plus grand risque financier pourrait être les règles que personne ne vérifie

Je n'essayais pas de changer quoi que ce soit sur mon téléphone. Je voulais juste empêcher une application de demander ma localisation. Quelques clics plus tard, je me suis rendu compte que plusieurs applications utilisaient la même autorisation depuis des mois. J'avais totalement oublié de l'avoir donnée au départ. Un ancien réglage influençait tranquillement tout ce qui s'est passé ensuite.

Fait amusant, la même idée m'a suivi jusque dans la documentation de Newton.

data.params semble ordinaire au premier abord. C'est là que résident les limites, les seuils, les listes d'autorisation (allowlists) et d'autres valeurs de configuration. Plus j'explorais l'architecture, moins cela ressemblait à de la configuration, et plus cela ressemblait à la mémoire du système. Chaque transaction est évaluée en fonction de choix qui ont peut-être été faits bien avant même que cette transaction n'existe.

C'est probablement pour ça que les organisations passent autant de temps à examiner les transactions, tout en remettant rarement en question les règles qui les régissent. Une transaction dure quelques secondes. Un seuil peut façonner des milliers de transactions avant que quiconque ne pense à le modifier.

Newton sépare la logique de politique (Policy) de la configuration, afin que les organisations puissent mettre à jour data.params sans réécrire la Policy elle-même. La documentation présente aussi --expire-after, qui permet de faire expirer des paramètres après un nombre défini de blocs. Je ne le vois pas comme une simple fonctionnalité pratique. Je le comprends comme la reconnaissance que les hypothèses d'hier finissent par devenir le risque d'aujourd'hui.

Plus j'y pense, plus cela ressemble à un problème de système plutôt qu'à un problème financier. Les systèmes fiables ne naissent pas en prenant une décision parfaite une fois. Ils se construisent en revisitant les règles invisibles qui continuent de guider les décisions bien après que tout le monde a oublié qu'elles existent.
NFA.DYOR. #newt $NEWT @NewtonProtocol

Nous construisons des systèmes financiers plus rapides. Peut-être avons-nous oublié de construire des pare-feu.

Il y a quelques jours, je faisais un paiement en ligne. Le montant était faible, mais le paiement a tout de même été mis en pause pour une étape de vérification supplémentaire. À ce moment-là, cela m’a semblé inutile. L’application connaissait déjà mon compte, mon solde et le destinataire. Alors pourquoi me l’arrêter ?

Cette question m’est revenue pendant que je lisais la documentation de Newton. J’ai atteint la partie où un Intent est évalué avant d’être exécuté. Le réseau Operator vérifie une Policy, produit une attestation BLS, puis le PolicyClient vérifie cette preuve avant que la transaction puisse continuer. La première fois que je l’ai lu, j’y ai simplement vu un autre système d’autorisation.

Puis je suis arrivé à VaultKit et aux Shield Contracts, et un détail m’a fait m’arrêter pour réfléchir. Une action protégée n’est pas transmise si les opérateurs la refusent, si le quorum requis de 67 % n’est pas atteint, si l’attestation expire, ou si la validation par Shield échoue. C’est à ce moment-là que ma première impression a changé.

Je me suis mis à me demander si nous envisagions la sécurité financière dans la mauvaise direction. La plupart des systèmes financiers se concentrent sur la détection des transactions suspectes après qu’elles se sont produites. Newton semble consacrer son effort à déterminer si une transaction mérite même d’avoir lieu. Pour moi, c’est beaucoup plus proche de la façon dont fonctionne un pare-feu que de ce que fait généralement la sécurité financière traditionnelle.

C’est peut-être pour cela que l’étape de vérification supplémentaire pendant mon paiement a soudainement pris davantage de sens. Il ne s’agissait pas de remettre en question ma capacité à envoyer de l’argent. Il s’agissait de vérifier si cette action particulière avait obtenu l’autorisation d’aller plus loin. Je commence à penser que la prochaine mise à niveau en finance ne sera pas des transactions plus rapides. Elle sera de meilleures décisions avant que les transactions n’aient lieu.

Source : Documentation du protocole Newton. Les termes techniques tels que Intent, Policy, Operator Network, BLS Attestation, PolicyClient, VaultKit, Shield Contracts, ainsi que le quorum par défaut de 67 % reposent sur la documentation. La comparaison avec un « pare-feu financier » est mon analyse personnelle. #newt $NEWT @NewtonProtocol #Web3 #AI

La plus grande amélioration de l’IA pourrait être d’apprendre quand dire « Je ne sais pas. »

La plupart des utilisateurs d’IA ont déjà vu ce scénario. Vous posez une question, la réponse sonne avec assurance, puis vous réalisez seulement plus tard que certaines parties sont fausses. Cela me fait penser que la plus grande amélioration de l’IA ne consiste pas à répondre à davantage de questions. Il s’agirait peut-être de savoir quand ne pas répondre.

Cette idée m’est revenue en lisant la documentation sur le consensus de Newton. Un détail a attiré mon attention. Si les opérateurs ne sont pas d’accord sur les données, Newton ne ignore pas discrètement la divergence pour passer à autre chose. D’après la documentation, des valeurs en dehors de la tolérance par défaut de 10 % renvoient ToleranceExceeded, et les opérateurs ne sont pas exclus silencieusement. Le protocole s’arrête simplement.

On retrouve le même schéma dans d’autres parties du système. Si aucun opérateur ne répond, le résultat est NoResponses. Si le réseau ne parvient pas à atteindre le quorum par défaut de 67 % pondéré par les mises, le résultat est InsufficientQuorum. D’après la documentation, il ne s’agit pas de pannes cachées. Ce sont des signaux explicites indiquant que le réseau n’a pas pu parvenir à une décision fiable.

L’analogie avec le distributeur de billets m’a fait comprendre le design. Si votre banque ne peut pas confirmer la transaction, vous préféreriez voir « Transaction échouée » plutôt que l’automate devine votre solde et vous distribue de l’argent. Newton semble appliquer la même idée. Parfois, refuser de continuer est plus sûr que de faire comme si tout allait bien.

Je ne pense pas que ce soit une idée propre à la blockchain uniquement. C’est une idée de confiance. Les systèmes deviennent plus fiables lorsqu’ils admettent l’incertitude au lieu de la dissimuler derrière des réponses trop assurées. À mon avis, « Je ne sais pas » peut être bien plus précieux qu’une réponse qui n’a jamais été fiable.

Source : Documentation du protocole Newton (Consensus & Security). #newt $NEWT @NewtonProtocol

Le meilleur moment pour trouver un bug n’est pas en production

La plupart des développeurs ne s’inquiètent pas d’écrire du code. Ils s’inquiètent de découvrir trop tard que le code se comporte différemment que prévu. Lire la documentation de tests de Newton a changé ma façon de voir ce problème. Nous prévisualisons des photos avant de les publier et vérifions l’itinéraire avant un long trajet. Déployer une politique sans la tester commence à ressembler à un oubli de faire les deux étapes.

La documentation de Newton suit un principe simple : tester d’abord, déployer ensuite. Les développeurs peuvent valider des composants individuels ou simuler l’ensemble du flux de travail avant même que quoi que ce soit n’atteigne la blockchain. L’étape finale, simulatePolicy(), collecte les données de l’oracle, évalue la politique Rego et indique si le résultat serait une autorisation (allow) ou un refus (deny) avant le déploiement.

C’est à ce moment-là que la documentation a cessé de ressembler à un guide de débogage pour moi. Elle a commencé à répondre à une question que les développeurs posent souvent seulement après qu’un problème se soit produit : « Qu’est-ce que cette politique fera réellement ? » Au lieu de découvrir la réponse à travers une transaction échouée, la simulation révèle la décision tant que les changements sont encore sûrs et peu coûteux.

Newton sépare aussi les tests en différentes étapes. simulatePolicyData() vérifie si l’oracle renvoie les données attendues. simulatePolicy() valide le flux complet d’autorisation. simulateTask() aide à rejouer des tâches existantes pendant le débogage. Chaque outil se concentre sur un problème plutôt que d’essayer de tout résoudre.

Une limite mérite d’être retenue. simulateTask() s’exécute localement, donc il ne teste pas l’ensemble du pipeline de l’Operator. Les développeurs doivent encore utiliser simulatePolicy() pour valider le flux d’exécution complet avant le déploiement.

Ma conclusion est que les systèmes fiables ne se construisent pas en évitant les erreurs. Ils se construisent en repérant la plupart des erreurs avant même que les utilisateurs ne les voient.

Source : Documentation du protocole Newton (Testing & Debugging, Testing Policies & Oracles, SDK Reference). Analyse personnelle uniquement lorsque c’est explicitement indiqué. NFA.DYOR. #Newt $NEWT @NewtonProtocol