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

# Sincronização de estado

> Como um nó que nunca viu a cadeia chega à versão atual, e como se mantém nela.

Um nó que se junta à rede tem de responder a duas perguntas: como chegar ao ponto onde a cadeia está agora e como manter-se aí. A sincronização de estado responde às duas, e o compromisso entre elas é explícito, não escondido.

<h2 id="two-modes-of-catching-up">
  Duas formas de recuperar o atraso
</h2>

O arranque inicial (bootstrapping) — chegar à versão atual a partir do nada — pode ser feito de duas maneiras fundamentalmente diferentes.

**Reexecutar o histórico.** Começar na génese e avançar, executando de novo todas as transações ou aplicando os resultados que a execução já produziu. O resultado é um nó que detém o histórico inteiro: todas as versões, todas as provas, todas as transações. É também lento, e fica mais lento a cada dia que a cadeia corre.

**Descarregar o estado atual.** Saltar o histórico e obter as chaves e os valores de estado tal como estão na versão mais recente, verificados contra a raiz confirmada. O nó fica atualizado numa fração do tempo e não sabe nada sobre como a cadeia lá chegou.

<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">Um nó novo</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">Reexecutar o histórico</span><span className="dg-s">reexecutar ou aplicar os resultados, desde a génese</span><span className="dg-n">lento, e mais lento a cada dia que passa</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">Descarregar o estado atual</span><span className="dg-s">chaves e valores na versão mais recente, verificados contra a raiz confirmada</span><span className="dg-n">atualizado numa fração do tempo</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">Versão atual</span><span className="dg-s">sincronização contínua</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">Os caminhos não são equivalentes</span><span className="dg-s">Um nó que descarregou o estado atual não serve consultas históricas nem sabe como uma posição chegou onde está. Um nó que alimenta um indexador ou uma auditoria precisa do histórico que saltou.</span></div>
  </div>
</div>

Dentro do caminho da reexecução há ainda outra escolha — reexecutar as transações, aplicar os resultados guardados, ou deixar o nó escolher o que for mais rápido em cada momento. Reexecutar é a verificação mais forte, já que reproduz o resultado em vez de confiar num resultado registado; aplicar os resultados é mais rápido. O modo misto existe porque a resposta certa muda consoante o atraso do nó.

<Note>
  Esta é uma decisão operacional, não um valor por omissão a aceitar sem pensar. Um nó que descarregou o estado atual não consegue servir consultas históricas nem responder a perguntas sobre como uma posição chegou onde está — não tem histórico para ler. Um nó que sirva um [indexador](/pt/protocol/architecture/indexer) ou um processo de auditoria precisa do histórico que saltou.
</Note>

<h2 id="staying-current">
  Manter-se atualizado
</h2>

Uma vez na versão atual, um nó acompanha a cadeia consumindo os blocos confirmados à medida que chegam — de novo executando as transações ou aplicando os resultados, com o mesmo compromisso entre força de verificação e velocidade.

A diferença face ao arranque inicial é que a distância é pequena e constante, em vez de grande e a diminuir. Um nó que fique suficientemente atrasado volta a entrar no caminho do arranque inicial, em vez de tentar fechar uma distância arbitrária de forma incremental.

<h2 id="how-data-moves">
  Como os dados circulam
</h2>

A sincronização não é um nó a pedir a outro um intervalo de blocos. Separa-se em camadas, para que nenhum par isolado seja uma dependência e nenhuma falha isolada trave o progresso.

| Camada                       | Função                                                                                            |
| ---------------------------- | ------------------------------------------------------------------------------------------------- |
| **Serviço de armazenamento** | Serve dados a outros nós: transações, resultados, valores de estado e as provas que os acompanham |
| **Cliente de dados**         | Escolhe pares, regista quem tem o quê, envia pedidos e trata dos que falham                       |
| **Serviço de streaming**     | Transforma «leva-me daqui até ali» num fluxo ordenado de segmentos verificados                    |
| **Controlador**              | Decide de que precisa o nó a seguir e aplica o que chega                                          |

A consequência que vale a pena perceber: um nó em sincronização não está a confiar num par. Cada segmento chega com uma prova contra uma raiz que a rede confirmou, e um par que sirva algo inconsistente é rejeitado em vez de merecer crédito. A seleção de pares é uma decisão de desempenho, não uma decisão de confiança.

<h2 id="verification">
  Verificação
</h2>

Nada na sincronização de estado é aceite apenas por crédito de quem o enviou.

Os valores de estado são verificados contra a raiz do estado confirmada. As transações e os resultados são verificados contra os acumuladores. Um nó que termina o arranque inicial tem um estado cuja raiz corresponde ao que um quórum de validadores assinou — e é isto que torna seguro o caminho rápido: descarregar o estado atual salta o histórico, mas não salta a verificação.

<h2 id="where-to-go-next">
  Para onde ir a seguir
</h2>

<CardGroup cols={2}>
  <Card title="Armazenamento e provas" href="/pt/protocol/architecture/state/storage">
    As estruturas que tornam a sincronização verificável.
  </Card>

  <Card title="Operar um nó" href="/pt/developers/run-a-node">
    Os papéis de nó e como pedir informações sobre a operação de um nó.
  </Card>

  <Card title="Topologia da rede" href="/pt/protocol/architecture/intention-bft">
    Com que nível de nó está a falar um par em sincronização.
  </Card>

  <Card title="Indexador" href="/pt/protocol/architecture/indexer">
    O que o histórico responde e o estado atual não consegue.
  </Card>
</CardGroup>
