> ## 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.

# Sincronización de estado

> Cómo un nodo que nunca ha visto la cadena llega a la versión actual, y cómo se mantiene ahí.

Un nodo que se une a la red tiene que responder a dos preguntas: cómo llego a donde está la cadena ahora, y cómo me mantengo ahí. La sincronización de estado responde a las dos, y el compromiso entre ambas es explícito en lugar de estar escondido.

<h2 id="two-modes-of-catching-up">
  Dos modos de ponerse al día
</h2>

El arranque inicial (llegar a la versión actual partiendo de cero) se puede hacer de dos formas fundamentalmente distintas.

**Reejecutar el historial.** Empezar en el génesis y avanzar, ya sea ejecutando otra vez cada transacción o aplicando las salidas que la ejecución ya produjo. El resultado es un nodo que tiene el historial completo: cada versión, cada prueba, cada transacción. También es lento, y se vuelve más lento cada día que la cadena funciona.

**Descargar el estado actual.** Saltarse el historial y traer las claves y los valores de estado tal como están en la última versión, verificados contra la raíz confirmada. El nodo se pone al día en una fracción del tiempo, y no sabe nada de cómo la cadena llegó hasta ahí.

<div className="dg" data-dg="state-sync">
  <div className="dg-c" style={{aspectRatio:"720 / 322"}}>
    <svg className="dg-w" viewBox="0 0 720 322" aria-hidden="true">
      <path className="dg-wire dg--blue" d="M 134.00 126.00 L 159.60 126.00" />

      <path className="dg-head dg--blue" d="M 166.00 126.00 L 159.60 130.40 L 159.60 121.60 Z" />

      <path className="dg-wire dg--sky" d="M 324.00 126.00 L 356.54 75.38" />

      <path className="dg-head dg--sky" d="M 360.00 70.00 L 360.24 77.76 L 352.84 73.00 Z" />

      <path className="dg-wire dg--yellow" d="M 324.00 126.00 L 356.54 176.62" />

      <path className="dg-head dg--yellow" d="M 360.00 182.00 L 352.84 179.00 L 360.24 174.24 Z" />

      <path className="dg-wire dg--green" d="M 568.00 70.00 L 578.66 119.74" />

      <path className="dg-head dg--green" d="M 580.00 126.00 L 574.36 120.66 L 582.96 118.82 Z" />

      <path className="dg-wire dg--green" d="M 568.00 182.00 L 578.66 132.26" />

      <path className="dg-head dg--green" d="M 580.00 126.00 L 582.96 133.18 L 574.36 131.34 Z" />
    </svg>

    <div className="dg-b dg--blue" style={{left:"0.0000%",top:"30.4348%",width:"18.0556%",height:"17.3913%"}}><span className="dg-t">Un nodo nuevo</span></div>
    <div className="dg-b dg--yellow dg-round" style={{left:"23.6111%",top:"29.1925%",width:"20.8333%",height:"19.8758%"}}><span className="dg-t">Modo de arranque</span></div>
    <div className="dg-b dg--sky" style={{left:"50.5556%",top:"6.2112%",width:"27.7778%",height:"31.0559%"}}><span className="dg-t">Reejecutar historial</span><span className="dg-s">reejecutar o aplicar salidas, desde el génesis</span><span className="dg-n">lento, y más lento cada día que pasa</span></div>
    <div className="dg-b dg--yellow" style={{left:"50.5556%",top:"40.9938%",width:"27.7778%",height:"31.0559%"}}><span className="dg-t">Descargar estado actual</span><span className="dg-s">claves y valores en la última versión, verificados contra la raíz confirmada</span><span className="dg-n">al día en una fracción del tiempo</span></div>
    <div className="dg-b dg--green" style={{left:"81.1111%",top:"25.4658%",width:"18.8889%",height:"27.3292%"}}><span className="dg-t">Versión actual</span><span className="dg-s">y sincronización continua</span></div>
    <div className="dg-b dg--orange dg-left" style={{left:"0.0000%",top:"78.2609%",width:"100.0000%",height:"18.0124%"}}><span className="dg-t">Las dos rutas no son equivalentes</span><span className="dg-s">Un nodo que descargó el estado actual no puede servir consultas históricas ni decir cómo llegó una posición hasta ahí. Quien alimenta a un indexador o a una auditoría necesita el historial que se saltó.</span></div>
  </div>
</div>

Dentro de la ruta de reejecución hay una elección más: volver a ejecutar las transacciones, aplicar las salidas almacenadas o dejar que el nodo escoja en cada punto lo que sea más rápido. Volver a ejecutar es la comprobación más fuerte, porque reproduce el resultado en lugar de fiarse de uno registrado; aplicar salidas es más rápido. El modo mixto existe porque la respuesta correcta cambia según lo atrasado que vaya el nodo.

<Note>
  Esta es una decisión operativa, no un valor por defecto que aceptar sin pensarlo. Un nodo que descargó el estado actual no puede servir consultas históricas ni responder preguntas sobre cómo llegó una posición a donde está: no tiene historial que leer. Un nodo que sirve a un [indexador](/es/protocol/architecture/indexer) o a un proceso de auditoría necesita el historial que se saltó.
</Note>

<h2 id="staying-current">
  Mantenerse al día
</h2>

Una vez en la versión actual, un nodo se mantiene al día consumiendo los bloques confirmados según llegan, de nuevo ejecutando las transacciones o aplicando las salidas, con el mismo compromiso entre fuerza de verificación y velocidad.

La diferencia con el arranque inicial es que la distancia es pequeña y constante en lugar de grande y decreciente. Un nodo que se atrasa lo suficiente vuelve a entrar en la ruta de arranque inicial en vez de intentar cerrar una distancia arbitraria de forma incremental.

<h2 id="how-data-moves">
  Cómo se mueven los datos
</h2>

La sincronización no es un nodo pidiéndole a otro un rango de bloques. Se separa en capas para que ningún par concreto sea una dependencia y ningún fallo aislado detenga el progreso.

| Capa                           | Función                                                                                              |
| ------------------------------ | ---------------------------------------------------------------------------------------------------- |
| **Servicio de almacenamiento** | Sirve datos a otros nodos: transacciones, salidas, valores de estado y las pruebas que los acompañan |
| **Cliente de datos**           | Elige pares, lleva la cuenta de quién tiene qué, envía peticiones y gestiona las que fallan          |
| **Servicio de streaming**      | Convierte “llévame de aquí a allí” en un flujo ordenado de segmentos verificados                     |
| **Controlador**                | Decide qué necesita el nodo a continuación y aplica lo que llega                                     |

La consecuencia que conviene entender: un nodo que sincroniza no está confiando en un par. Cada segmento llega con una prueba contra una raíz que la red confirmó, y a un par que sirve algo inconsistente se le rechaza en vez de creerle. La elección de pares es una decisión de rendimiento, no una decisión de confianza.

<h2 id="verification">
  Verificación
</h2>

En la sincronización de estado nada se acepta por quién lo haya enviado.

Los valores de estado se verifican contra la raíz de estado confirmada. Las transacciones y las salidas se verifican contra los acumuladores. Un nodo que termina el arranque inicial tiene un estado cuya raíz coincide con lo que firmó un quórum de validadores, y eso es lo que hace segura la vía rápida: descargar el estado actual se salta el historial, pero no se salta la verificación.

<h2 id="where-to-go-next">
  Qué leer a continuación
</h2>

<CardGroup cols={2}>
  <Card title="Almacenamiento y pruebas" href="/es/protocol/architecture/state/storage">
    Las estructuras que hacen verificable la sincronización.
  </Card>

  <Card title="Ejecutar un nodo" href="/es/developers/run-a-node">
    Los roles de nodo y cómo solicitar información para operar uno.
  </Card>

  <Card title="Topología de la red" href="/es/protocol/architecture/intention-bft">
    Con qué nivel de nodo habla un par que sincroniza.
  </Card>

  <Card title="Indexador" href="/es/protocol/architecture/indexer">
    Qué responde el historial que el estado actual no puede responder.
  </Card>
</CardGroup>