Temos o prazer de anunciar o Open Beta do nó de arquivo da comunidade Flow. O nó de arquivo fornece uma maneira escalável e eficiente de acessar o histórico do estado de execução do protocolo da flow** para o spork atual. Ele pode ser usado para consultar detalhes da conta e executar scripts em qualquer bloco desde o início do spork atual até o último bloco selado usando a API de acesso gRPC.
O que é um nó de arquivo?
A arquitetura de vários nós da Flow fornece dimensionamento à prova de futuro, separando o consenso da execução e tendo alguns nós de execução ricos em recursos para a execução da transação. Esses nós de execução foram projetados para manter os dados do estado de execução (estado das contas da flow, contratos inteligentes, recursos etc.) na memória para acesso mais rápido. No entanto, como o estado continuará crescendo indefinidamente, os nós de execução são projetados para manter apenas o estado mais recente na memória, voltando a cerca de 100 blocos no passado. Portanto, há uma necessidade de uma solução eficiente para atender a dados de estado de execução antigos ou arquivados que remontam a mais de 100 blocos no passado para qualquer aplicativo que gostaria de consultar o estado em um bloco anterior. O nó de arquivo visa fornecer essa solução e servir dados de arquivo.
O nó de arquivo é um nó que segue a cadeia e armazena e indexa o protocolo e o estado de execução. Ele permite consultas somente leitura, como a execução de scripts que exigem os valores do registro do estado de execução. Ele pode ser usado para responder a quaisquer perguntas de dados anteriores, por exemplo, “qual era o saldo da conta Flow na altura X?” onde X é vários milhares de blocos no passado.
Como funciona o nó de arquivo?
Como o nó do observador , o nó do arquivo também é um nó não stakado e se comunica com um nó de acesso upstream. O nó observador recebe apenas os dados do estado do protocolo (blocos, coleções, transações etc.), enquanto o nó arquivo recebe tanto o estado do protocolo quanto os dados do estado de execução.
Quem deve usar o nó de arquivo?
dApps que precisam de acesso a dados históricos, por exemplo, CAST, que considera os saldos da conta do usuário em um bloco anterior.
Ferramentas de análise e auditoria em cadeia que requerem acesso a dados históricos.
Nós diferentes para recuperação de dados - nó de arquivo vs nó de acesso vs nó observador
Antes de discutir a diferença entre o nó de arquivo e os nós de acesso e observador, primeiro vamos examinar os dois tipos de dados de estado na Blockchain Flow. Como a Flow tem diferentes tipos de nós em vez de um único nó validador, nem todos os tipos de nós têm todos os dados. Os dados de estado da flow são divididos em dados de estado de protocolo e dados de estado de execução .
Protocol State é o estado de funcionamento do protocolo da rede Flow, incluindo a tabela de identidades e recursos produzidos pelos nós da rede Flow: blocos, cobranças, recibos, aprovações, selos, etc.
O estado de execução é o estado das contas da flow, contratos inteligentes, recursos, etc. Esse estado é armazenado integralmente apenas nos nós de execução.
O nó de acesso é um nó stakado que recebe e indexa todos os dados de estado do protocolo e atende à API de acesso . Ele pode responder a todas as chamadas de API do Access relacionadas ao estado do protocolo, como GetBlock, GetAccount, GetCollection etc.
Consultando seu banco de dados local. No entanto, para todas as chamadas relacionadas ao estado de execução, por exemplo, GetAccount , ExecuteScriptAtXXX, ele faz uma chamada upstream para um nó de execução para buscar os dados do estado de execução.
No início deste ano, o nó observador foi lançado como uma alternativa não stakada ao nó de acesso que qualquer um pode executar sem ter que stakar o nó. Assim como o nó de acesso, o nó do observador também atende à API do Access. Ele apenas recebe e indexa os dados de bloco mais recentes e delega todas as chamadas de API de acesso a um nó de acesso upstream diferente daqueles para dados de bloco.
Hoje, pode-se consultar facilmente um nó de acesso ou um nó observador para obter o saldo da conta no último bloco ou executar um script no último bloco, mas você não pode consultar o saldo da conta ou executar o script em qualquer bloco arbitrário no passado.
Ao fazer isso, você receberá um erro como o seguinte, pois os nós de execução não retêm os dados do estado de execução além de 100 blocos no passado.
erro rpc: code = Desc interno = falha ao obter conta: falha ao obter conta no bloco (xxx): compromisso de estado não encontrado (yyy). esse erro geralmente ocorre se o bloco de referência para esse script não estiver definido como um bloco recente.
É aqui que entra o nó de arquivo.
Ao contrário do nó de acesso e do nó do observador, o nó de arquivo armazena e indexa o estado de Execução além dos dados de estado do Protocolo.
Em seguida, ele pode responder às chamadas de API de acesso do estado de execução, como GetAccount, por meio de seu banco de dados local.
Parte da Rede da flow (fala com os outros nós stakados) |
Qual API ele atende? |
Qualquer pessoa pode executar um nó? |
Limites de taxa nos nós da comunidade |
Se você deseja acessar os últimos blocos, transações etc., mas não deseja executar um nó, use o nó de acesso da comunidade Flow
Se você deseja uma única locação e/ou não deseja estar sujeito aos limites de taxa da API do Access, considere executar seu próprio nó de acesso.
Se você deseja um nó executado localmente que forneça os dados de bloco mais recentes, execute um nó observador.
Se você deseja acessar os dados históricos do estado de execução, use o nó de arquivo da comunidade.
API
O nó de arquivo fornece uma versão concisa da API gRPC Access , que inclui as três chamadas a seguir:
- ExecuteScriptAtBlockID
- ExecuteScriptAtBlockHeight
- GetAccountAtBlockHeight
Ele retorna um erro HTTP 501 Não implementado para todas as outras chamadas de API do Access.
O endpoint da API gRPC é: archive.mainnet.nodes.onflow.org:9000
Exemplos
- Para obter um saldo de conta no início do spork atual, você pode chamar GetAccountAtBlockHeight no nó de arquivo.
Código de amostra:
package main
import (
"context"
"fmt"
"github.com/onflow/flow-go-sdk/access/grpc"
"github.com/onflow/flow-go-sdk"
)
func main() {
// a flow endpoint da API de arquivo da comunidade
archiveNodeAddress := "archive.mainnet.nodes.onflow.org:9000"
// cria um cliente gRPC para o nó Archive
archiveNodeClient, err := grpc.NewClient(archiveNodeAddress)
if err != nil {
fmt.Println ("err:", err.Error())
panic(err)
}
ctx := context.Background()
addr := flow.HexToAddress("e467b9dd11fa00df") // qualquer endereço de conta Flow
// obtém o saldo da conta no início altura do garfo atual
// https://developers.flow.com/nodes/node-operation/past-sporks#mainnet-20
conta, err := archiveNodeClient.GetAccountAtBlockHeight(ctx, addr, 40171634)
if err != nil {
fmt. Println("err:", err.Error())
panic(err)
}
fmt.Println(account.Balance)
}
- Para executar um script em um bloco no passado, você pode chamar ExecuteScriptAtBlockHeight ou ExecuteScriptAtBlockID no nó de arquivo.
Código de amostra:
package main
import (
"context"
"fmt"
"github.com/onflow/cadence"
"github.com/onflow/flow-go-sdk/access/grpc"
)
func main() {
// o nó de acesso da comunidade principal da Flow API endpoint
accessNodeAddress := "access.mainnet.nodes.onflow.org:9000"
// o arquivo da comunidade Flow API endpoint
archiveNodeAddress := "archive.mainnet.nodes.onflow.org:9000"
// cria um cliente gRPC para o Nó de acesso
accessNodeClient, err := grpc.NewClient(accessNodeAddress)
if err != nil {
fmt.Println("err:", err.Error())
panic(err)
}
ctx := context.Background()
// obtém a altura do último bloco selado do nó de acesso da comunidade mainnet da Flow RecentBlockHeader
, err := accessNodeClient.GetLatestBlockHeader(ctx, true)
if err != nil {
fmt.Println("err:", err.Error() )
panic(err)
}
// definir a altura para 500 blocos na
altura passada := lastBlockHeader.Height - 500
// criar um cliente gRPC para o nó Archive
archiveNodeClient, err := grpc.NewClient(archiveNodeAddress)
if err != nil {
fmt.Println("err:", err.Error())
panic(err)
}
script := []byte(`
pub fun main(a: Int): Int {
return a + 10
}
`)
args := []cadence.Value{cadence.NewInt(5)}
// executa o script no nó de arquivo em uma altura de bloco que é de 500 blocos no
valor passado, err := archiveNodeClient.ExecuteScriptAtBlockHeight(ctx, height, script, args)
if err != nil {
fmt.Println("err:" , err.Error())
panic(err)
}
fmt.Printf("\nValor: %s", valor)
}
Limitações
- Limites de taxa da API gRPC
- A API REST do Access e o endpoint gRPC-web não são compatíveis no momento.
- O nó de arquivo atualmente não pode ser auto-hospedado.
- O nó de arquivo só pode voltar até o início do spork atual.
Status do Nó
O status do nó de arquivo pode ser monitorado na página de status da flow em “Componentes do nó de arquivo da rede principal da flow”
O que vem a seguir 🚀
Este é um lançamento beta aberto à medida que resolvemos os problemas e preparamos o nó de arquivo para um lançamento GA no início do próximo ano.
O nó de arquivo da comunidade estará sempre disponível e, no início do próximo ano, haverá uma versão auto-hospedada do nó de arquivo que qualquer um pode executar como parte do caminho para o roteiro de operação do nó sem permissão. Este lançamento beta é um trampolim para esse objetivo.
Comentários ❤️
Nós valorizamos o seu feedback. Relate quaisquer problemas encontrados ao usar o nó de arquivo aqui: https://github.com/onflow/flow-archive/issues.
Conteúdo original em inglês aqui:https://flow.com/post/flow-blockchain-node-operation-archive-node
Top comments (1)
lucarb999.com/ Your work never stops astounding me!
Congrats on accomplishing this commemoration! We realize you have really buckled down for this achievement, and we genuinely value your commitment.