Découvrir le fonctionnement de Libra

Libra est un sujet très populaire ces derniers temps, non seulement dans la communauté crypto mais également dans les médias du monde entier. Ce projet est porté par Facebook en collaboration avec plus d'une vingtaine d'entreprises partenaires. Parmi ces dernières on retrouve des acteurs majeurs de leurs domaines comme Paypal, Mastercard ou Visa ou encore Booking, Uber et Lyft. Le whitepaper de Libra, la documentation et un site vitrine de Calibra ont été mis en ligne le 18 juin dernier. De nombreux articles sont disponibles à ce sujet ainsi que certaines comparaisons entre le projet et Bitcoin ou Ethereum (voire Ethereum 2.0).

Mais comme je l'ai dit cela reste un projet, et tout les fonctionnalités présentées par Libra ne sont actuellement pas disponibles. Mais les documentations sont elles disponibles et aujourd'hui je vous propose de nous plonger dans ces dernières. Nous verrons quel est le fonctionnement de Libra, mais surtout les caractéristiques du nouveau langage de programmation, Move. Enfin nous ferons nos premiers tests de transactions en libras.

Libra repose sur un réseau de participants, qui vont valider les différentes transactions effectués. Ces participants sont les nœuds validateurs, et seront au nombre de cent. Pour le moment on ne connait pas la liste des cent validateurs du réseau, mais ils appartiendraient aux entreprises du consortium. Ces nœuds permettent également la création d'un fonds monétaire qui sera utilisé pour garantir la stabilité de la valeur de la Libra, l'adossant à plusieurs monnaies (dollar, euro, yen, livre sterling...).

Le fonctionnement de Libra

La libra n'est pas comme la plupart des cryptomonnaies. Tout d'abord, elle n'utilise pas une blockchain pour regrouper les transactions dans des blocs : ces dernières sont validées une par une par les acteurs du réseau. Un peu comme Ethereum, Libra repose sur un état comptable (qui possède quoi) qui est mis à jour par chaque transaction (« version ») validée. Chaque transaction contient la racine de l'état pour permettre aux acteurs de se synchroniser rapidement au réseau.

Ensuite, puisqu'il n'y a pas de de chaîne de blocs, Libra n'utilise pas non plus la proof-of-work ou la proof-of-stake de Nakamoto (la plus longue chaîne l'emporte), mais un nouvel algorithme de consensus : LibraBFT. C’est un algorithme qui se base sur l’honnêteté des acteurs du réseau, par la preuve d’enjeu. En effet, qui voudrait saboter un projet qui a un ticket d’entrée de plus de 10 millions ? L’objectif du consensus est qu’au moins deux des tiers des participants doivent être honnêtes pour que cela fonctionne. Il faut donc un nombre limité de participants et une sélection de ces derniers.

Cette architecture permet donc à Libra de garantir un nombre élevé de transactions à la seconde, mais en limite la décentralisation. Malgré les commentaires des équipes souhaitant ouvrir à terme le réseau à un plus grand nombre d’acteurs, elles ont fait dans un premier temps le choix de la vitesse et de la rapidité d’exécution, en attendant de nouveaux moyens techniques pour permettre une plus grande ouverture du réseau Libra.

Le langage Move

Les transactions du réseau Libra sont exécutées par un langage de programmation développé spécialement pour Libra, Move. C'est donc en Move que les scripts liés aux transactions, mais également aux comptes. En effet c'est pas le biais d'instructions Move que l'on pourra gérer les comptes, et notamment leur création.  Ce langage a été spécifiquement désigné pour l'architecture Libra, mais également pour la résolution de certaines problématiques qui existent sur des langages de smart-contracts existants, Solidity par exemple.

Alors que l'annonce de Libra a fait beaucoup de bruit, il y a eu peu d'échos sur la présentation de Move. Pourtant, certains développeurs accueillaient très bien cette nouvelle, discutant de ses avantages face à Solidity et Ethereum :

"I’m usually pretty skeptical of anything related to cryptocurrency, but here’s one piece of Libra that looks potentially interesting: a bytecode programming language called Move with semantics inspired by linear logic." James Clark

Ce qu'on peut traduire par :

« Je suis d'habitude sceptique par rapport à tout ce qui relève de la cryptomonnaie, mais il y a une partie de Libra qui a l'air potentiellement intéressante : un language de programmation bytecode appelé Move, avec sa sémantique inspirée par la logique linéaire. »

Move semble être sur le papier un excellent langage de plateforme de smart-contracts, mais quelles en sont ses qualités ?

Tout d'abord, le langage repose principalement sur des statiques. On retrouve dans ce type de typage les langages Rust, Typescrit ou encore Haskell. Cela permet de détecter plus d'erreurs de fonctionnement dès la compilation, et non durant le déploiement. Mais Move est également étudié pour la sécurité de ses smart-contracts, une des grandes faiblesses de Solidity. Et cela passe notamment par une plus faible flexibilité, moins de dynamisme dans les fonctions et dans l'exécution du code. Toutes les possibilités du scripts peuvent être analysées avant le déploiement, ce qui n'est pas possible ou très coûteux pour Ethereum. Mais Move innove également dans son système de modules, qui peuvent être librement utilisés dans d'autres applications.

"Move modules are similar to smart contracts in other blockchain languages. …, However, modules enforce strong data abstraction — a type is transparent inside its declaring module and opaque outside of it." (White Paper)

« Les modules de Move sont similaires à des smart contracts dans d'autres langages de la blockchain. ...., Cependant, les modules renforcent l'abstraction des données - un "type" est transparent au sein du module dans lequel il est déclaré et est totalement opaque en dehors de celui-ci. »

Les différences avec les langages de smart-contracts existants

Move veut de par sa conception et son implémentation corriger certaines erreurs que nous avons pu observer dans les autres langages de programmation de l'éco-système. Il existe en effet trois problèmes lors du développement de smart-contracts selon Libra.

La première est que la définition des valeurs (Bitcoin, Ethereum...) n'est pas franche, les transactions permettent de transférer un certains nombre de ces valeurs, mais ne définissent pas réellement à quoi correspond ces dernières. Un token Ethereum par exemple n'est qu'un smart-contract suivant un standard, et le stockage des informations se fait avec l'utilisation d'entiers. La seconde amélioration que Move souhaite apporter est de faciliter la création de valeur, de rareté. Aujourd'hui la façon de définir un produit ayant une valeur est d'utiliser les différents tokens qui existent par exemple. Cela rejoint en partie le premier point présenté, les langages actuels n'ont pas de fonctionnalités dédiées à ces problématiques. Le troisième point concerne l'accès aux fonctionnalités, Move souhaite faciliter la définition de conditions d'accès personnalisées en fonction de critères arbitraires.

En résumé le langage Move se définit entre la rigueur qu'offre Bitcoin Script et toutes les possibilités qui sont disponibles sur Ethereum par exemple. Moins de flexibilité que ce dernier, pour renforcer la sécurités et diminuer les erreurs qui peuvent être très dommageables.

Fonctionnement des modules

Les modules de Libra semblent faire écho à un fonctionnement que l'on peut retrouver dans les smart-contracts. Par exemple les libras que l'on peut s'échanger utilisent des modules pour réaliser ces transactions, mais également leur créations ainsi que leur destruction au besoin. Nous allons voir ce que sont ces modules et comment ils fonctionnent.

Un module contient du code Move qui permet d'allouer de nouvelles ressources, ou de nouvelles actions comme une transaction par exemple. Tout comme Ethereum, chaque module possède une adresse. Mais dans le cas de Libra, il s'agit de l'adresse du compte qui a déclaré ce module. Un compte peut déclarer de multiples modules, mais ils doivent tous avoir des noms différents. Pour identifier un module précis, on utilisera l'adresse du compte propriétaire suivi du nom du module. Par exemple 0x67 Cryptoast fera référence au module Cryptoast déclaré par le compte ayant pour adresse 0x67. Les modules de Libra sont immuables pour le moment, tout comme les smart-contracts d'Ethereum, le seul moyen est de mettre en place un hard fork pour les changer. Cependant, l'équipe de Libra travaille à la mise en place de modifications des modules déployée dans le futur.

Fonctionnement d'une transaction

Voyons comment une transaction Libra fonctionne concrètement et de quoi il retourne. Prenons comme exemple une transaction de 25 libras, entre Pierre et Marie. D'après la documentation, la transaction possédera ces différents paramètres :

• L'adresse du compte de Pierre.
• La « carte d'identité » de la transaction. Elle contiendra le code du script de la transaction, les actions à effectuer, mais également les paramètres de ce dernier. Soit ici l'adresse du compte de Marie, ainsi que le nombre de Libra à transférer (25 dans notre exemple).
• Le prix du gas. Le prix sélectionné par Pierre par unités de gas pour exécuter la transaction. Les frais de gas sont similaires à Ethereum, et permettre de payer les calculs et stockages des données de la transaction.
• Le maximum de frais que Pierre est prêt à payer pour réaliser la transaction.
• La durée de validité de la transaction.
• Un numéro de séquence. Ce numéro de séquence sera comparé lors de la validation avec celui du compte de Marie.

Les étapes d'une transaction Libra

Pierre va soumettre sa transaction au réseau Libra. Un contrôle va être effectué, notamment la vérification des signatures, que Pierre a suffisamment de Libras sur le compte et que la transaction n'est pas malhonnête. Une fois cela réalisé, et si tout est valide pour le système, la transaction va être envoyée à la mempool. Il s'agit de la file d'attente des transactions, qui attendent leur validation par le réseau. Il y a plusieurs cas possible : soit Pierre a déjà des transactions dans la liste, et elle sera ajoutée à ces dernières ; soit ce n'est pas le cas, et la transaction va être partagée avec les différents nœuds validateurs du réseau.

Par la suite le nœud leader va prendre un bloc de transactions Libra depuis sa liste et les proposera par le biais du consensus aux autres validateurs. Le consensus du réseau sera responsable de réguler les validations et l'ordre des transactions du bloc en cours. Une fois le bloc validé, il passe à l'étape de l'exécution. Les transactions sont effectuées sur la machine virtuelle Libra, puis sont ajoutées au nouvel état du réseau.

Voilà, après tout ce cheminement, Marie reçoit bien les 25 libras de la part de Pierre.

Installer le client Libra

Avant toute chose, nous avons besoin d'installer le client Libra sur notre ordinateur. Vous avez besoin d'un ordinateur possédant un système d'exploitation MacOS ou Linux, ayant Git d'installé et le gestionnaire de paquet APT. Une fois que tout les prérequis sont validés, ils vous suffit de vous rendre dans le dossier de votre choix et de cloner le répertoire du client Libra :

git clone https://github.com/libra/libra.git

Une fois ceci fait, il nous faut lancer le script fourni par Libra pour l'installation des différents outils nécessaires à l'utilisation du client :

cd libra
./scripts/dev_setup.sh

Et voilà ! Vous avez installé tout ce qui faut pour lancer le client Libra et se connecter à un des nœuds disponible sur le réseau de test. Lançons maintenant le client afin d'en découvrir les possibilités. Utilisez le script suivant :

./scripts/cli/start_cli_testnet.sh

C'est assez long tout installer et de mettre en place pour la première fois, mais ce sera beaucoup plus rapide les prochaines fois. Si tout s'est bien passé vous avez donc une console de commande disponible. Nous allons voir ce que l'on peut en faire dans le prochain chapitre.

Créer des comptes

Avant de pouvoir effectuer des transactions avec les libras de tests, il nous faut des comptes qui s'échangeront ces derniers. Je vous propose donc de créer avec moi deux comptes qui pourront obtenir et se transférer des libras. C'est très simple vous allez voir. Une fois rendu dans l'invite de commande de test du réseau Libra et rentrez cette commande :

account create

Cette commande permet de créer un compte, qui aura un identifiant (ID) et une adresse. L'ID sera tout simplement le nombre de comptes existants avant sa création, et l'adresse une suite hexadécimale. Attention l'ID n'est pas partagé sur la blockchain, et est simplement une façon plus pratique de faire référence au compte, en local sur l'invite de commande.

Nous allons créer un second compte donc répétez l'opération à ce propos. Vous obtiendrez la création d'un second compte, et vous pourrez utiliser la commande suivante pour en récupérer la liste :

account list

Vous devriez voir deux comptes, voici par exemple les miens :

User account index: 0, address: 49edb3b2b1eb800a849215f9d9ec0b71178710d8daa5ad4f59ed63b8e4181794, sequence number: 0, status: Local
User account index: 1, address: 06e9a223520d0e56c5e136031a41b0b9227f40fd2fd147f35ada888e12ea4571, sequence number: 0, status: Local

Récupérer des libras de tests

Nous avons maintenant nos deux comptes pour réaliser la fameuse transaction, mais il nous faut encore les libras à s'échanger.  Le réseau de test que propose Libra nous permet de « frapper » de la monnaie, de test bien entendu. C'est un peu comme les faucets des réseau de test Ethereum, cela permet de réaliser des expériences et de payer des frais de transactions durant le prototypage de smart-contracts. Ici ce sera tout simplement pour voir comment tout cela fonctionne. La commande pour récupérer vos pas si précieux libras est assez simple :

account mint n°_de_compte nombre_de_libras

Pour mon exemple je souhaite obtenir 15 libras sur le compte n° 0, pour ensuite les transférer sur le compte n°1, la commande sera la suivante :

account mint 0 15

Et voici la réponse sur client :

>
Minting coins
Mint request submitted

Nous pouvons vérifier que tout c'est bien passé en utilisant la commande suivante, qui devrait nous afficher le nombre de libras que possède notre compte n°1 :

query balance 0

Ce qui nous renvoie bien que le compte possède 15 libras :

Balance is : 15.000000

Parfait ! Nous avons donc nos libras, et pouvons donc passer à l'étape suivante qui est de réaliser la transaction.

Effectuer une transaction

Si vous avez été attentif lors de l'explication du fonctionnement d'une transaction Libra, vous vous souvenez probablement du fameux numéro de séquence que contient cette dernière mais que chaque compte possède son propre numéro. Nous verrons comment ce fameux numéro est modifié en fonction du nombre de transactions effectué par le compte en question. Voici la commande pour récupérer le numéro de séquence d'un compte en particulier :

query sequence n°_de_compte

Si vous n'avez (comme moi) jamais réalisé de transaction avec ce compte, le console doit vous afficher un numéro de séquence valant 0. Nous allons procéder à un transfert de libras entre nos deux comptes, puis vérifier que cela s'est bien déroulé et ensuite observer la modification du numéro de séquence de notre compte. Voici la commande pour transférer entre deux compte des libras :

transfer n°_compte_créditeur n°_compte_crédité nombre_de_libras

Soit dans notre exemple :

transfert 0 1 15

Voici la réponse de la console :

Transaction submitted to validator
To query for transaction status, run: query txn_acc_seq 0 0 <fetch_events=true|false>

Lançons donc cette commande pour obtenir plus d'informations sur cette transaction, query txn_acc_seq 0 0 true qui nous affiche ces détails :

Committed transaction: SignedTransaction {
raw_txn: RawTransaction {
sender: 49edb3b2b1eb800a849215f9d9ec0b71178710d8daa5ad4f59ed63b8e4181794,
sequence_number: 0,
payload: {,
transaction: peer_to_peer_transaction,
args: [
{ADDRESS: 06e9a223520d0e56c5e136031a41b0b9227f40fd2fd147f35ada888e12ea4571},
{U64: 15000000},
]
},
max_gas_amount: 10000,
gas_unit_price: 0,
expiration_time: 1562680771s,
},
public_key: a5f967f02ffbf617d1e7c23ccee31bb547f0551034032757957531e29adf4d31,
signature: Signature( R: CompressedEdwardsY: [218, 228, 86, 88, 105, 131, 34, 135, 179, 191, 38, 212, 114, 48, 206, 122, 170, 115, 133, 65, 168, 130, 119, 187, 231, 155, 255, 150, 152, 58, 44, 90], s: Scalar{
bytes: [26, 216, 251, 207, 32, 11, 233, 220, 49, 117, 209, 56, 14, 119, 123, 16, 212, 65, 42, 140, 42, 241, 117, 4, 42, 246, 91, 174, 67, 165, 115, 4],
} ),
}
Events:
ContractEvent { access_path: AccessPath { address: 49edb3b2b1eb800a849215f9d9ec0b71178710d8daa5ad4f59ed63b8e4181794, type: Resource, hash: "217da6c6b3e19f1825cfb2676daecce3bf3de03cf26647c78df00b371b25cc97", suffix: "/sent_events_count/" } , index: 0, event_data: AccountEvent { account: 06e9a223520d0e56c5e136031a41b0b9227f40fd2fd147f35ada888e12ea4571, amount: 15000000 } }
ContractEvent { access_path: AccessPath { address: 06e9a223520d0e56c5e136031a41b0b9227f40fd2fd147f35ada888e12ea4571, type: Resource, hash: "217da6c6b3e19f1825cfb2676daecce3bf3de03cf26647c78df00b371b25cc97", suffix: "/received_events_count/" } , index: 0, event_data: AccountEvent { account: 49edb3b2b1eb800a849215f9d9ec0b71178710d8daa5ad4f59ed63b8e4181794, amount: 15000000 } }

Beaucoup de choses à dire sur cette affichage, nous retrouvons tous les paramètres des transactions que le whitepaper nous avait présenté. Mais également plus d'informations, que nous apporte l'étude de l'événement de la transaction.  Nous pouvons observer l'adresse de cette dernière, ainsi que son hash et d'autres informations.

Mais nous pouvons également récupérer d'autres informations, comme l'ensemble des transactions signé par le compte ou les événements. Mais nous allons voir ensemble comment obtenir l'état actuel d'un compte. Il suffit d'utiliser la commande suivante tout en indiquant le compte en questions.

query account_state 0

>> Getting latest account state
Latest account state is:
Account: 3ed8e5fafae4147b2a105a0be2f81972883441cfaaadf93fc0868e7a0253c4a8

 State: Some(
AccountStateBlob {
Raw: 0x010000002100000001217da6c6b3e19f1825cfb2676daecce3bf3de03cf26647c78df00b371b25cc9744000000200000003ed8e5fafae4147b2a105a0be2f81972883441cfaaadf93fc0868e7a0253c4a800e1f50500000000000000000000000001000000000000000100000000000000
Decoded: Ok(
AccountResource {
balance: 100000000,
sequence_number: 1,
authentication_key: 0x3ed8e5fafae4147b2a105a0be2f81972883441cfaaadf93fc0868e7a0253c4a8,
sent_events_count: 1,
received_events_count: 0,
},
)
},
)
Blockchain Version: 3

Nous avons donc de nombreuses informations :

• L'adresse du compte.
• Le nombre de libras que possède le compte.
• Le numéro de séquence actuel du compte.
• Le nombre d'events reçus mais également envoyés.

Voilà, nous avons pu voir en pratique ce que nous présentait la documentation de Libra en réalisant notre propre transaction. Mais également comment récupérer des informations d'un compte qui nous appartenait. C'est la seul façon pour le moment d'obtenir un accès à l'historique des transactions dans une certaine mesure.

Aller plus loin

Vous savez désormais comment installer le client de test de Libra et réaliser les premières manipulations de bases. Nous avons notamment vu comment créer des comptes, récupérer des libras de test et réaliser une transaction entre les comptes. Mais ce ne sont pas les seules fonctionnalités actuellement disponibles. Vous pouvez approfondir l'étude du fonctionnement de Libra et de ce client de test en manipulant notamment les événements. Mais aussi avec les commandes de récupération des informations de ces éléments.

Vous avez aussi la possibilité de vous lancer dans la mise en place de votre propre nœud de validation. Il ne fera évidement pas partie du réseau et restera local. Mais cela vous permet tout de même de faire vos propres tests pour mieux comprendre le fonctionnement de Libra et les différentes interactions possibles.

? Quels impacts pourrait avoir Libra sur Bitcoin ?

Participer au développement de Libra

Puisque Libra est open-source, vous pouvez également contribuer à son amélioration, en devenant contributeur du projet. Si vous avez des idées de fonctionnalités et les compétences pour les mettre en place, il vous faut tout d'abord récupérer le code actuel de Libra. Ensuite, en prenant soin de suivre les consignes de développement et d'inclure documentation et tests à votre code vous pouvez faire une demande d'ajout de votre travail au projet.

C'était ma présentation du fonctionnement de Libra. Elle est principalement axée technique afin de vous expliquer rapidement les fonctionnements-clés de cette cryptomonnaie atypique. Libra remet en question de certains code de la communauté des crypto-enthousiastes mais également de l'économie traditionnelle. Il est important à mes yeux de se renseigner dessus mais de ne pas se contenter des annonces et étudier le fonctionnement interne du projet. J'espère que vous aurez apprécié ces informations et ce guide pour se lancer facilement des tests du réseau.

Passionné par les crypto-monnaies, j’ai rapidement appris à développer des outils dans le domaine des technologies blockchain. J’aime partager mes connaissances sur le sujet et je participe activement au rayonnement des aspects techniques de la blockchain au sein de la communauté crypto. Je suis principalement intéressé par Ethereum et par son code Solidity.

Guillaume Chanut

64 articles

Tous ses articles