> ## Documentation Index
> Fetch the complete documentation index at: https://docs.intention.xyz/llms.txt
> Use this file to discover all available pages before exploring further.
# Synchronisation d’état
> Comment un nœud qui n’a jamais vu la chaîne atteint la version courante, et comment il s’y maintient.
Un nœud qui rejoint le réseau doit répondre à deux questions : comment arriver là où la chaîne se trouve maintenant, et comment y rester. La synchronisation d’état répond aux deux, et le compromis entre les deux est explicite plutôt que caché.
Deux modes de rattrapage
L’amorçage — atteindre la version courante en partant de rien — peut se faire de deux façons fondamentalement différentes.
**Rejouer l’historique.** Partir de la genèse et avancer, soit en exécutant à nouveau chaque transaction, soit en appliquant les sorties que l’exécution a déjà produites. On obtient un nœud qui détient tout l’historique : chaque version, chaque preuve, chaque transaction. C’est aussi lent, et cela devient plus lent chaque jour où la chaîne tourne.
**Télécharger l’état courant.** Sauter l’historique et récupérer les clés et valeurs d’état telles qu’elles sont à la dernière version, vérifiées par rapport à la racine entérinée. Le nœud est à jour en une fraction du temps, et ne sait rien de la façon dont la chaîne en est arrivée là.
Un nouveau nœud
Mode d’amorçage
Rejouer l’historiqueréexécuter, ou appliquer les sorties, depuis la genèselent, et plus lent chaque jour qui passe
Télécharger l’état courantclés et valeurs à la dernière version, vérifiées face à la racine entérinéeà jour en une fraction du temps
Version courantepuis en continu
Les deux chemins ne s’équivalent pasUn nœud qui a téléchargé l’état courant ne sert aucune requête historique ni ne dit comment une position en est arrivée là. Alimenter un indexeur ou un audit demande l’historique sauté.
À l’intérieur du chemin de rejeu, un autre choix se présente — réexécuter les transactions, appliquer les sorties stockées, ou laisser le nœud prendre à chaque instant la plus rapide des deux. Réexécuter est la vérification la plus forte, puisqu’elle reproduit le résultat au lieu de faire confiance à un résultat enregistré ; appliquer les sorties est plus rapide. Le mode mixte existe parce que la bonne réponse change selon le retard du nœud.
C’est une décision opérationnelle, pas un réglage par défaut à accepter sans réfléchir. Un nœud qui a téléchargé l’état courant ne peut ni servir de requêtes historiques, ni dire comment une position en est arrivée là — il n’a pas d’historique à lire. Un nœud qui sert un [indexeur](/fr/protocol/architecture/indexer) ou un processus d’audit a besoin de l’historique qu’il a sauté.
Rester à jour
Une fois à la version courante, un nœud se maintient en consommant les blocs entérinés à mesure qu’ils arrivent — là encore soit en exécutant les transactions, soit en appliquant les sorties, avec le même compromis entre force de vérification et vitesse.
La différence avec l’amorçage, c’est que l’écart est petit et constant plutôt que grand et décroissant. Un nœud qui prend suffisamment de retard repasse par le chemin d’amorçage au lieu d’essayer de combler un écart arbitraire par petits pas.
Comment les données circulent
La synchronisation n’est pas un nœud qui demande à un autre une plage de blocs. Elle se décompose en couches, pour qu’aucun pair ne soit une dépendance et qu’aucune défaillance isolée ne bloque la progression.
| Couche | Rôle |
| ------------------------ | ------------------------------------------------------------------------------------------------------- |
| **Service de stockage** | Sert des données aux autres nœuds : transactions, sorties, valeurs d’état, et les preuves qui vont avec |
| **Client de données** | Choisit les pairs, suit qui détient quoi, envoie les requêtes et traite celles qui échouent |
| **Service de streaming** | Transforme « amène-moi d’ici à là » en un flux ordonné de fragments vérifiés |
| **Pilote** | Décide de ce dont le nœud a besoin ensuite et applique ce qui arrive |
La conséquence qu’il faut comprendre : un nœud en cours de synchronisation ne fait pas confiance à un pair. Chaque fragment arrive accompagné d’une preuve qui le rattache à une racine entérinée par le réseau, et un pair qui sert quelque chose d’incohérent est rejeté plutôt que cru. Le choix des pairs est une décision de performance, pas une décision de confiance.
Vérification
Rien dans la synchronisation d’état n’est accepté sur la seule foi de son expéditeur.
Les valeurs d’état sont vérifiées par rapport à la racine d’état entérinée ; les transactions et les sorties, par rapport aux accumulateurs. Un nœud qui termine son amorçage détient un état dont la racine correspond à ce qu’un quorum de validateurs a signé — c’est ce qui rend le chemin rapide sûr : télécharger l’état courant saute l’historique, mais ne saute pas la vérification.
Pour aller plus loin
Les structures qui rendent la synchronisation vérifiable.
Les rôles de nœud, et comment demander à en opérer un.
À quel palier de nœud parle un pair en cours de synchronisation.
Ce à quoi l’historique répond et que l’état courant ne peut pas.