Juntar-se a uma Rede

Instruções para acelerar um nó usando Sincronização de Estado.

Para instruções sobre como se juntar como um validador, veja o Guia do Validador.

Primeiros Passos

Certifique-se de que os seguintes pré-requisitos estejam concluídos:

Escolha a configuração adequada de hardware/servidor. Veja o guia de hardware.
Certifique-se de que o crossfid esteja corretamente instalado. Veja o guia de instalação para um tutorial.
Siga o guia de configuração para inicializar e preparar o nó para sincronizar com a rede.

Escolhendo uma Rede

As redes CrossFi atuais são:

Rede de Teste

crossfi-evm-testnet-1.

Rede Principal

crossfi-mainnet-1.

Exploradores

Exploradores de Testnet

Explorador de blocos - https://scan.testnet.ms/
Explorador de camadas de execução/consenso - https://test.xfiscan.com/

Exploradores de Mainnet

Explorador de camadas de execução/consenso - https://xfiscan.com/

Hardware

Executar um nó de arquivo completo pode ser intensivo em recursos, já que o atual crossfi-1 completo está acima de 1TB. Para aqueles que desejam executar a sincronização de estado ou usar o quicksync, a seguinte configuração de hardware é recomendada:

\n\n| Tipo de Nó | RAM | Armazenamento | Validador | 32GB | 500GB-2TB* |\n| --- | --- | --- | --- | --- | --- |\n\n

* O tamanho de armazenamento para validadores dependerá do nível de poda.

Configuração Geral

Certifique-se de passar pela configuração básica e de instalação. Os operadores precisarão inicializar o crossfid, baixar o arquivo genesis para o crossfi-1, e definir peers persistentes e/ou seeds para inicialização.

Inicializar Cadeia

Rede de Teste

wget https://github.com/crossfichain/crossfi-node/releases/download/v0.3.0-prebuild3/crossfi-node_0.3.0-prebuild3_linux_amd64.tar.gz &amp;amp;&amp;amp; tar -xf crossfi-node_0.3.0-prebuild3_linux_amd64.tar.gz
git clone https://github.com/crossfichain/testnet.git
./bin/crossfid start --home ./testnet

Rede Principal

wget https://github.com/crossfichain/crossfi-node/releases/download/v0.3.0/crossfi-node_0.3.0_linux_amd64.tar.gz &amp;amp;&amp;amp; tar -xf crossfi-node_0.3.0_linux_amd64.tar.gz
git clone https://github.com/crossfichain/mainnet.git
./bin/crossfid start --home ./mainnet

Seeds & Peers

Após a inicialização, o nó precisará se conectar a peers. Se houver nós específicos que um operador deseja configurar como seeds ou peers persistentes, isso pode ser configurado em ~/.crossfid/config/config.toml

# Lista separada por vírgulas de nós seeds para se conectar
seeds = "@:26656,@:26656"

# Lista separada por vírgulas de nós para manter conexões persistentes
persistent_peers = "@:26656,@:26656"

Poda de Estado - Passo Opcional

Existem quatro estratégias para podar o estado. Essas estratégias se aplicam apenas ao estado e não ao armazenamento de blocos. Um operador de nó pode querer considerar a poda personalizada se o armazenamento do nó for uma preocupação ou houver interesse em executar um nó de arquivo.

Para definir a poda, ajuste o parâmetro pruning no arquivo ~/.crossfid/config/app.toml. As seguintes configurações de estado de poda estão disponíveis:

everything: Podar todos os estados salvos, exceto o estado atual.
nothing: Salvar todos os estados e não deletar nada.
default: Salvar os últimos 100 estados e o estado de cada 10.000º bloco.
custom: Especificar configurações de poda com os parâmetros pruning-keep-recent, pruning-keep-every, e pruning-interval.

Por padrão, todo nó está em modo default, que é a configuração recomendada para a maioria dos ambientes. Se um operador de nó quiser alterar a estratégia de poda do nó, isto deve ser feito antes do nó ser inicializado.

Em ~/.crossfid/config/app.toml

# default: os últimos 100 estados são mantidos além de cada 500º estado; poda em intervalos de 10 blocos

# nothing: todos os estados históricos serão salvos, nada será deletado (i.e. nó arquivado)

# everything: todos os estados salvos serão deletados, armazenando apenas o estado atual; poda em intervalos de 10 blocos

# custom: permite que as opções de poda sejam especificadas manualmente através de 'pruning-keep-recent', 'pruning-keep-every', e 'pruning-interval'
pruning = "custom"

# Estas são aplicadas se e somente se a estratégia de poda for custom.
pruning-keep-recent = "10"
pruning-keep-every = "1000"
pruning-interval = "10"

Passar um flag ao iniciar o crossfid sempre irá sobrescrever as configurações no arquivo app.toml. Para mudar a configuração de poda do nó para o modo everything, passe o flag ---pruning everything ao executar crossfid start.

Se o nó estiver sendo executado com estado podado, não será possível consultar as alturas que não estão armazenadas no nó.

API REST - Opcional

Por padrão, a API REST está desativada. Para ativar a API REST, edite o arquivo ~/.crossfid/config/app.toml e defina enable como true na seção [api].

###############################################################################

###                           Configuração de API                           ###

###############################################################################
[api]

# Habilita define se o servidor de API deve ser ativado.
enable = true

# Swagger define se a documentação swagger deve ser registrada automaticamente.
swagger = false

# O endereço define o servidor de API para escutar.
address = "tcp://0.0.0.0:1317"

Opcionalmente, ative o swagger definindo swagger como true ou altere a porta da API REST no parâmetro address. Após reiniciar o aplicativo, acesse a API REST em :1317.

GRPC - Opcional

Por padrão, o gRPC está ativado na porta 9090. O arquivo ~/.crossfid/config/app.toml é onde alterações podem ser feitas na seção de gRPC. Para desativar o endpoint gRPC, defina enable como false. Para alterar a porta, use o parâmetro address.

###############################################################################

###                           Configuração de gRPC                          ###

###############################################################################
[grpc]

# Habilitar define se o servidor gRPC deve ser ativado.
enable = true

# O endereço define o endereço do servidor gRPC para conectar.
address = "0.0.0.0:9090"

Opções de Sincronização

Existem três maneiras principais de sincronizar um nó na Cadeia Crossfi; Blocksync, Sincronização de Estado e Quicksync. Veja a matriz abaixo para a configuração recomendada do Hub. Este guia irá focar na sincronização de dois tipos comuns de nós; completo e podado. Para mais informações sobre sincronização para execução de um nó validador, veja a seção sobre Validadores.

Existem dois tipos de preocupações ao decidir qual opção de sincronização é a correta. Integridade dos dados refere-se a quão confiáveis são os dados fornecidos por um subconjunto de participantes da rede. Dados históricos refere-se a quão robusta e abrangente é a história da cadeia.

	Baixa Integridade de Dados	Alta Integridade de Dados
Dados Históricos Minimais	Quicksync - Podado	Sincronização de Estado
Dados Históricos Moderados	Quicksync - Padrão
Dados Históricos Completos	Quicksync - Arquivo	Blocksync

Certifique-se de consultar a seção de hardware para orientação sobre a melhor configuração para o tipo de nó em operação.

Blocksync

Blocksync é mais rápido que o consenso tradicional e sincroniza a cadeia desde o gênesis baixando blocos e verificando contra a árvore merkle de validadores. Para mais informações veja os Documentos de Fastsync da Tendermint

Ao sincronizar via Blocksync, operadores de nós precisarão atualizar manualmente a cadeia ou configurar Cosmovisor para atualizar automaticamente.

É possível sincronizar de versões anteriores da Cadeia Crossfi. Veja a matriz abaixo para a versão correta do crossfid. Veja o arquivo de testnet para arquivos gênesis históricos.

Id da Cadeia	Versão Crossfi
`crossfi-evm-testnet-1`	`v0.2.0`

Primeiros Passos

Inicie o crossfid para começar a sincronizar com o flag skip-invariants. Para mais informações sobre isso veja Verificar rede.

crossfid start --x-crisis-skip-assert-invariants

Sincronização de Estado

Sincronização de Estado é uma forma eficiente e rápida de inicializar um novo nó, funcionando por meio da reprodução de grandes blocos de estado do aplicativo diretamente em vez de reproduzir blocos individuais ou rodadas de consenso. Para mais informações, veja os documentos de Sincronização de Estado da Tendermint.

Para habilitar a sincronização de estado, visite um explorador para obter uma altura de bloco recente e hash correspondente. Um operador de nó pode escolher qualquer altura/hash no período de vinculação atual, mas como o período recomendado de snapshot é 1000 blocos, é aconselhável escolher algo próximo a altura atual - 1000.

Com a altura do bloco e hash selecionados, atualize a configuração em ~/.crossfid/config/config.toml para definir enable = true, e preencha os trust_height e trust_hash. Operadores de nós podem configurar os servidores rpc para um fornecedor preferido, mas devem haver pelo menos dois registros. É importante que estes sejam dois servidores rpc que o operador de nó confia para verificar partes componentes do estado da cadeia. Embora não seja recomendado, a exclusividade não é atualmente aplicada, de modo que é possível duplicar o mesmo servidor na lista e ainda sincronizar com sucesso.

No futuro, o requisito do servidor RPC será descontinuado à medida que a sincronização de estado for movida para a camada p2p no Tendermint 0.38.

#######################################################

###         Opções de Configuração de Sincronização de Estado         ###

#######################################################
[statesync]

# A sincronização de estado inicializa rapidamente um novo nó, descobrindo, buscando e restaurando um estado

# de máquina de snapshot de peers em vez de buscar e reproduzir blocos históricos. Requer alguns peers na

# rede para tirar e servir snapshots do estado da máquina. A sincronização de estado não é tentada se o nó

# tiver algum estado local (LastBlockHeight &amp;gt; 0). O nó terá um histórico de blocos truncado,

# começando a partir da altura do snapshot.
enable = true

# Servidores RPC (separados por vírgulas) para verificação de cliente leve do estado sincronizado e

# recuperação de dados de estado para inicialização do nó. Também precisa de uma altura confiável e hash

# correspondente obtidos de uma fonte confiável, e um período durante o qual os validadores podem ser confiáveis.

#

# Para cadeias baseadas em Cosmos SDK, trust_period deve geralmente ser cerca de 2/3 do tempo de desvinculação (~2

# semanas) durante o qual eles podem ser punidos financeiramente (reduzidos) por má conduta.
rpc_servers = ""
trust_height = 0
trust_hash = ""
trust_period = "168h0m0s"

Inicie o crossfid para começar a sincronização de estado. Pode levar algum tempo para que o nó adquira um snapshot, mas o comando e a saída devem ser semelhantes ao seguinte:

$ crossfid start --x-crisis-skip-assert-invariants

...

&amp;gt; INF Descoberto novo formato de snapshot=1 hash="0x000..." altura=8967000 módulo=statesync

...

&amp;gt; INF Buscando pedaço de snapshot pedaço=4 formato=1 altura=8967000 módulo=statesync total=45
&amp;gt; INF Aplicado pedaço de snapshot ao aplicativo ABCI pedaço=0 formato=1 altura=8967000 módulo=statesync total=45

Uma vez que a sincronização de estado é concluída com sucesso, o nó começará a processar blocos normalmente. Se a sincronização de estado falhar e o operador do nó encontrar o seguinte erro: Sincronização de estado falhou err="sincronização de estado abortada", tente reiniciar o crossfid ou execute crossfid unsafe-reset-all (certifique-se de fazer backup de qualquer configuração e histórico antes de fazer isso).

Quicksync

Quicksync.io oferece vários snapshots diários da Cadeia Crossfi com níveis variados de poda (arquivo 1.4TB, padrão 540GB, e podado 265GB). Para downloads e instruções de instalação, visite o guia Cosmos Quicksync.

Snapshots

Salvar e servir snapshots ajuda os nós a entrarem rapidamente na rede. Snapshots agora estão habilitados por padrão a partir de 1/20/21.

Embora não seja aconselhável, se um operador de nó precisar personalizar esse recurso, ele pode ser configurado em ~/.crossfid/config/app.toml. A Cadeia Crossfi recomenda definir esse valor para coincidir com pruning-keep-every em config.toml.

É altamente recomendado que os operadores de nó usem o mesmo valor para snapshot-interval de modo a ajudar na descoberta de snapshots. A descoberta é mais fácil quando mais nós estão servindo os mesmos snapshots.

Em app.toml

###############################################################################

###                        Configuração de Sincronização de Estado                         ###

###############################################################################

# Snapshots de sincronização de estado permitem que outros nós entrem rapidamente na rede sem reproduzir blocos históricos

# , em vez disso, baixando e aplicando um snapshot do estado do aplicativo em uma determinada altura.
[state-sync]

# snapshot-interval especifica o intervalo de bloco no qual snapshots locais de sincronização de estado são

# tirados (0 para desativar). Deve ser um múltiplo de pruning-keep-every.
snapshot-interval = 1000

# snapshot-keep-recent especifica o número de snapshots recentes a serem mantidos e servidos (0 para manter todos).
snapshot-keep-recent = 10

Cosmovisor

O Cosmovisor é um gerenciador de processos desenvolvido para aliviar operadores de nó da intervenção manual toda vez que houver uma atualização. O Cosmovisor monitora o módulo de governança para propostas de atualização; ele cuidará de baixar o novo binário, parar o antigo, trocar para o novo e reiniciar.

Para mais informações sobre como executar um nó via Cosmovisor, confira os documentos.

Executando por meio de Processo em Segundo Plano

Para executar o nó em um processo em segundo plano com reinicializações automáticas, é recomendado usar um gerenciador de serviços como systemd. Para configurá-lo, execute o seguinte:

sudo tee /etc/systemd/system/.service &amp;gt; /dev/null &amp;lt;

Então, inicie o processo e confirme que está em execução.

sudo -S systemctl start

sudo service  status

Exportando Estado

O crossfid pode descarregar todo o estado do aplicativo em um arquivo JSON. Esse descarregamento de estado do aplicativo é útil para análise manual e também pode ser usado como o arquivo gênesis de uma nova rede.

O nó não pode estar em execução enquanto exporta o estado, caso contrário o operador pode esperar pelo erro resource temporarily unavailable.

Exportar estado com:

crossfid export &amp;gt; [filename].json

Também é possível exportar estado de uma altura particular (no final do processamento do bloco dessa altura):

crossfid export --height [height] &amp;gt; [filename].json

Se planeja iniciar uma nova rede a partir do estado exportado, exporte com a flag --for-zero-height:

crossfid export --height [height] --for-zero-height &amp;gt; [filename].json

Verificar Rede

Executar invariantes em cada bloco é uma prática recomendada para prevenção de desastres. Isso garante que o operador de nó mantenha o estado correto e esperado da rede.

Embora isso seja importante para a operação de um nó, as verificações de invariantes não são ativadas por padrão porque são computacionalmente caras. Para executar um nó com essas verificações, inicie seu nó com a flag assert-invariants-blockly:

crossfid start --assert-invariants-blockly

Se um invariante for quebrado no nó, ele irá entrar em pânico e solicitará ao operador o envio de uma transação que irá interromper a rede. Por exemplo, a mensagem fornecida pode ser semelhante a:

invariante quebrada:
    invariância de tokens soltos:
        pool.NotBondedTokens: 100
        soma de tokens da conta: 101
    CRÍTICO, por favor envie a seguinte transação:
        crossfid tx crisis invariante-quebrada staking supply

Se você gostaria de executar seu próprio nó validador, veja a seção sobre Validadores.

Primeiros Passos​

Escolhendo uma Rede​

Rede de Teste​

Rede Principal​

Exploradores​

Exploradores de Testnet​

Exploradores de Mainnet​

Hardware​

Configuração Geral​

Inicializar Cadeia​

Rede de Teste​

Rede Principal​

Seeds & Peers​

Poda de Estado - Passo Opcional​

API REST - Opcional​

GRPC - Opcional​

Opções de Sincronização​

Blocksync​

Sincronização de Estado​

Quicksync​

Snapshots​

Cosmovisor​

Executando por meio de Processo em Segundo Plano​

Exportando Estado​

Verificar Rede​

Primeiros Passos

Escolhendo uma Rede

Rede de Teste

Rede Principal

Exploradores

Exploradores de Testnet

Exploradores de Mainnet

Hardware

Configuração Geral

Inicializar Cadeia

Rede de Teste

Rede Principal

Seeds & Peers

Poda de Estado - Passo Opcional

API REST - Opcional

GRPC - Opcional

Opções de Sincronização

Blocksync

Sincronização de Estado

Quicksync

Snapshots

Cosmovisor

Executando por meio de Processo em Segundo Plano

Exportando Estado

Verificar Rede